0
1
Fork 0
hedera-web-mindshore/js/db/model.js

1334 lines
26 KiB
JavaScript
Raw Normal View History

2016-09-26 09:28:47 +00:00
var Connection = require ('./connection');
/**
* Class to handle the Database select results. Also allows
* updates, insertions and deletions on tables where the primary key is
* selected.
*
* Note that table and column names must be unique in the selection query,
* otherwise updates are not allowed on that table/column. If two tables or
* columns have the same name, an alias should be used to make it updatable.
2016-12-20 09:32:17 +00:00
*/
2016-09-26 09:28:47 +00:00
var Model = new Class ();
module.exports = Model;
var Status =
{
CLEAN : 1
,LOADING : 2
,READY : 3
,ERROR : 4
};
var Mode =
{
ON_CHANGE : 1
,ON_DEMAND : 2
};
var Operation =
{
INSERT : 1 << 1
,UPDATE : 1 << 2
,DELETE : 1 << 3
};
var SortWay =
{
ASC : 1
,DESC : 2
};
Model.extend
({
2016-09-26 09:28:47 +00:00
Status: Status
,Mode: Mode
,Operation: Operation
,SortWay: SortWay
});
2016-09-26 09:28:47 +00:00
Model.implement
({
Extends: Vn.Object
,Tag: 'db-model'
,Properties:
{
/**
* The connection used to execute the statement.
2016-12-20 09:32:17 +00:00
*/
conn:
{
2016-09-26 09:28:47 +00:00
type: Connection
,set: function (x)
{
this._conn = x;
2015-07-10 12:30:08 +00:00
this._autoLoad ();
}
,get: function ()
{
return this._conn;
}
},
/**
* The result index.
2016-12-20 09:32:17 +00:00
*/
resultIndex:
{
type: Number
,set: function (x)
{
this._resultIndex = x;
}
,get: function ()
{
return this._resultIndex;
}
},
/**
* The batch used to execute the statement.
2016-12-20 09:32:17 +00:00
*/
batch:
{
type: Sql.Batch
,set: function (x)
{
2015-07-10 12:30:08 +00:00
this.link ({_batch: x}, {'changed': this._autoLoad});
this._autoLoad ();
}
,get: function ()
{
return this._batch;
}
},
/**
* The model select statement.
2016-12-20 09:32:17 +00:00
*/
stmt:
{
type: Sql.Stmt
,set: function (x)
{
this._stmt = x;
2015-07-10 12:30:08 +00:00
this._autoLoad ();
}
,get: function ()
{
return this._stmt;
}
},
/**
* The model query.
2016-12-20 09:32:17 +00:00
*/
query:
{
type: String
,set: function (x)
{
this.stmt = new Sql.String ({query: x});
}
,get: function ()
{
if (this._stmt)
return this._stmt.render (null);
else
return null;
}
},
/**
* The main table.
2016-12-20 09:32:17 +00:00
*/
mainTable:
{
type: String
,set: function (x)
{
this._mainTable = null;
this._requestedMainTable = x;
this._refreshMainTable ();
}
,get: function ()
{
return this._mainTable;
}
},
/**
* Determines if the model is updatable.
2016-12-20 09:32:17 +00:00
*/
updatable:
{
type: Boolean
,set: function (x)
{
this._updatable = false;
this._requestedUpdatable = x;
this._refreshUpdatable ();
}
,get: function ()
{
return this._updatable;
}
},
/**
* The number of rows in the model.
2016-12-20 09:32:17 +00:00
*/
numRows:
{
type: Number
,get: function ()
{
if (this.data)
return this.data.length;
return 0;
}
},
/**
* The current status of the model.
2016-12-20 09:32:17 +00:00
*/
status:
{
type: Number
,get: function ()
{
return this._status;
}
},
/**
* Checks if the model data is ready.
2016-12-20 09:32:17 +00:00
*/
ready:
{
type: Boolean
,get: function ()
{
2016-09-26 09:28:47 +00:00
return this._status == Status.READY;
}
2015-07-10 12:30:08 +00:00
},
/**
* Update mode.
2016-12-20 09:32:17 +00:00
*/
2015-07-10 12:30:08 +00:00
mode:
{
2016-09-26 09:28:47 +00:00
enumType: Mode
,value: Mode.ON_CHANGE
2015-07-10 12:30:08 +00:00
},
/**
* Wether to execute the model query automatically.
2016-12-20 09:32:17 +00:00
*/
2015-07-10 12:30:08 +00:00
autoLoad:
{
type: Boolean
,value: true
}
}
2015-11-09 08:14:33 +00:00
,_conn: null
,_resultIndex: 0
,_batch: null
,_stmt: null
2016-09-26 09:28:47 +00:00
,_status: Status.CLEAN
,data: null
,tables: null
,columns: null
,columnMap: null
,_updatable: false
,_requestedSortIndex: -1
,_requestedSortName: null
,_sortColumn: -1
,_sortWay: null
,_requestedIndexes: {}
,_indexes: []
,_requestedUpdatable: false
,_operations: null
,_operationsMap: null
,_defaults: []
,_requestedMainTable: null
,initialize: function (props)
{
this.parent (props);
this._cleanData ();
2016-09-26 09:28:47 +00:00
this._setStatus (Status.CLEAN);
}
,loadXml: function (builder, node)
{
this.parent (builder, node);
var query = node.firstChild.nodeValue;
if (query)
this.query = query;
}
2015-07-10 12:30:08 +00:00
,_autoLoad: function ()
{
if (this.autoLoad)
this.refresh ();
else
this.clean ();
2015-07-10 12:30:08 +00:00
}
/**
* Refresh the model data reexecuting the query on the database.
2016-12-20 09:32:17 +00:00
*/
,refresh: function ()
{
var ready = false;
if (this._stmt && this._conn)
{
var ids = this._stmt.findHolders ();
if (ids)
{
if (this._batch && this._batch.isReady ())
{
ready = true;
for (var i = 0; i < ids.length; i++)
if (!this._batch.get (ids[i]))
{
ready = false;
break;
}
}
}
else
ready = true;
}
if (ready)
{
2016-09-26 09:28:47 +00:00
this._setStatus (Status.LOADING);
this._conn.execStmt (this._stmt, this._selectDone.bind (this), this._batch);
}
else
2015-09-28 15:21:37 +00:00
this.clean ();
}
,clean: function ()
{
this._cleanData ();
2016-09-26 09:28:47 +00:00
this._setStatus (Status.CLEAN);
}
,_selectDone: function (resultSet)
{
var result;
var dataResult;
this._cleanData ();
2016-10-11 14:45:10 +00:00
try {
for (var i = 0; result = resultSet.fetchResult (); i++)
if (i == this._resultIndex)
dataResult = result;
2016-10-11 14:45:10 +00:00
if (!dataResult || typeof dataResult !== 'object')
throw new Error ('The provided statement doesn\'t return a result set');
}
catch (e)
{
2016-10-11 14:45:10 +00:00
this._setStatus (Status.ERROR);
throw e;
}
2016-10-11 14:45:10 +00:00
this.data = dataResult.data;
this.tables = dataResult.tables;
this.columns = dataResult.columns;
this.columnMap = dataResult.columnMap;
this._repairColumns ();
this._refreshRowIndexes (0);
this._refreshMainTable ();
2016-10-11 14:45:10 +00:00
for (column in this._requestedIndexes)
this._buildIndex (column);
2016-10-11 14:45:10 +00:00
var sortColumn = -1;
2016-10-11 14:45:10 +00:00
if (this._requestedSortName)
sortColumn = this.getColumnIndex (this._requestedSortName);
else if (this._requestedSortIndex !== -1
&& this.checkColExists (this._requestedSortIndex))
sortColumn = this._requestedSortIndex;
if (sortColumn !== -1)
this._realSort (sortColumn, this._sortWay);
this._setStatus (Status.READY);
}
,_refreshRowIndexes: function (start)
{
for (var i = start; i < this.data.length; i++)
this.data[i].index = i;
if (this._operationsMap)
{
this._operationsMap = {};
for (var i = 0; i < this._operations.length; i++)
this._operationsMap[i] = this._operations[i];
}
}
,_cleanData: function (error)
{
this.data = null;
this.tables = null;
this.columns = null;
this.columnMap = null;
this._sortColumn = -1;
this._indexes = [];
this._resetOperations ();
}
,_refreshUpdatable: function ()
{
var oldValue = this._updatable;
this._updatable = this._mainTable !== null && this._requestedUpdatable;
if (oldValue != this._updatable)
this.signalEmit ('updatable-changed');
}
,_refreshMainTable: function ()
{
var newMainTable = null;
var tables = this.tables;
if (tables)
for (var i = 0; i < tables.length; i++)
if (tables[i].pks.length > 0)
if (!this._requestedMainTable
|| tables[i].name === this._requestedMainTable)
{
newMainTable = i;
break;
}
this._mainTable = newMainTable;
this._refreshUpdatable ();
}
/**
* Sets the default value for inserted fields.
*
* @param {String} field The destination field name
* @param {String} table The destination table name
* @param {Sql.Expr} srcColumn The default value expression
2016-12-20 09:32:17 +00:00
*/
,setDefault: function (field, table, expr)
{
this._defaults.push
({
field: field
,table: table
,expr: expr
});
}
/**
* Sets the default value for inserted fields.
*
* @param {String} field The destination field name
* @param {String} table The destination table name
2017-03-30 11:44:53 +00:00
* @param {*} value The default value
2016-12-20 09:32:17 +00:00
*/
,setDefaultFromValue: function (field, table, value)
{
this._defaults.push
({
field: field
,table: table
,value: value
});
}
/**
* Sets the default value for inserted fields from another column in the
* model.
*
* @param {String} field The destination field name
* @param {String} table The destination table name
* @param {String} srcColumn The source column
2016-12-20 09:32:17 +00:00
*/
,setDefaultFromColumn: function (field, table, srcColumn)
{
this._defaults.push
({
field: field
,table: table
,srcColumn: srcColumn
});
}
/**
* Checks if the column exists.
*
* @param {integer} column The column index
* @return {Boolean} %true if column exists, %false otherwise
2016-12-20 09:32:17 +00:00
*/
,checkColExists: function (column)
{
return this.columns
&& column >= 0
&& column < this.columns.length;
}
/**
* Checks if the row exists.
*
* @param {integer} rowIndex The row index
* @return {Boolean} %true if row exists, %false otherwise
2016-12-20 09:32:17 +00:00
*/
,checkRowExists: function (rowIndex)
{
return this.data
&& rowIndex >= 0
&& rowIndex < this.data.length;
}
,_checkTableUpdatable: function (tableIndex)
{
2015-04-01 08:24:15 +00:00
var tableUpdatable = tableIndex !== null
&& this.tables[tableIndex].pks.length > 0;
if (!tableUpdatable)
2015-07-03 05:49:45 +00:00
console.warn ("Db.Model: Table %s is not updatable",
this.tables[tableIndex].name);
return tableUpdatable;
}
/**
* Get the index of the column from its name.
*
* @param {string} columnName The column name
* @return {number} The column index or -1 if column not exists
2016-12-20 09:32:17 +00:00
*/
,getColumnIndex: function (columnName)
{
var index;
if (this.columnMap
&& (index = this.columnMap[columnName]) !== undefined)
return index;
return -1;
}
/**
* Gets a value from the model.
*
* @param {number} rowIndex The row index
2017-03-30 11:44:53 +00:00
* @param {String} columnName The column name
* @return {*} The value
2016-12-20 09:32:17 +00:00
*/
,get: function (rowIndex, columnName)
{
var index = this.getColumnIndex (columnName);
if (index != -1)
return this.getByIndex (rowIndex, index);
return undefined;
}
/**
* Updates a value on the model.
*
* @param {number} rowIndex The row index
2017-03-30 11:44:53 +00:00
* @param {String} columnName The column name
* @param {*} value The new value
2016-12-20 09:32:17 +00:00
*/
,set: function (rowIndex, columnName, value)
{
var index = this.getColumnIndex (columnName);
if (index != -1)
this.setByIndex (rowIndex, index, value);
else
console.warn ('Db.Model: Column %s doesn\'t exist', columnName);
}
/**
* Gets a value from the model using the column index.
*
* @param {number} rowIndex The row index
* @param {number} column The column index
2017-03-30 11:44:53 +00:00
* @return {*} The value
2016-12-20 09:32:17 +00:00
*/
,getByIndex: function (rowIndex, column)
{
if (this.checkRowExists (rowIndex) && this.checkColExists (column))
return this.data[rowIndex][column];
return undefined;
}
/**
* Updates a value on the model using the column index.
*
* @param {number} rowIndex The row index
* @param {number} col The column index
2017-03-30 11:44:53 +00:00
* @param {*} value The new value
2016-12-20 09:32:17 +00:00
*/
,setByIndex: function (rowIndex, col, value)
{
if (!this.checkRowExists (rowIndex)
&& !this.checkColExists (col))
return;
var tableIndex = this.columns[col].table;
if (!this._checkTableUpdatable (tableIndex))
return;
var row = this.data[rowIndex];
var op = this._createOperation (rowIndex);
2016-09-26 09:28:47 +00:00
op.type |= Operation.UPDATE;
if (!op.oldValues)
op.oldValues = [];
if (!op.tables)
op.tables = {};
var tableOp = op.tables[tableIndex];
if (!tableOp)
{
2016-09-26 09:28:47 +00:00
tableOp = Operation.UPDATE;
var pks = this.tables[tableIndex].pks;
for (var i = 0; i < pks.length; i++)
if (!row[pks[i]] && !op.oldValues[pks[i]])
{
2016-09-26 09:28:47 +00:00
tableOp = Operation.INSERT;
break;
}
op.tables[tableIndex] = tableOp;
}
2016-09-26 09:28:47 +00:00
if (tableOp & Operation.UPDATE
&& op.oldValues[col] === undefined)
op.oldValues[col] = row[col];
this.signalEmit ('row-updated-before', rowIndex);
row[col] = value;
this.signalEmit ('row-updated', rowIndex, [col]);
2016-09-26 09:28:47 +00:00
if (this.mode == Mode.ON_CHANGE
&& !(op.type & Operation.INSERT))
this.performOperations ();
}
/**
* Deletes a row from the model.
*
* @param {number} rowIndex The row index
2016-12-20 09:32:17 +00:00
*/
,deleteRow: function (rowIndex)
{
if (!this.checkRowExists (rowIndex)
|| !this._checkTableUpdatable (this._mainTable))
return;
var op = this._createOperation (rowIndex);
2016-09-26 09:28:47 +00:00
op.type |= Operation.DELETE;
if (!this._requestedMainTable)
{
this.signalEmit ('row-deleted-before', rowIndex);
this.data.splice (rowIndex, 1);
this.signalEmit ('row-deleted', rowIndex);
this._refreshRowIndexes (rowIndex);
}
else
{
this.signalEmit ('row-updated-before', rowIndex);
if (!op.oldValues)
op.oldValues = [];
var updatedCols = [];
for (var i = 0; i < this.columns.length; i++)
if (this.columns[i].table == this._mainTable)
{
if (op.oldValues[i] === undefined)
op.oldValues[i] = op.row[i];
op.row[i] = null;
updatedCols.push (i);
}
this.signalEmit ('row-updated', rowIndex, updatedCols);
}
2016-09-26 09:28:47 +00:00
if (this.mode === Mode.ON_CHANGE)
this.performOperations ();
}
/**
* Inserts a new row on the model.
*
* @return The index of the inserted row
2016-12-20 09:32:17 +00:00
*/
,insertRow: function ()
{
if (!this._checkTableUpdatable (this._mainTable))
return -1;
var cols = this.columns;
var newRow = new Array (cols.length);
for (var i = 0; i < cols.length; i++)
if (cols[i].table === this._mainTable)
newRow[i] = cols[i].def;
else
newRow[i] = null;
var rowIndex = this.data.push (newRow) - 1;
newRow.index = rowIndex;
var op = this._createOperation (rowIndex);
2016-09-26 09:28:47 +00:00
op.type |= Operation.INSERT;
this.signalEmit ('row-inserted', rowIndex);
return rowIndex;
}
/**
* Performs all model changes on the database.
2016-12-20 09:32:17 +00:00
*/
,performOperations: function ()
{
var ops = this._operations;
if (ops.length === 0)
2015-07-10 12:30:08 +00:00
{
this.signalEmit ('operations-done');
return;
2015-07-10 12:30:08 +00:00
}
var stmts = new Sql.MultiStmt ();
var query = new Sql.String ({query: 'START TRANSACTION'});
stmts.addStmt (query);
for (var i = 0; i < ops.length; i++)
{
query = null;
var op = ops[i];
2016-09-26 09:28:47 +00:00
if (op.type & Operation.DELETE)
{
2016-09-26 09:28:47 +00:00
if (op.type & Operation.INSERT)
continue;
var where = this._createWhere (this._mainTable, op, true);
if (where)
{
query = new Sql.Delete ({where: where});
query.addTarget (this._createTarget (this._mainTable));
}
}
2016-09-26 09:28:47 +00:00
else if (op.type & (Operation.INSERT | Operation.UPDATE))
{
query = new Sql.MultiStmt ();
for (var tableIndex in op.tables)
{
var stmt = this._createDmlQuery (op, parseInt (tableIndex));
query.addStmt (stmt);
}
}
if (query)
{
stmts.addStmt (query);
}
else
{
console.warn ('Db.Model: %s', _('ErrorSavingChanges'));
return;
}
}
2015-07-10 12:30:08 +00:00
var query = new Sql.String ({query: 'COMMIT'});
stmts.addStmt (query);
this._conn.execStmt (stmts,
this._onOperationsDone.bind (this, ops));
this._resetOperations ();
}
,_createDmlQuery: function (op, tableIndex)
{
var where = this._createWhere (tableIndex, op, false);
if (!where)
return null;
var multiStmt = new Sql.MultiStmt ();
var target = this._createTarget (tableIndex);
var select = new Sql.Select ({where: where});
select.addTarget (target);
var row = op.row;
var cols = this.columns;
2016-09-26 09:28:47 +00:00
if (op.tables[tableIndex] & Operation.INSERT)
{
var dmlQuery = new Sql.Insert ();
var table = this.tables[tableIndex];
for (var i = 0; i < this._defaults.length; i++)
{
var def = this._defaults[i];
if (def.table === table.name)
{
if (def.value)
dmlQuery.addSet (def.field, def.value);
else if (def.expr)
dmlQuery.addExpr (def.field, def.expr);
else if (def.srcColumn)
{
var columnIndex = this.getColumnIndex (def.srcColumn);
dmlQuery.addSet (def.field, row[columnIndex]);
}
}
}
for (var i = 0; i < cols.length; i++)
if (cols[i].table === tableIndex)
{
if (row[i] !== null)
dmlQuery.addSet (cols[i].orgname, row[i]);
select.addField (cols[i].orgname);
}
}
else
{
var updateWhere = this._createWhere (tableIndex, op, true);
if (!updateWhere)
return null;
var dmlQuery = new Sql.Update ({where: updateWhere});
for (var i = 0; i < cols.length; i++)
if (cols[i].table === tableIndex && op.oldValues[i] !== undefined)
{
var fieldName = cols[i].orgname;
dmlQuery.addSet (fieldName, row[i]);
select.addField (fieldName);
}
}
dmlQuery.addTarget (target);
multiStmt.addStmt (dmlQuery);
multiStmt.addStmt (select);
return multiStmt;
}
,_onOperationsDone: function (ops, resultSet)
{
2016-10-30 22:48:18 +00:00
var error = resultSet.getError ();
if (error)
{
this._operations = this._operations.concat (ops);
for (var i = 0; i < ops.length; i++)
this._operationsMap[ops[i].row.index] = ops[i];
2015-07-21 14:16:07 +00:00
2016-10-30 22:48:18 +00:00
throw error;
}
2015-07-10 12:30:08 +00:00
resultSet.fetchResult ();
var isOperation = false;
for (var i = 0; i < ops.length; i++)
{
var op = ops[i];
var row = op.row;
2016-09-26 09:28:47 +00:00
if (!(op.type & Operation.DELETE
&& op.type & Operation.INSERT))
isOperation = true;
2016-09-26 09:28:47 +00:00
if (op.type & Operation.DELETE)
{
resultSet.fetchResult ();
}
2016-09-26 09:28:47 +00:00
else if (op.type & (Operation.INSERT | Operation.UPDATE))
{
this.signalEmit ('row-updated-before', row.index);
var updatedCols = [];
var cols = this.columns;
for (var tableIndex in op.tables)
{
var j = 0;
tableIndex = parseInt (tableIndex);
resultSet.fetchResult ();
var newValues = resultSet.fetchRow ();
2016-09-26 09:28:47 +00:00
if (op.tables[tableIndex] & Operation.INSERT)
{
for (var i = 0; i < cols.length; i++)
if (cols[i].table === tableIndex)
{
row[i] = newValues[j++];
updatedCols.push (i);
}
}
else
{
for (var i = 0; i < cols.length; i++)
if (cols[i].table === tableIndex
&& op.oldValues[i] !== undefined)
{
row[i] = newValues[j++];
updatedCols.push (i);
}
}
}
this.signalEmit ('row-updated', row.index, updatedCols);
}
}
resultSet.fetchResult ();
2015-07-10 12:30:08 +00:00
// if (isOperation)
this.signalEmit ('operations-done');
}
/**
* Undoes all unsaved changes made to the model.
2016-12-20 09:32:17 +00:00
*/
,reverseOperations: function ()
{
for (var i = 0; i < this._operations.length; i++)
{
var op = this._operations[i];
var row = op.row;
2016-09-26 09:28:47 +00:00
if (op.type & Operation.DELETE
&& !(op.type & Operation.INSERT))
{
this.data.splice (row.index, 0, row);
this.signalEmit ('row-inserted', row.index);
}
2016-09-26 09:28:47 +00:00
else if (op.type & Operation.UPDATE)
{
this.signalEmit ('row-updated-before', row.index);
var updatedCols = [];
var cols = this.columns;
for (var i = 0; i < cols.length; i++)
if (op.oldValues[i] !== undefined)
{
row[i] = op.oldValues[i];
updatedCols.push (i);
}
this.signalEmit ('row-updated', row.index, updatedCols);
}
}
this._resetOperations ();
this._refreshRowIndexes (0);
}
,_resetOperations: function ()
{
this._operations = [];
this._operationsMap = {};
}
/*
* Function used to sort the model ascending.
*/
,sortFunctionAsc: function (column, a, b)
{
if (a[column] < b[column])
return -1;
else if (a[column] > b[column])
return 1;
return 0;
}
/*
* Function used to sort the model descending.
*/
,sortFunctionDesc: function (column, a, b)
{
if (a[column] > b[column])
return -1;
else if (a[column] < b[column])
return 1;
return 0;
}
/**
* Orders the model by the specified column name.
*
* @param {integer} column The column name
2016-09-26 09:28:47 +00:00
* @param {SortWay} way The sort way
2016-12-20 09:32:17 +00:00
*/
,sortByName: function (columnName, way)
{
this._requestedSortIndex = -1;
this._requestedSortName = columnName;
var index = this.getColumnIndex (columnName);
if (index != -1)
this._sort (index, way);
}
/**
* Orders the model by the specified column.
*
* @param {integer} column The column index
2016-09-26 09:28:47 +00:00
* @param {SortWay} way The sort way
2016-12-20 09:32:17 +00:00
*/
,sort: function (column, way)
{
this._requestedSortIndex = column;
this._requestedSortName = null;
if (!this.checkColExists (column))
return;
this._sort (column, way);
}
,_sort: function (column, way)
{
2016-09-26 09:28:47 +00:00
this._setStatus (Status.LOADING);
this._realSort (column, way);
2016-09-26 09:28:47 +00:00
this._setStatus (Status.READY);
}
,_realSort: function (column, way)
{
if (column !== this._sortColumn)
{
2016-09-26 09:28:47 +00:00
if (way === SortWay.DESC)
var sortFunction = this.sortFunctionDesc;
else
var sortFunction = this.sortFunctionAsc;
this.data.sort (sortFunction.bind (this, column));
}
else if (way !== this._sortWay)
this.data.reverse ();
this._sortColumn = column;
this._sortWay = way;
this._refreshRowIndexes (0);
}
2015-02-08 15:38:38 +00:00
/**
* Builds an internal hash index for the specified column, this speeds
* significantly searches on that column, specially when model has a lot of
* rows.
*
* FIXME: Not fully implemented.
2015-02-08 15:38:38 +00:00
*
* @param {String} column The column name
2016-12-20 09:32:17 +00:00
*/
2015-02-08 15:38:38 +00:00
,indexColumn: function (column)
{
this._requestedIndexes[column] = true;
2015-02-08 15:38:38 +00:00
2016-09-26 09:28:47 +00:00
if (this._status === Status.READY)
this._buildIndex (column);
2015-02-08 15:38:38 +00:00
}
,_buildIndex: function (column)
2015-02-08 15:38:38 +00:00
{
var columnIndex = this.getColumnIndex (column);
if (columnIndex !== -1)
2015-02-08 15:38:38 +00:00
{
var index = {};
var data = this.data;
switch (this.columns[columnIndex].type)
{
2016-09-26 09:28:47 +00:00
case Connection.Type.TIMESTAMP:
case Connection.Type.DATE_TIME:
case Connection.Type.DATE:
2015-02-08 15:38:38 +00:00
for (var i = 0; i < data.length; i++)
index[data[i][columnIndex].toString ()] = i;
break;
default:
for (var i = 0; i < data.length; i++)
index[data[i][columnIndex]] = i;
}
this._indexes[columnIndex] = index;
2015-02-08 15:38:38 +00:00
}
}
/**
* Searchs a value on the model and returns the row index of the first
* ocurrence.
* If an index have been built on that column, it will be used, for more
* information see the indexColumn() method.
*
* @param {String} column The column name
* @param {Object} value The value to search
* @return {integer} The column index
2016-12-20 09:32:17 +00:00
*/
,search: function (column, value)
{
var index = this.getColumnIndex (column);
return this.searchByIndex (index, value);
}
/**
* Searchs a value on the model and returns the row index of the first
* ocurrence.
*
* @param {integer} col The column index
* @param {Object} value The value to search
* @return {integer} The column index
2016-12-20 09:32:17 +00:00
*/
,searchByIndex: function (col, value)
{
if (!this.checkColExists (col))
return -1;
2015-02-08 15:38:38 +00:00
if (value)
switch (this.columns[col].type)
{
2016-09-26 09:28:47 +00:00
case Connection.Type.BOOLEAN:
2015-02-08 15:38:38 +00:00
value = !!value;
break;
2016-09-26 09:28:47 +00:00
case Connection.Type.INTEGER:
2015-02-08 15:38:38 +00:00
value = parseInt (value);
break;
2016-09-26 09:28:47 +00:00
case Connection.Type.DOUBLE:
2015-02-08 15:38:38 +00:00
value = parseFloat (value);
break;
default:
value = value.toString ();
}
// Searchs the value using an internal index.
var index = this._indexes[col];
2015-02-08 15:38:38 +00:00
if (index)
{
2015-02-17 11:48:53 +00:00
if (index[value] !== undefined)
2015-02-08 15:38:38 +00:00
return index[value];
return -1;
}
// Searchs the value using a loop.
var data = this.data;
switch (this.columns[col].type)
{
2016-09-26 09:28:47 +00:00
case Connection.Type.TIMESTAMP:
case Connection.Type.DATE_TIME:
case Connection.Type.DATE:
{
for (var i = 0; i < data.length; i++)
2016-10-30 22:48:18 +00:00
if (value === data[i][col].toString ())
return i;
break;
}
default:
for (var i = 0; i < data.length; i++)
if (value === data[i][col])
return i;
}
return -1;
}
,_setStatus: function (status)
{
this._status = status;
this.signalEmit ('status-changed', status);
2015-07-21 14:16:07 +00:00
this.signalEmit ('status-changed-after', status);
}
,_createTarget: function (tableIndex)
{
var table = this.tables[tableIndex];
2015-03-31 15:14:44 +00:00
return new Sql.Table
({
name: table.orgname
,schema: table.schema
});
}
,_createWhere: function (tableIndex, op, useOldValues)
{
var where = new Sql.Operation ({type: Sql.Operation.Type.AND});
var pks = this.tables[tableIndex].pks;
if (pks.length === 0)
return null;
for (var i = 0; i < pks.length; i++)
{
var col = pks[i];
var column = this.columns[col];
var equalOp = new Sql.Operation ({type: Sql.Operation.Type.EQUAL});
equalOp.exprs.add (new Sql.Field ({name: column.orgname}));
where.exprs.add (equalOp);
var pkValue = null;
if (useOldValues && op.oldValues
&& op.oldValues[col] !== undefined)
pkValue = op.oldValues[col];
else
pkValue = op.row[col];
if (pkValue)
equalOp.exprs.add (new Sql.Value ({value: pkValue}));
2016-09-26 09:28:47 +00:00
else if (column.flags & Connection.Flag.AI && !useOldValues)
2016-10-04 15:27:49 +00:00
equalOp.exprs.add (new Sql.Function ({name: 'LAST_INSERT_ID'}));
else
return null;
}
return where;
}
,_createOperation: function (rowIndex)
{
var op = this._operationsMap[rowIndex];
if (!op)
{
op = {
type: 0,
row: this.data[rowIndex]
};
this._operations.push (op);
this._operationsMap[rowIndex] = op;
}
2015-02-08 15:38:38 +00:00
return op;
}
/**
* Overrides information about a table and its columns. If a parameter is
* not provided, the original will be preserved. This method should be used
* primarily to avoid the mysql bug that causes this information will not
* be set correctly.
* For more information see the following links:
* - https://bugs.mysql.com/bug.php?id=44660
* - https://bugs.mysql.com/bug.php?id=26894
*
* @param {String} table The table alias
* @param {String} orgtable The original table name
* @param {String} schema The original table schema
* @param {Array} pks Array with the names of primary keys
* @param {String} ai The autoincrement column name
2016-12-20 09:32:17 +00:00
*/
,setInfo: function (table, orgname, schema, pks, ai)
{
if (!this.tableInfo)
this.tableInfo = {};
this.tableInfo[table] =
2015-03-31 15:14:44 +00:00
{
orgname: orgname,
schema: schema,
pks: pks,
ai: ai
2015-03-31 15:14:44 +00:00
};
this._repairColumns ();
}
,_repairColumns: function ()
{
// Repairs wrong table info
2015-03-31 15:14:44 +00:00
if (this.tableInfo && this.tables)
for (var i = 0; i < this.tables.length; i++)
{
var table = this.tables[i];
var tableInfo = this.tableInfo[table.name];
2015-03-31 15:14:44 +00:00
if (!tableInfo)
continue;
table.orgname = tableInfo.orgname;
2015-03-31 15:14:44 +00:00
table.schema = tableInfo.schema;
if (tableInfo.pks)
{
table.pks = [];
for (var j = 0; j < tableInfo.pks.length; j++)
{
var colIndex = this.getColumnIndex (tableInfo.pks[j]);
2015-12-10 23:24:14 +00:00
if (colIndex !== -1)
table.pks.push (colIndex);
else
console.warn ('Db.Model: Can\'t repair primary key: `%s`.`%s`'
,tableInfo.orgname
,tableInfo.pks[j]
);
}
}
if (tableInfo.ai)
{
var colIndex = this.getColumnIndex (tableInfo.ai);
2015-12-10 23:24:14 +00:00
if (colIndex !== -1)
2016-09-26 09:28:47 +00:00
this.columns[colIndex].flags |= Connection.Flag.AI;
2015-12-10 23:24:14 +00:00
else
console.warn ('Db.Model: Can\'t repair autoincrement column: `%s`.`%s`'
,tableInfo.orgname
,tableInfo.ai
);
}
}
}
});