jaydata/public/jaydataproviders/SqLiteProvider.js

Cross-platform HTML5 data-management, JavaScript Language Query (JSLQ) support for OData, SQLite, WebSQL, IndexedDB, YQL and Facebook (packaged for Node.JS)

// JayData 1.5.10 
// Dual licensed under MIT and GPL v2
// Copyright JayStack Technologies (http://jaydata.org/licensing)
//
// JayData is a standards-based, cross-platform Javascript library and a set of
// practices to access and manipulate data from various online and offline sources.
//
// Credits:
//     Hajnalka Battancs, Dániel József, János Roden, László Horváth, Péter Nochta
//     Péter Zentai, Róbert Bónay, Szabolcs Czinege, Viktor Borza, Viktor Lázár,
//     Zoltán Gyebrovszki, Gábor Dolla
//
// More info: http://jaydata.org
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define("jaydata/sqlite",["jaydata/core"],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.$data = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.DbCommand', null, null, {
    connection: {},
    parameters: {},
    execute: function execute(callback) {
        _core.Guard.raise("Pure class");
    }
}, null);

},{"jaydata/core":"jaydata/core"}],2:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.DbConnection', null, null, {
    connectionParams: {},
    database: {},
    isOpen: function isOpen() {
        _core.Guard.raise("Pure class");
    },
    open: function open() {
        _core.Guard.raise("Pure class");
    },
    close: function close() {
        _core.Guard.raise("Pure class");
    },
    createCommand: function createCommand() {
        _core.Guard.raise("Pure class");
    }
}, null);

},{"jaydata/core":"jaydata/core"}],3:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.jayStorageClient.JayStorageCommand', _core2.default.dbClient.DbCommand, null, {
    constructor: function constructor(con, queryStr, params) {
        this.query = queryStr;
        this.connection = con;
        this.parameters = params;
    },
    executeNonQuery: function executeNonQuery(callback) {
        // TODO
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error);
    },
    executeQuery: function executeQuery(callback) {
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error);
    },
    exec: function exec(query, parameters, callback, errorhandler) {
        if (parameters == null || parameters == undefined) {
            parameters = {};
        }
        var single = false;
        if (!(query instanceof Array)) {
            single = true;
            query = [query];
            parameters = [parameters];
        }

        var provider = this;
        var results = [];
        var remainingCommands = query.length;
        var decClb = function decClb() {
            if (--remainingCommands == 0) {
                callback(single ? results[0] : results);
            }
        };

        query.forEach(function (q, i) {
            if (q) {
                _core2.default.ajax({
                    url: 'http' + (this.connection.connectionParams.storage.ssl ? 's' : '') + '://' + this.connection.connectionParams.storage.src.replace('http://', '').replace('https://', '') + '?db=' + this.connection.connectionParams.storage.key,
                    type: 'POST',
                    headers: {
                        'X-PINGOTHER': 'pingpong'
                    },
                    data: { query: q, parameters: parameters[i] },
                    dataType: 'json',
                    contentType: 'application/json;charset=UTF-8',
                    success: function success(data) {
                        if (data && data.error) {
                            console.log('JayStorage error', data.error);
                            errorhandler(data.error);
                            return;
                        }
                        if (this.lastID) {
                            results[i] = { insertId: this.lastID, rows: (data || { rows: [] }).rows };
                        } else results[i] = { rows: (data || { rows: [] }).rows };
                        decClb();
                    }
                });
            } else {
                results[i] = null;
                decClb();
            }
        }, this);
    }
}, null);

},{"jaydata/core":"jaydata/core"}],4:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.jayStorageClient.JayStorageConnection', _core2.default.dbClient.DbConnection, null, {
    constructor: function constructor(params) {
        this.connectionParams = params;
    },
    isOpen: function isOpen() {
        return true;
        //return this.database !== null && this.database !== undefined;
    },
    open: function open() {
        /*if (this.database == null) {
            var p = this.connectionParams;
            this.database = new sqLiteModule.Database(p.fileName);
        }*/
    },
    close: function close() {
        //not supported yet (performance issue)
    },
    createCommand: function createCommand(queryStr, params) {
        var cmd = new _core2.default.dbClient.jayStorageClient.JayStorageCommand(this, queryStr, params);
        return cmd;
    }
}, null);

},{"jaydata/core":"jaydata/core"}],5:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.openDatabaseClient.OpenDbCommand', _core2.default.dbClient.DbCommand, null, {
    constructor: function constructor(con, queryStr, params) {
        this.query = queryStr;
        this.connection = con;
        this.parameters = params;
    },
    executeNonQuery: function executeNonQuery(callback, tran, isWrite) {
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error, tran, isWrite);
    },
    executeQuery: function executeQuery(callback, tran, isWrite) {
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error, tran, isWrite);
    },
    exec: function exec(query, parameters, callback, errorhandler, transaction, isWrite) {
        // suspicious code
        /*if (console) {
            //console.log(query);
        }*/
        this.connection.open({
            error: errorhandler,
            success: function success(tran) {
                var single = false;
                if (!(query instanceof Array)) {
                    single = true;
                    query = [query];
                    parameters = [parameters];
                }

                var results = [];
                var remainingCommands = 0;

                function decClb() {
                    if (--remainingCommands == 0) {
                        callback(single ? results[0] : results, transaction);
                    }
                }

                query.forEach(function (q, i) {
                    remainingCommands++;
                    if (q) {
                        tran.executeSql(query[i], parameters[i], function (trx, result) {
                            var r = { rows: [] };
                            try {
                                r.insertId = result.insertId;
                            } catch (e) {}
                            if (typeof r.insertId !== 'number') {
                                // If insertId is present, no rows are returned
                                r.rowsAffected = result.rowsAffected;
                                var maxItem = result.rows.length;
                                for (var j = 0; j < maxItem; j++) {
                                    r.rows.push(result.rows.item(j));
                                }
                            }
                            results[i] = r;
                            decClb(trx);
                        }, function (trx, err) {
                            var _q = q;
                            var _i = i;

                            if (errorhandler) errorhandler(err);

                            return true;
                        });
                    } else {
                        results[i] = null;
                        decClb();
                    }
                });
            }
        }, transaction, isWrite);
    }
}, null);

},{"jaydata/core":"jaydata/core"}],6:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.openDatabaseClient.OpenDbConnection', _core2.default.dbClient.DbConnection, null, {
    constructor: function constructor(params) {
        this.connectionParams = params;
    },
    isOpen: function isOpen() {
        return this.database !== null && this.database !== undefined && this.transaction !== null && this.transaction !== undefined;
    },
    open: function open(callBack, tran, isWrite) {
        if (isWrite === undefined) isWrite = true;

        callBack.oncomplete = callBack.oncomplete || function () {};
        if (tran) {
            callBack.success(tran.transaction);
        } else if (this.database) {
            if (isWrite) {
                this.database.transaction(function (tran) {
                    callBack.success(tran);
                }, callBack.error, callBack.oncomplete);
            } else {
                this.database.readTransaction(function (tran) {
                    callBack.success(tran);
                }, callBack.error, callBack.oncomplete);
            }
        } else {
            var p = this.connectionParams;
            var con = this;
            this.database = openDatabase(p.fileName, p.version, p.displayName, p.maxSize);
            if (!this.database.readTransaction) {
                this.database.readTransaction = function () {
                    con.database.transaction.apply(con.database, arguments);
                };
            }

            if (isWrite) {
                this.database.transaction(function (tran) {
                    callBack.success(tran);
                }, callBack.error, callBack.oncomplete);
            } else {
                this.database.readTransaction(function (tran) {
                    callBack.success(tran);
                }, callBack.error, callBack.oncomplete);
            }
        }
    },
    close: function close() {
        this.transaction = undefined;
        this.database = undefined;
    },
    createCommand: function createCommand(queryStr, params) {
        var cmd = new _core2.default.dbClient.openDatabaseClient.OpenDbCommand(this, queryStr, params);
        return cmd;
    }
}, null);

},{"jaydata/core":"jaydata/core"}],7:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.sqLiteNJClient.SqLiteNjCommand', _core2.default.dbClient.DbCommand, null, {
    constructor: function constructor(con, queryStr, params) {
        this.query = queryStr;
        this.connection = con;
        this.parameters = params;
    },
    executeNonQuery: function executeNonQuery(callback) {
        // TODO
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error);
    },
    executeQuery: function executeQuery(callback) {
        callback = _core2.default.PromiseHandlerBase.createCallbackSettings(callback);
        this.exec(this.query, this.parameters, callback.success, callback.error);
    },
    exec: function exec(query, parameters, callback, errorhandler) {
        if (!this.connection.isOpen()) {
            this.connection.open();
        }
        if (parameters == null || parameters == undefined) {
            parameters = {};
        }
        var single = false;
        if (!(query instanceof Array)) {
            single = true;
            query = [query];
            parameters = [parameters];
        }

        var provider = this;
        var results = [];
        var remainingCommands = 0;
        var decClb = function decClb() {
            if (--remainingCommands == 0) {
                provider.connection.database.exec('COMMIT');
                callback(single ? results[0] : results);
            }
        };
        provider.connection.database.exec('BEGIN');
        query.forEach(function (q, i) {
            remainingCommands++;
            if (q) {
                var sqlClb = function sqlClb(error, rows) {
                    if (error != null) {
                        errorhandler(error);
                        return;
                    }
                    if (this.lastID) {
                        results[i] = { insertId: this.lastID, rows: [] };
                    } else {
                        results[i] = { rows: rows };
                    }
                    decClb();
                };

                var stmt = provider.connection.database.prepare(q, parameters[i]);
                if (q.indexOf('SELECT') == 0) {
                    stmt.all(sqlClb);
                } else {
                    stmt.run(sqlClb);
                }
                stmt.finalize();
            } else {
                results[i] = null;
                decClb();
            }
        }, this);
    }
}, null);

},{"jaydata/core":"jaydata/core"}],8:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.Class.define('$data.dbClient.sqLiteNJClient.SqLiteNjConnection', _core2.default.dbClient.DbConnection, null, {
    constructor: function constructor(params) {
        this.connectionParams = params;
    },
    isOpen: function isOpen() {
        return this.database !== null && this.database !== undefined;
    },
    open: function open() {
        if (this.database == null) {
            var p = this.connectionParams;
            this.database = new sqLiteModule.Database(p.fileName);
        }
    },
    close: function close() {
        //not supported yet (performance issue)
    },
    createCommand: function createCommand(queryStr, params) {
        var cmd = new _core2.default.dbClient.sqLiteNJClient.SqLiteNjCommand(this, queryStr, params);
        return cmd;
    }
}, null);

},{"jaydata/core":"jaydata/core"}],9:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

(0, _core.$C)('$data.sqLite.sqLite_ModelBinderCompiler', _core2.default.Expressions.EntityExpressionVisitor, null, {
    constructor: function constructor(query, context) {
        this._query = query;
        this.sqlContext = context;
        this._sqlBuilder = _core2.default.sqLite.SqlBuilder.create(context.sets, context.entityContext);
    },
    VisitSingleExpression: function VisitSingleExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitSomeExpression: function VisitSomeExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitFindExpression: function VisitFindExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitEveryExpression: function VisitEveryExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitToArrayExpression: function VisitToArrayExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitFirstExpression: function VisitFirstExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitForEachExpression: function VisitForEachExpression(expression) {
        this._defaultModelBinder(expression);
    },
    VisitCountExpression: function VisitCountExpression(expression) {
        var builder = _core.Container.createqueryBuilder();

        builder.modelBinderConfig['$type'] = _core2.default.Array;
        builder.selectModelBinderProperty('$item');
        builder.modelBinderConfig['$type'] = _core2.default.Integer;
        builder.modelBinderConfig['$source'] = 'cnt';
        builder.resetModelBinderProperty();
        this._query.modelBinderConfig = builder.modelBinderConfig;
    },

    VisitExpression: function VisitExpression(expression, builder) {
        var projVisitor = _core.Container.createFindProjectionVisitor();
        projVisitor.Visit(expression);

        if (projVisitor.projectionExpression) {
            this.Visit(projVisitor.projectionExpression, builder);
        } else {
            this.DefaultSelection(builder);
        }
    },
    _defaultModelBinder: function _defaultModelBinder(expression) {
        var builder = _core.Container.createqueryBuilder();
        builder.modelBinderConfig['$type'] = _core2.default.Array;
        builder.modelBinderConfig['$item'] = {};
        builder.selectModelBinderProperty('$item');

        this.VisitExpression(expression, builder);

        builder.resetModelBinderProperty();
        this._query.modelBinderConfig = builder.modelBinderConfig;
    },
    _addPropertyToModelBinderConfig: function _addPropertyToModelBinderConfig(elementType, builder) {
        var storageModel = this._query.context._storageModel.getStorageModel(elementType);
        elementType.memberDefinitions.getPublicMappedProperties().forEach(function (prop) {
            if (!storageModel || storageModel && !storageModel.Associations[prop.name] && !storageModel.ComplexTypes[prop.name]) {
                if (prop.key) {
                    if (this.currentObjectFieldName) {
                        builder.addKeyField(this.currentObjectFieldName + '__' + prop.name);
                    } else {
                        builder.addKeyField(prop.name);
                    }
                }
                if (this.currentObjectFieldName) {
                    builder.modelBinderConfig[prop.name] = this.currentObjectFieldName + '__' + prop.name;
                } else {
                    builder.modelBinderConfig[prop.name] = prop.name;
                }
            }
        }, this);
        if (storageModel) {
            this._addComplexTypeProperties(storageModel.ComplexTypes, builder);
        }
    },
    _addComplexTypeProperties: function _addComplexTypeProperties(complexTypes, builder) {
        complexTypes.forEach(function (ct) {

            builder.selectModelBinderProperty(ct.FromPropertyName);
            builder.modelBinderConfig['$type'] = ct.ToType;
            var tmpPrefix = this.currentObjectFieldName;
            if (this.currentObjectFieldName) {
                this.currentObjectFieldName += '__';
            } else {
                this.currentObjectFieldName = '';
            }
            this.currentObjectFieldName += ct.FromPropertyName;
            //recursion
            this._addPropertyToModelBinderConfig(ct.ToType, builder);
            //reset model binder property
            builder.popModelBinderProperty();
            this.currentObjectFieldName = tmpPrefix;
        }, this);
    },
    DefaultSelection: function DefaultSelection(builder) {
        //no projection, get all item from entitySet
        builder.modelBinderConfig['$type'] = this._query.defaultType;
        var storageModel = this._query.context._storageModel.getStorageModel(this._query.defaultType);

        var needPrefix = this.sqlContext.infos.filter(function (i) {
            return i.IsMapped;
        }).length > 1;
        if (needPrefix) {
            this.currentObjectFieldName = this._sqlBuilder.getExpressionAlias(this.sqlContext.sets[0]);
        }
        this._addPropertyToModelBinderConfig(this._query.defaultType, builder);
        this.sqlContext.infos.forEach(function (info, infoIndex) {
            if (infoIndex > 0 && info.IsMapped) {
                var pathFragments = info.NavigationPath.split('.');
                pathFragments.shift();
                pathFragments.forEach(function (pathFragment, index) {
                    if (!pathFragment) {
                        return;
                    }
                    if (!builder.modelBinderConfig[pathFragment]) {
                        builder.selectModelBinderProperty(pathFragment);
                        var isArray = false;
                        if (info.Association.associationInfo.ToMultiplicity === '*' && pathFragments.length - 1 === index) {
                            builder.modelBinderConfig['$type'] = _core2.default.Array;
                            builder.selectModelBinderProperty('$item');
                            isArray = true;
                        }

                        builder.modelBinderConfig['$type'] = this.sqlContext.sets[infoIndex].elementType;
                        this.currentObjectFieldName = this._sqlBuilder.getExpressionAlias(this.sqlContext.sets[infoIndex]);
                        this._addPropertyToModelBinderConfig(this.sqlContext.sets[infoIndex].elementType, builder);
                        if (isArray) {
                            builder.popModelBinderProperty();
                        }
                    } else {
                        builder.selectModelBinderProperty(pathFragment);
                    }
                }, this);
                for (var i = 0; i < pathFragments.length; i++) {
                    builder.popModelBinderProperty();
                }
            }
        }, this);
    },
    VisitProjectionExpression: function VisitProjectionExpression(expression, builder) {
        this.hasProjection = true;
        this.Visit(expression.selector, builder);

        if (expression.selector && expression.selector.expression instanceof _core2.default.Expressions.ObjectLiteralExpression) {
            builder.modelBinderConfig['$type'] = expression.projectionAs || builder.modelBinderConfig['$type'] || _core2.default.Object;
        }
    },
    VisitParametricQueryExpression: function VisitParametricQueryExpression(expression, builder) {
        if (expression.expression instanceof _core2.default.Expressions.EntityExpression) {
            this.VisitEntityAsProjection(expression.expression, builder);
            builder.modelBinderConfig['$keys'].unshift('rowid$$');
        } else if (expression.expression instanceof _core2.default.Expressions.EntitySetExpression) {
            this.currentObjectFieldName = this._sqlBuilder.getExpressionAlias(expression.expression);
            this.VisitEntitySetAsProjection(expression.expression, builder);
            builder.modelBinderConfig['$keys'] = ['rowid$$'];
        } else if (expression.expression instanceof _core2.default.Expressions.ComplexTypeExpression) {
            this.VisitEntityAsProjection(expression.expression, builder);
        } else {
            builder.modelBinderConfig['$keys'] = ['rowid$$'];
            this.Visit(expression.expression, builder);
            if (expression.expression instanceof _core2.default.Expressions.EntityFieldExpression) {
                builder.modelBinderConfig['$source'] = 'd';
            }
        }
    },
    VisitConstantExpression: function VisitConstantExpression(expression, builder) {
        builder.modelBinderConfig['$type'] = expression.type;
        builder.modelBinderConfig['$source'] = this.currentObjectFieldName;
    },
    VisitEntityAsProjection: function VisitEntityAsProjection(expression, builder) {
        this.Visit(expression.source, builder);
        builder.modelBinderConfig['$type'] = expression.entityType;
        this._addPropertyToModelBinderConfig(expression.entityType, builder);
    },
    VisitEntitySetAsProjection: function VisitEntitySetAsProjection(expression, builder) {
        builder.modelBinderConfig['$type'] = _core2.default.Array;
        builder.selectModelBinderProperty('$item');
        builder.modelBinderConfig['$type'] = expression.elementType;
        this._addPropertyToModelBinderConfig(expression.elementType, builder);
        builder.popModelBinderProperty();
    },
    VisitComplexTypeExpression: function VisitComplexTypeExpression(expression, builder) {
        return expression;
    },
    VisitEntityFieldExpression: function VisitEntityFieldExpression(expression, builder) {
        this.Visit(expression.source, builder);
        this.Visit(expression.selector, builder);
    },
    VisitMemberInfoExpression: function VisitMemberInfoExpression(expression, builder) {
        if (expression.memberDefinition instanceof _core2.default.MemberDefinition) {
            builder.modelBinderConfig['$type'] = expression.memberDefinition.type;
            if (expression.memberDefinition.storageModel && expression.memberName in expression.memberDefinition.storageModel.ComplexTypes) {
                this._addPropertyToModelBinderConfig(_core.Container.resolveType(expression.memberDefinition.type), builder);
            } else {
                builder.modelBinderConfig['$source'] = this.currentObjectFieldName;
            }
        }
    },
    VisitEntitySetExpression: function VisitEntitySetExpression(expression, builder) {
        if (expression.source instanceof _core2.default.Expressions.EntityExpression) {
            this.Visit(expression.source, builder);
            this.Visit(expression.selector, builder);
        }
    },
    VisitEntityExpression: function VisitEntityExpression(expression, builder) {
        this.Visit(expression.source, builder);
    },
    VisitAssociationInfoExpression: function VisitAssociationInfoExpression(expression, builder) {
        if ('$selector' in builder.modelBinderConfig && builder.modelBinderConfig.$selector.length > 0) {
            builder.modelBinderConfig.$selector += '.';
        } else {
            builder.modelBinderConfig['$selector'] = 'json:';
        }
        builder.modelBinderConfig['$selector'] += expression.associationInfo.FromPropertyName;
    },
    VisitSimpleBinaryExpression: function VisitSimpleBinaryExpression(expression, builder) {
        this.Visit(expression.left, builder);
        this.Visit(expression.right, builder);
        builder.modelBinderConfig['$type'] = undefined;
    },
    VisitObjectLiteralExpression: function VisitObjectLiteralExpression(expression, builder) {
        builder.modelBinderConfig['$type'] = _core2.default.Object;
        expression.members.forEach(function (of) {
            this.Visit(of, builder);
        }, this);
    },
    VisitObjectFieldExpression: function VisitObjectFieldExpression(expression, builder) {
        var tempFieldName = this.currentObjectFieldName;
        builder.selectModelBinderProperty(expression.fieldName);
        if (this.currentObjectFieldName) {
            this.currentObjectFieldName += '__';
        } else {
            this.currentObjectFieldName = '';
        }
        this.currentObjectFieldName += expression.fieldName;

        if (expression.expression instanceof _core2.default.Expressions.EntityExpression || expression.expression instanceof _core2.default.Expressions.ComplexTypeExpression) {
            this.VisitEntityAsProjection(expression.expression, builder);
        } else if (expression.expression instanceof _core2.default.Expressions.EntitySetExpression) {
            this.VisitEntitySetAsProjection(expression.expression, builder);
        } else {
            this.Visit(expression.expression, builder);
        }

        this.currentObjectFieldName = tempFieldName;

        builder.popModelBinderProperty();
    }
});

},{"jaydata/core":"jaydata/core"}],10:[function(_dereq_,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SqlStatementBlocks = undefined;

var _core = _dereq_("jaydata/core");

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SqlStatementBlocks = exports.SqlStatementBlocks = {
    beginGroup: "(",
    endGroup: ")",
    nameSeparator: ".",
    valueSeparator: ", ",
    select: "SELECT ",
    where: " WHERE ",
    from: " FROM ",
    skip: " OFFSET ",
    take: " LIMIT ",
    parameter: "?",
    order: " ORDER BY ",
    as: " AS ",
    scalarFieldName: 'd',
    rowIdName: 'rowid$$',
    count: 'select count(*) cnt from ('
};
(0, _core.$C)('$data.sqLite.SqlBuilder', _core2.default.queryBuilder, null, {
    constructor: function constructor(sets, context) {
        this.sets = sets;
        this.entityContext = context;
    },
    getExpressionAlias: function getExpressionAlias(setExpression) {
        var idx = this.sets.indexOf(setExpression);
        if (idx == -1) {
            idx = this.sets.push(setExpression) - 1;
        }
        return "T" + idx;
    }
});

(0, _core.$C)('$data.sqLite.SqlCompiler', _core2.default.Expressions.EntityExpressionVisitor, null, {
    constructor: function constructor(queryExpression, context) {
        this.queryExpression = queryExpression;
        this.sets = context.sets;
        this.infos = context.infos;
        this.entityContext = context.entityContext;
        this.associations = [];
        this.filters = [];
        this.newFilters = {};
        this.sortedFilterPart = ['projection', 'from', 'filter', 'order', 'take', 'skip'];
    },
    compile: function compile() {
        var sqlBuilder = _core2.default.sqLite.SqlBuilder.create(this.sets, this.entityContext);
        this.Visit(this.queryExpression, sqlBuilder);

        if (sqlBuilder.getTextPart('projection') === undefined) {
            this.VisitDefaultProjection(sqlBuilder);
        }
        sqlBuilder.selectTextPart("result");
        this.sortedFilterPart.forEach(function (part) {
            var part = sqlBuilder.getTextPart(part);
            if (part) {
                sqlBuilder.addText(part.text);
                sqlBuilder.selectedFragment.params = sqlBuilder.selectedFragment.params.concat(part.params);
            }
        }, this);
        var countPart = sqlBuilder.getTextPart('count');
        if (countPart !== undefined) {
            sqlBuilder.selectedFragment.text = countPart.text + sqlBuilder.selectedFragment.text;
            sqlBuilder.addText(SqlStatementBlocks.endGroup);
            sqlBuilder.selectedFragment.params = sqlBuilder.selectedFragment.params.concat(countPart.params);
        }
        sqlBuilder.resetModelBinderProperty();
        this.filters.push(sqlBuilder);
    },

    VisitToArrayExpression: function VisitToArrayExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);
    },
    VisitCountExpression: function VisitCountExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);
        sqlBuilder.selectTextPart('count');
        sqlBuilder.addText(SqlStatementBlocks.count);
    },
    VisitFilterExpression: function VisitFilterExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);
        sqlBuilder.selectTextPart('filter');
        sqlBuilder.addText(SqlStatementBlocks.where);
        var filterCompiler = _core2.default.sqLite.SqlFilterCompiler.create();
        filterCompiler.Visit(expression.selector, sqlBuilder);
        return expression;
    },

    VisitOrderExpression: function VisitOrderExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);
        sqlBuilder.selectTextPart('order');
        if (this.addOrders) {
            sqlBuilder.addText(SqlStatementBlocks.valueSeparator);
        } else {
            this.addOrders = true;
            sqlBuilder.addText(SqlStatementBlocks.order);
        }
        var orderCompiler = _core2.default.sqLite.SqlOrderCompiler.create();
        orderCompiler.Visit(expression, sqlBuilder);

        return expression;
    },
    VisitPagingExpression: function VisitPagingExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);

        switch (expression.nodeType) {
            case _core2.default.Expressions.ExpressionType.Skip:
                sqlBuilder.selectTextPart('skip');
                sqlBuilder.addText(SqlStatementBlocks.skip);break;
            case _core2.default.Expressions.ExpressionType.Take:
                sqlBuilder.selectTextPart('take');
                sqlBuilder.addText(SqlStatementBlocks.take);break;
            default:
                _core.Guard.raise("Not supported nodeType");break;
        }
        var pagingCompiler = _core2.default.sqLite.SqlPagingCompiler.create();
        pagingCompiler.Visit(expression, sqlBuilder);
        return expression;
    },
    VisitProjectionExpression: function VisitProjectionExpression(expression, sqlBuilder) {
        this.Visit(expression.source, sqlBuilder);
        sqlBuilder.selectTextPart('projection');
        this.hasProjection = true;
        sqlBuilder.addText(SqlStatementBlocks.select);
        var projectonCompiler = _core2.default.sqLite.SqlProjectionCompiler.create();
        projectonCompiler.Visit(expression, sqlBuilder);
    },
    VisitEntitySetExpression: function VisitEntitySetExpression(expression, sqlBuilder) {
        sqlBuilder.selectTextPart('from');
        sqlBuilder.addText(SqlStatementBlocks.from);
        sqlBuilder.sets.forEach(function (es, setIndex) {

            if (setIndex > 0) {
                sqlBuilder.addText(" \n\tLEFT OUTER JOIN ");
            }

            var alias = sqlBuilder.getExpressionAlias(es);
            sqlBuilder.addText(es.instance.tableName + ' ');
            sqlBuilder.addText(alias);

            if (setIndex > 0) {
                sqlBuilder.addText(" ON (");
                var toSet = this.infos[setIndex];
                var toPrefix = "T" + toSet.AliasNumber;
                var fromSetName = toSet.NavigationPath.substring(0, toSet.NavigationPath.lastIndexOf('.'));
                var temp = this.infos.filter(function (inf) {
                    return inf.NavigationPath == fromSetName;
                }, this);
                var fromPrefix = "T0";
                if (temp.length > 0) {
                    fromPrefix = "T" + temp[0].AliasNumber;
                }
                toSet.Association.associationInfo.ReferentialConstraint.forEach(function (constrain, index) {
                    if (index > 0) {
                        sqlBuilder.addText(" AND ");
                    }
                    sqlBuilder.addText(fromPrefix + "." + constrain[toSet.Association.associationInfo.From]);
                    sqlBuilder.addText(" = ");
                    sqlBuilder.addText(toPrefix + "." + constrain[toSet.Association.associationInfo.To]);
                }, this);
                sqlBuilder.addText(")");
            }
        }, this);
    },
    VisitDefaultProjection: function VisitDefaultProjection(sqlBuilder) {
        sqlBuilder.selectTextPart('projection');
        var needAlias = this.infos.filter(function (i) {
            return i.IsMapped;
        }).length > 1;
        if (sqlBuilder.sets.length > 1) {
            sqlBuilder.addText(SqlStatementBlocks.select);
            sqlBuilder.sets.forEach(function (set, masterIndex) {

                if (this.infos[masterIndex].IsMapped) {
                    var alias = sqlBuilder.getExpressionAlias(set);
                    set.storageModel.PhysicalType.memberDefinitions.getPublicMappedProperties().forEach(function (memberDef, index) {
                        if (index > 0 || masterIndex > 0) {
                            sqlBuilder.addText(SqlStatementBlocks.valueSeparator);
                        }
                        sqlBuilder.addText(alias + ".");
                        sqlBuilder.addText(memberDef.name);
                        if (needAlias) {
                            sqlBuilder.addText(SqlStatementBlocks.as);
                            sqlBuilder.addText(alias + "__" + memberDef.name);
                        }
                    }, this);
                }
            }, this);
        } else {
            sqlBuilder.addText("SELECT *");
        }
    }
});

_core2.default.Expressions.ExpressionNode.prototype.monitor = function (monitorDefinition, context) {
    var m = _core2.default.sqLite.SqlExpressionMonitor.create(monitorDefinition);
    return m.Visit(this, context);
};

(0, _core.$C)('$data.storageProviders.sqLite.SQLiteCompiler', null, null, {
    compile: function compile(query) {
        /// <param name="query" type="$data.Query" />
        var expression = query.expression;
        var context = { sets: [], infos: [], entityContext: query.context };

        var optimizedIncludeExpression = expression.monitor({
            MonitorEntitySetExpression: function MonitorEntitySetExpression(expression, context) {
                if (expression.source instanceof _core2.default.Expressions.EntityContextExpression && context.sets.indexOf(expression) == -1) {
                    this.backupEntitySetExpression = expression;
                }
            },
            VisitCountExpression: function VisitCountExpression(expression, context) {
                context.hasCountFrameOperator = true;
                return expression;
            },
            MutateIncludeExpression: function MutateIncludeExpression(expression, context) {
                var result = null;
                if (context.hasCountFrameOperator) {
                    result = expression.source;
                } else {
                    var origSelector = expression.selector.value;
                    _core.Container.createCodeExpression("function(it){return it." + origSelector + ";}", null);

                    var jsCodeTree = _core.Container.createCodeParser(this.backupEntitySetExpression.source.instance).createExpression("function(it){return it." + origSelector + ";}");
                    var code2entity = _core.Container.createCodeToEntityConverter(this.backupEntitySetExpression.source.instance);
                    var includeSelector = code2entity.Visit(jsCodeTree, { queryParameters: undefined, lambdaParameters: [this.backupEntitySetExpression] });

                    result = _core.Container.createIncludeExpression(expression.source, includeSelector);
                }
                return result;
            }
        }, context);

        var optimizedExpression = optimizedIncludeExpression.monitor({
            MonitorEntitySetExpression: function MonitorEntitySetExpression(expression, context) {
                if (expression.source instanceof _core2.default.Expressions.EntityContextExpression && context.sets.indexOf(expression) == -1) {
                    context.sets.push(expression);
                    context.infos.push({ AliasNumber: 0, Association: null, FromType: null, FromPropertyName: null, IsMapped: true });
                }
            },
            MutateEntitySetExpression: function MutateEntitySetExpression(expression, context) {
                if (expression.source instanceof _core2.default.Expressions.EntityContextExpression) {
                    this.backupContextExpression = expression.source;
                    this.path = "";
                    return expression;
                }
                if (expression.selector.associationInfo.FromMultiplicity == "0..1" && expression.selector.associationInfo.FromMultiplicity == "*") {
                    _core.Guard.raise("Not supported query on this navigation property: " + expression.selector.associationInfo.From + " " + expression.selector.associationInfo.FromPropertyName);
                }

                this.path += '.' + expression.selector.associationInfo.FromPropertyName;
                var info = context.infos.filter(function (inf) {
                    return inf.NavigationPath == this.path;
                }, this);
                if (info.length > 0) {
                    return context.sets[info[0].AliasNumber];
                }
                var memberDefinitions = this.backupContextExpression.instance.getType().memberDefinitions.getMember(expression.storageModel.ItemName);
                if (!memberDefinitions) {
                    _core.Guard.raise("Context schema error");
                }
                var mi = _core.Container.createMemberInfoExpression(memberDefinitions);
                var result = _core.Container.createEntitySetExpression(this.backupContextExpression, mi);
                result.instance = this.backupContextExpression.instance[expression.storageModel.ItemName];
                var aliasNum = context.sets.push(result);
                context.infos.push({
                    AliasNumber: aliasNum - 1,
                    Association: expression.selector,
                    NavigationPath: this.path,
                    IsMapped: this.isMapped
                });
                return result;
            }
        }, context);

        var compiler = _core2.default.sqLite.SqlCompiler.create(optimizedExpression, context);
        compiler.compile();

        var sqlBuilder = _core2.default.sqLite.SqlBuilder.create(this.sets, this.entityContext);

        query.modelBinderConfig = {};
        var modelBinder = _core2.default.sqLite.sqLite_ModelBinderCompiler.create(query, context);
        modelBinder.Visit(optimizedExpression);

        var result = {
            sqlText: compiler.filters[0].selectedFragment.text,
            params: compiler.filters[0].selectedFragment.params,
            modelBinderConfig: query.modelBinderConfig
        };

        return result;
    }
}, null);

},{"jaydata/core":"jaydata/core"}],11:[function(_dereq_,module,exports){
'use strict';

var _core = _dereq_('jaydata/core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_core2.default.SqLiteConverter = {
    fromDb: {
        '$data.Enum': function $dataEnum(v, enumType) {
            return _core2.default.Container.convertTo(v, enumType);
        },
        '$data.Duration': _core2.default.Container.proxyConverter,
        '$data.Day': _core2.default.Container.proxyConverter,
        '$data.Byte': _core2.default.Container.proxyConverter,
        '$data.SByte': _core2.default.Container.proxyConverter,
        '$data.Decimal': _core2.default.Container.proxyConverter,
        '$data.Float': _core2.default.Container.proxyConverter,
        '$data.Int16': _core2.default.Container.proxyConverter,
        '$data.Int64': _core2.default.Container.proxyConverter,
        "$data.Integer": _core2.default.Container.proxyConverter,
        "$data.Int32": _core2.default.Container.proxyConverter,
        "$data.Number": _core2.default.Container.proxyConverter,
        "$data.Date": function $dataDate(dbData) {
            return dbData != null ? new Date(dbData) : dbData;
        },
        "$data.DateTimeOffset": function $dataDateTimeOffset(dbData) {
            return dbData != null ? new Date(dbData) : dbData;
        },
        "$data.Time": _core2.default.Container.proxyConverter,
        "$data.String": _core2.default.Container.proxyConverter,
        "$data.Boolean": function $dataBoolean(b) {
            return _core.Guard.isNullOrUndefined(b) ? b : b === 1 ? true : false;
        },
        "$data.Blob": function $dataBlob(b) {
            return b ? _core2.default.Container.convertTo(atob(b), _core2.default.Blob) : b;
        },
        "$data.Array": function $dataArray() {
            if (arguments.length == 0) return [];
            return arguments[0] ? JSON.parse(arguments[0]) : undefined;
        },
        "$data.Object": function $dataObject(v) {
            try {
                return JSON.parse(v);
            } catch (err) {
                return v;
            }
        },
        "$data.Guid": function $dataGuid(g) {
            return g ? _core2.default.parseGuid(g).toString() : g;
        },
        '$data.GeographyPoint': function $dataGeographyPoint(g) {
            if (g) {
                return new _core2.default.GeographyPoint(JSON.parse(g));
            }return g;
        },
        '$data.GeographyLineString': function $dataGeographyLineString(g) {
            if (g) {
                return new _core2.default.GeographyLineString(JSON.parse(g));
            }return g;
        },
        '$data.GeographyPolygon': function $dataGeographyPolygon(g) {
            if (g) {
                return new _core2.default.GeographyPolygon(JSON.parse(g));
            }return g;
        },
        '$data.GeographyMultiPoint': function $dataGeographyMultiPoint(g) {
            if (g) {
                return new _core2.default.GeographyMultiPoint(JSON.parse(g));
            }return g;
        },
        '$data.GeographyMultiLineString': function $dataGeographyMultiLineString(g) {
            if (g) {
                return new _core2.default.GeographyMultiLineString(JSON.parse(g));
            }return g;
        },
        '$data.GeographyMultiPolygon': function $dataGeographyMultiPolygon(g) {
            if (g) {
                return new _core2.default.GeographyMultiPolygon(JSON.parse(g));
            }return g;
        },
        '$data.GeographyCollection': function $dataGeographyCollection(g) {
            if (g) {
                return new _core2.default.GeographyCollection(JSON.parse(g));
            }return g;
        },
        '$data.GeometryPoint': function $dataGeometryPoint(g) {
            if (g) {
                return new _core2.default.GeometryPoint(JSON.parse(g));
            }return g;
        },
        '$data.GeometryLineString': function $dataGeometryLineString(g) {
            if (g) {
                return new _core2.default.GeometryLineString(JSON.parse(g));
            }return g;
        },
        '$data.GeometryPolygon': function $dataGeometryPolygon(g) {
            if (g) {
                return new _core2.default.GeometryPolygon(JSON.parse(g));
            }return g;
        },
        '$data.GeometryMultiPoint': function $dataGeometryMultiPoint(g) {
            if (g) {
                return new _core2.default.GeometryMultiPoint(JSON.parse(g));
            }return g;
        },
        '$data.GeometryMultiLineString': function $dataGeometryMultiLineString(g) {
            if (g) {
                return new _core2.default.GeometryMultiLineString(JSON.parse(g));
            }return g;
        },
        '$data.GeometryMultiPolygon': function $dataGeometryMultiPolygon(g) {
            if (g) {
                return new _core2.default.GeometryMultiPolygon(JSON.parse(g));
            }return g;
        },
        '$data.GeometryCollection': function $dataGeometryCollection(g) {
            if (g) {
                return new _core2.default.GeometryCollection(JSON.parse(g));
            }return g;
        }
    },
    toDb: {
        '$data.Enum': _core2.default.Container.proxyConverter,
        '$data.Duration': _core2.default.Container.proxyConverter,
        '$data.Day': _core2.default.Container.proxyConverter,
        '$data.Byte': _core2.default.Container.proxyConverter,
        '$data.SByte': _core2.default.Container.proxyConverter,
        '$data.Decimal': _core2.default.Container.proxyConverter,
        '$data.Float': _core2.default.Container.proxyConverter,
        '$data.Int16': _core2.default.Container.proxyConverter,
        '$data.Int64': _core2.default.Container.proxyConverter,
        "$data.Integer": _core2.default.Container.proxyConverter,
        "$data.Int32": _core2.default.Container.proxyConverter,
        "$data.Number": _core2.default.Container.proxyConverter,
        "$data.Date": function $dataDate(date) {
            return date ? date.valueOf() : null;
        },
        "$data.DateTimeOffset": function $dataDateTimeOffset(date) {
            return date ? date.valueOf() : null;
        },
        "$data.Time": _core2.default.Container.proxyConverter,
        "$data.String": _core2.default.Container.proxyConverter,
        "$data.Boolean": function $dataBoolean(b) {
            return _core.Guard.isNullOrUndefine