'use strict';

var _ = require('lodash');

var util = require('util');

var assert = require('assert');

var Sqlite = function(config) {

this.output = [];

this.params = [];

this._hasAddedAColumn = false;

this.config = config || {};

};

var Postgres = require('./postgres');

util.inherits(Sqlite, Postgres);

Sqlite.prototype._myClass = Sqlite;

Sqlite.prototype._arrayAggFunctionName = 'GROUP_CONCAT';

Sqlite.prototype.visitReplace = function(replace) {

var self = this;

// don't use table.column for replaces

this._visitedReplace = true;

var result = ['REPLACE'];

result = result.concat(replace.nodes.map(this.visit.bind(this)));

result.push('INTO ' + this.visit(this._queryNode.table.toNode()));

result.push('(' + replace.columns.map(this.visit.bind(this)).join(', ') + ')');

var paramNodes = replace.getParameters();

if (paramNodes.length > 0) {

var paramText = paramNodes.map(function (paramSet) {

return paramSet.map(function (param) {

return self.visit(param);

}).join(', ');

}).map(function (param) {

return '('+param+')';

}).join(', ');

result.push('VALUES', paramText);

if (result.slice(2, 5).join(' ') === '() VALUES ()') {

result.splice(2, 3, 'DEFAULT VALUES');

}

}

this._visitedReplace = false;

return result;

};

Sqlite.prototype._getParameterValue = function(value) {

if (Buffer.isBuffer(value)) {

value = 'x' + this._getParameterValue(value.toString('hex'));

} else if (value instanceof Date && this.config.dateTimeMillis) {

value = value.getTime();

} else if('boolean' === typeof value) {

value = value ? 1 : 0;

} else if(_.isArray(value)) {

value = Postgres.prototype._getParameterValue.call(this, JSON.stringify(value));

} else {

value = Postgres.prototype._getParameterValue.call(this, value);

}

return value;

};

Sqlite.prototype.visitDefault = function() {

throw new Error('SQLite requires that all rows of a multi-row insert are for the same columns.');

};

Sqlite.prototype.visitDropColumn = function() {

throw new Error('SQLite does not allow dropping columns.');

};

Sqlite.prototype.visitFunctionCall = function (functionCall) {

var _this = this;

this._visitingFunctionCall = true;

function _left() {

// convert LEFT(column,4) to SUBSTR(column,1,4)

var nodes = functionCall.nodes.map(_this.visit.bind(_this));

if (nodes.length != 2) throw new Error('Not enough parameters passed to LEFT function.');

var txt = "SUBSTR(" + (nodes[0] + '') + ', 1, ' + (nodes[1] + '') + ')';

return txt;

}

function _right() {

// convert RIGHT(column,4) to SUBSTR(column,-4)

var nodes = functionCall.nodes.map(_this.visit.bind(_this));

if (nodes.length != 2) throw new Error('Not enough parameters passed to RIGHT function.');

var txt = "SUBSTR(" + (nodes[0] + '') + ', -' + (nodes[1] + '') + ')';

return txt;

}

function _extract() {

var nodes = functionCall.nodes.map(_this.visit.bind(_this));

if (nodes.length != 1) throw new Error('Not enough parameters passed to ' + functionCall.name + ' function');

var format;

switch (functionCall.name) {

case 'YEAR':

format = "'%Y'";

break;

case 'MONTH':

format = "'%m'";

break;

case 'DAY':

format = "'%d'";

break;

case 'HOUR':

format = "'%H'";

break;

}

var col = (nodes[0] + '');

if (_this.config.dateTimeMillis) {

// Convert to a datetime before running the strftime function

// Sqlite unix epoch is in seconds, but javascript is milliseconds.

col = 'datetime(' + col + '/1000, "unixepoch")';

}

var txt = 'strftime(' + format + ', ' + col + ')';

return txt;

}

var txt = "";

var name = functionCall.name;

// Override LEFT and RIGHT and convert to SUBSTR

if (name == "LEFT") txt = _left();

else if (name == "RIGHT") txt = _right();

// Override date functions since sqlite uses strftime

else if (['YEAR', 'MONTH', 'DAY', 'HOUR'].indexOf(functionCall.name) >= 0) txt = _extract();

else if ('CURRENT_TIMESTAMP' == functionCall.name) txt = functionCall.name;

else txt = name + '(' + functionCall.nodes.map(this.visit.bind(this)).join(', ') + ')';

this._visitingFunctionCall = false;

return [txt];

};

Sqlite.prototype.visitTruncate = function(truncate) {

var result = ['DELETE FROM'];

result = result.concat(truncate.nodes.map(this.visit.bind(this)));

return result;

};

Sqlite.prototype.visitRenameColumn = function() {

throw new Error('SQLite does not allow renaming columns.');

};

Sqlite.prototype.visitOnDuplicate = function() {

throw new Error('SQLite does not allow onDuplicate clause.');

};

Sqlite.prototype.visitOnConflict = function(onConflict) {

throw new Error('Sqlite does not allow onConflict clause.');

};

Sqlite.prototype.visitReturning = function() {

throw new Error('SQLite does not allow returning clause.');

};

Sqlite.prototype.visitForUpdate = function() {

throw new Error('SQLite does not allow FOR UPDATE clause.');

};

Sqlite.prototype.visitForShare = function() {

throw new Error('SQLite does not allow FOR SHARE clause.');

};

Sqlite.prototype.visitAddColumn = function(addColumn) {

assert(!this._hasAddedAColumn, 'SQLite can not add more that one column at a time');

var result = Postgres.prototype.visitAddColumn.call(this, addColumn);

this._hasAddedAColumn = true;

return result;

};

Sqlite.prototype.visitIndexes = function(node) {

var tableName = this.visit(this._queryNode.table.toNode())[0];

return "PRAGMA INDEX_LIST(" + tableName + ")";

};

Sqlite.prototype.visitCascade = function() {

throw new Error('Sqlite do not support CASCADE in DROP TABLE');

};

Sqlite.prototype.visitRestrict = function() {

throw new Error('Sqlite do not support RESTRICT in DROP TABLE');

};

Sqlite.prototype.visitBinary = function(binary) {

if(binary.operator === '@@'){

binary.operator = 'MATCH';

var ret = Sqlite.super_.prototype.visitBinary.call(this, binary);

binary.operator = '@@';

return ret;

}

return Sqlite.super_.prototype.visitBinary.call(this, binary);

};

Sqlite.prototype.visitOrIgnore = function() {

return ['OR IGNORE'];

};

module.exports = Sqlite;