funcRet.then(function () {
if (!isCallback) {
ret.callback();
isCallback = true;
}
}, function (err) {
this._saveReload().then(comb.hitch(this, function () {
ret.callback(this);
}), comb.hitch(ret, "errback"));
m.save().then(ret.errback.bind(ret), function (err) {
assert.equal(err[0].message, "num must be even got 1.");
ret.callback();
});
db.unListen("myChannel").chain(function () {
assert.deepEqual(db.sqls, ['LISTEN my_channel', "NOTIFY my_channel , '{\"msg\":\"hello\"}'", "UNLISTEN my_channel"]);
assert.deepEqual(db.__listeners, {});
ret.callback();
}).addErrback(ret);
.chain(function () {
assert.equal(called, 1);
finalPromise.callback();
});
execute : function(sql, opts) {
var ret = new comb.Promise();
this.sqls.push(sql);
ret.callback();
return ret;
},
.on('end', function (count) {
ret.callback(retObj);
})
validate : function(conn) {
var ret = new comb.Promise();
ret.callback(true);
return ret;
},
fetchRows:function(sql, cb){
var from = this.__opts.from[0], ret = new comb.Promise();
ret.callback(cb({version:patioMigrationVersion}));
return ret;
},
comb.when(cb(item, res, i), function (res) {
retArr[i] = res;
ret.callback();
}, hitch(ret, "errback"));
comb.when(cb(item, res, i), function (res) {
if (res) {
retArr.push(item);
}
ret.callback();
});
it.run().both(function (summary) {
comb.merge(summaries, summary.summaries);
ret.callback();
});
it.run().both(function (summary) {
summaries[description] = comb.merge(summaries[description] || {}, summary);
ret.callback();
});
}, function (err) {
if (!isCallback) {
ret.errback(err);
isCallback = true;
}
});
.then(function(employee) {
var Employee = moose.addModel(employee);
ret.callback();
}, comb.hitch(console, "log"));
model._hook("post", "load").then(hitch(this, function () {
ret.callback(model);
}), hitch(ret, "errback"));
fetchRows : function(sql) {
var ret = new comb.Promise();
this.db.execute(sql);
ret.callback({id : 1, x : 1});
return ret;
},
graph:function(dataset, joinConditions, options, block) {
var ret = new comb.Promise();
var args = comb.argsToArray(arguments).slice(1);
block = comb.isFunction(args[args.length - 1]) ? args.pop() : null;
joinConditions = args.shift() || null;
options = args.shift() || {};
// Allow the use of a model, dataset, or string as the first argument
// Find the table name/dataset based on the argument
dataset.hasOwnProperty("dataset") && (dataset = dataset.dataset);
var tableAlias = options.tableAlias, table;
if (comb.isString(dataset)) {
table = sql.identifier(dataset);
dataset = this.db.from(dataset);
comb.isUndefinedOrNull(tableAlias) && (tableAlias = table);
} else if (comb.isInstanceOf(dataset, Dataset)) {
if (dataset.isSimpleSelectAll) {
table = dataset.__opts.from[0];
comb.isUndefinedOrNull(tableAlias) && (tableAlias = table);
} else {
table = dataset;
comb.isUndefinedOrNull(tableAlias) && (tableAlias = this._datasetAlias((this.__opts.numDatasetSources || 0) + 1));
}
} else {
throw new QueryError("The dataset arg should be a string, dataset or model");
}
var aliases;
// Only allow table aliases that haven't been used
var thisOpts = this.__opts, thisOptsGraph = thisOpts.graph;
if (comb.isObject(thisOptsGraph) && comb.isHash((aliases = thisOptsGraph.tableAliases)) && !comb.isUndefinedOrNull(aliases[tableAlias.value])) {
raiseAliasError(options);
}
// Use a from_self if this is already a joined table
var ds = (!thisOptsGraph && (thisOpts.from.length > 1 || thisOpts.join)) ? this.fromSelf({alias:options.fromSelfAlias || this.firstSourceAlias}) : this;
// Join the table early in order to avoid cloning the dataset twice
ds = ds.joinTable(options.joinType || "leftOuter", table, joinConditions, {tableAlias:tableAlias, implicitQualifier:options.implicitQualifier}, block);
var opts = ds.__opts;
// Whether to include the table in the result set
var addTable = comb.isBoolean(options.select) ? options.select : true;
// Whether to add the columns to the list of column aliases
var addColumns = comb.isUndefinedOrNull(opts.graphAliases);
// Setup the initial graph data structure if it doesn't exist
var graph;
var populateGraphPromise = new comb.Promise();
if (comb.isUndefinedOrNull((graph = opts.graph))) {
var master = this._toTableName(ds.firstSourceAlias);
(master == tableAlias) && raiseAliasError(options);
// Master hash storing all .graph related information
graph = opts.graph = {};
// Associates column aliases back to tables and columns
var columnAliases = graph.columnAliases = {};
// Associates table alias (the master is never aliased)
var tableAliases = graph.tableAliases = {};
tableAliases[master] = this;
// All columns in the master table are never
// aliased, but are not included if set_graph_aliases
// has been used.
if (addColumns) {
var select = opts.select = [];
this.columns.then(hitch(this, function(cols) {
cols.forEach(function(column) {
columnAliases[column] = [master, column];
select.push(new sql.QualifiedIdentifier(master, column));
});
populateGraphPromise.callback(graph);
}), hitch(ret, "errback"));
} else {
populateGraphPromise.callback(graph);
}
} else {
populateGraphPromise.callback(graph);
}
populateGraphPromise.then(hitch(this, function(graph) {
// Add the table alias to the list of aliases
// Even if it isn't been used in the result set,
// we add a key for it with a nil value so we can check if it
// is used more than once
var tableAliases = graph.tableAliases;
tableAliases[tableAlias] = addTable ? dataset : null;
// Add the columns to the selection unless we are ignoring them
if (addTable && addColumns) {
var select = opts.select;
var columnAliases = graph.columnAliases;
// Which columns to add to the result set
var dsColPromise;
if (options.select) {
dsColPromise = new comb.Promise().callback(options.select)
} else {
dsColPromise = dataset.columns;
}
// If the column hasn't been used yet, don't alias it.
// If it has been used, try tableColumn.
dsColPromise.then(hitch(this, function(cols) {
cols.forEach(function(column) {
var colAlias, identifier;
if (columnAliases[column]) {
var columnAlias = format("%s_%s", [tableAlias, column]);
colAlias = columnAlias, identifier = new sql.QualifiedIdentifier(tableAlias, column).as(columnAlias);
} else {
colAlias = column, identifier = new sql.QualifiedIdentifier(tableAlias, column);
}
columnAliases[colAlias] = [tableAlias, column];
select.push(identifier)
});
ret.callback(ds);
}), hitch(ret, "errback"));
} else {
ret.callback(ds);
}
}), hitch(ret, "errback"));
return ret;
},
child.biologicalFather.then(function (father) {
console.log(child.name + " father is " + father.name);
ret.callback();
}, ret);
}), hitch(this, function (err) {
this._returnConnection(conn);
ret.errback(err);
}));
.on('error', function (error) {
ret.errback(error);
});
this.get(sql.version().sqlFunction).then(hitch(this, function (version) {
var m = version.match(/(\d+)\.(\d+)\.(\d+)/);
this._serverVersion = (parseInt(m[1]) * 10000) + (parseInt(m[2]) * 100) + parseInt(m[3]);
ret.callback(this._serverVersion);
}), hitch(ret, "errback"));
db.listenOnce("myChannel").chain(function (payload) {
assert.equal(payload, "hello1");
called++;
ret2.callback();
}, finalPromise.errback);
this.run("USE " + dbName).then(hitch(this, function () {
this.opts.database = dbName;
this.schemas = {};
ret.callback(this);
}));
transaction: function (opts, cb) {
var ret = new comb.Promise();
cb();
ret.callback();
return ret;
},
this._super(arguments).then(hitch(this, function (sql) {
op.table = related;
ret.callback([sql, format("ALTER TABLE %s ADD FOREIGN KEY (%s)%s",
this.__quoteSchemaTable(table), this.__quoteIdentifier(op.name),
this.__columnReferencesSql(op))]);
}), hitch(ret, "errback"));
this.find(q).then(comb.hitch(this, function (res) {
ret.callback(res || this.create());
}), comb.hitch(ret, "errback"));
columns: function () {
var from = this.__opts.from[0], ret = new comb.Promise();
ret.callback(this.db.columnsCreated);
return ret;
}
m.save().then(ret.errback.bind(ret), function (err) {
assert.equal(err[0].message, "num2 cannot be null.");
ret.callback();
});
var errorHandler = function (err) {
if (!isCallback) {
isCallback = true;
ret.errback(err);
}
};