alasql 2.2.2 → 2.2.4

package/dist/alasql.fs.js

@@ -1,7 +1,7 @@
-//! AlaSQL v2.2.1-develop-86ee0810 | © 2014-2022 Andrey Gershun & Mathias Wulff | License: MIT
+//! AlaSQL v2.2.3-develop-21117291 | © 2014-2022 Andrey Gershun & Mathias Wulff | License: MIT
 /*
 @module alasql
-@version 2.2.1-develop-86ee0810
+@version 2.2.3-develop-21117291
 
 AlaSQL - JavaScript SQL database
 © 2014-2016	Andrey Gershun & Mathias Rangel Wulff
@@ -142,7 +142,7 @@ var alasql = function(sql, params, cb, scope) {
 	Current version of alasql 
  	@constant {string} 
 */
-alasql.version = '2.2.1-develop-86ee0810';
+alasql.version = '2.2.3-develop-21117291';
 
 /**
 	Debug flag
@@ -3573,7 +3573,6 @@ var loadFile = (utils.loadFile = function (path, asy, success, error) {
 					}
 				};
 				xhr.open('GET', path, asy); // Async
-				xhr.responseType = 'text';
 				xhr.send();
 			}
 		} else if (path instanceof Event) {
@@ -4935,7 +4934,7 @@ alasql.promise = function (sql, params) {
 // Main Database class
 
 /**
-    @class Database 
+    @class Database
  */
 
 var Database = (alasql.Database = function (databaseid) {
@@ -5012,85 +5011,95 @@ Database.prototype.autoval = function (tablename, colname, getNext) {
 	return alasql.autoval(tablename, colname, getNext, this.databaseid);
 };
 
+Database.prototype.transaction = function (cb) {
+	var tx = new alasql.Transaction(this.databaseid);
+	var res = cb(tx);
+	return res;
+};
+
 // Aliases like MS SQL
 
 /*
 //
-// Transactio class for Alasql.js
+// Transaction class for Alasql.js
 // Date: 03.11.2014
 // (c) 2014, Andrey Gershun
 //
 */
 
-Database.prototype.transaction = function (cb) {
-	var tx = new alasql.Transaction(this.databaseid);
-	var res = cb(tx);
-	return res;
-};
-
-// Transaction class (for WebSQL compatibility)
+class Transaction {
+	transactionid = Date.now();
 
-/** 
- Transaction class
- @class Transaction
- */
+	committed = false;
 
-var Transaction = (alasql.Transaction = function (databaseid) {
-	this.transactionid = Date.now();
-	this.databaseid = databaseid;
-	this.commited = false;
-	this.dbversion = alasql.databases[databaseid].dbversion;
-	//	this.bank = cloneDeep(alasql.databases[databaseid]);
-	this.bank = JSON.stringify(alasql.databases[databaseid]);
-	// TODO CLone Tables with insertfns
+	/** @type {string | undefined} */
+	bank;
 
-	return this;
-});
+	constructor(databaseid) {
+		this.databaseid = databaseid;
+		this.dbversion = alasql.databases[databaseid].dbversion;
+		// this.bank = structuredClone(alasql.databases[databaseid]);
+		this.bank = JSON.stringify(alasql.databases[databaseid]);
+		// TODO CLone Tables with insertfns
+	}
 
-// Main class
+	/** Commit transaction */
+	commit() {
+		this.committed = true;
+		alasql.databases[this.databaseid].dbversion = Date.now();
+		delete this.bank;
+	}
 
-// Commit
+	/** Rollback transaction */
+	rollback() {
+		if (!this.committed) {
+			alasql.databases[this.databaseid] = JSON.parse(this.bank);
+			// alasql.databases[this.databaseid].tables = this.bank;
+			// alasql.databases[this.databaseid].dbversion = this.dbversion;
+			delete this.bank;
+		} else {
+			throw new Error('Transaction already commited');
+		}
+	}
 
-/**
- Commit transaction
- */
-Transaction.prototype.commit = function () {
-	this.commited = true;
-	alasql.databases[this.databaseid].dbversion = Date.now();
-	delete this.bank;
-};
+	/**
+	 * Execute SQL statement
+	 * @param {string} sql SQL statement
+	 * @param {object} params Parameters
+	 * @param {function} cb Callback function
+	 * @return result
+	 */
+	exec(sql, params, cb) {
+		return alasql.dexec(this.databaseid, sql, params, cb);
+	}
 
-// Rollback
-/**
- Rollback transaction
- */
-Transaction.prototype.rollback = function () {
-	if (!this.commited) {
-		alasql.databases[this.databaseid] = JSON.parse(this.bank);
-		// alasql.databases[this.databaseid].tables = this.bank;
-		// alasql.databases[this.databaseid].dbversion = this.dbversion;
-		delete this.bank;
-	} else {
-		throw new Error('Transaction already commited');
+	/*
+	queryArray (sql, params, cb) {
+		return flatArray(this.exec(sql, params, cb));
 	}
-};
 
-// Transactions stub
+	queryArrayOfArrays (sql, params, cb) {
+		return arrayOfArrays(this.exec(sql, params, cb));
+	}
 
-/**
- Execute SQL statement
- @param {string} sql SQL statement
- @param {object} params Parameters
- @param {function} cb Callback function 
- @return result
- */
-Transaction.prototype.exec = function (sql, params, cb) {
+	querySingle (sql, params, cb) {
+		return this.exec(sql, params, cb)[0];
+	}
 
-	return alasql.dexec(this.databaseid, sql, params, cb);
-};
+	queryValue (sql, params, cb) {
+		var res = this.querySingle(sql, params, cb);
+		return res[Object.keys(res)[0]];
+	}
+	*/
+}
 
 Transaction.prototype.executeSQL = Transaction.prototype.exec;
 
+// Transaction.prototype.query = Database.prototype.exec;
+// Transaction.prototype.run = Database.prototype.exec;
+
+alasql.Transaction = Transaction;
+
 /*
 //
 // Table class for Alasql.js
@@ -5138,7 +5147,7 @@ var Table = (alasql.Table = function (params) {
 	this.insteadofupdate = {};
 
 	// Done
-	extend(this, params);
+	Object.assign(this, params);
 });
 
 Table.prototype.indexColumns = function () {
@@ -5165,7 +5174,7 @@ var View = (alasql.View = function (params) {
 	// Data array
 	this.query = [];
 
-	extend(this, params);
+	Object.assign(this, params);
 });
 
 /*
@@ -5209,27 +5218,29 @@ var Recordset = (alasql.Recordset = function (params) {
 //
 */
 
-var yy = (alasqlparser.yy = alasql.yy = {});
-
-// Utility
-yy.extend = extend;
-// Option for case sensitive
-yy.casesensitive = alasql.options.casesensitive;
-
 // Base class for all yy classes
-var Base = (yy.Base = function (params) {
-	return yy.extend(this, params);
-});
+class Base {
+	constructor(params) {
+		Object.assign(this, params);
+	}
+	toString() {}
+	toType() {}
+	toJS() {}
+	exec() {}
+	compile() {}
+}
 
-Base.prototype.toString = function () {};
-Base.prototype.toType = function () {};
-Base.prototype.toJS = function () {};
+var yy = {
+	// Utility
+	/** @deprecated use `Object.assign` instead */
+	extend: Object.assign,
 
-Base.prototype.compile = returnUndefined;
-Base.prototype.exec = function () {};
+	// Option for case sensitive
+	casesensitive: alasql.options.casesensitive,
+	Base,
+};
 
-Base.prototype.compile = returnUndefined;
-Base.prototype.exec = function () {};
+alasqlparser.yy = alasql.yy = yy;
 
 /*
 //
@@ -5239,36 +5250,25 @@ Base.prototype.exec = function () {};
 //
 */
 
-// Statements container
-yy.Statements = function (params) {
-	return yy.extend(this, params);
-};
+yy.Statements = class Statements {
+	constructor(params) {
+		Object.assign(this, params);
+	}
 
-yy.Statements.prototype.toString = function () {
-	return this.statements
-		.map(function (st) {
-			return st.toString();
-		})
-		.join('; ');
-};
+	toString() {
+		return this.statements.map((st) => st.toString()).join('; ');
+	}
 
-// Compile array of statements into single statement
-yy.Statements.prototype.compile = function (db) {
-	var statements = this.statements.map(function (st) {
-		return st.compile(db);
-	});
-	if (statements.length === 1) {
-		return statements[0];
-	} else {
-		return function (params, cb) {
-			var res = statements.map(function (st) {
-				return st(params);
-			});
-			if (cb) {
-				cb(res);
-			}
-			return res;
-		};
+	// Compile array of statements into single statement
+	compile(db) {
+		const statements = this.statements.map((st) => st.compile(db));
+		return statements.length === 1
+			? statements[0]
+			: (params, cb) => {
+					const res = statements.map((st) => st(params));
+					if (cb) cb(res);
+					return res;
+			  };
 	}
 };
 
@@ -5282,1078 +5282,1051 @@ yy.Statements.prototype.compile = function (db) {
 //
 */
 
-function doSearch(databaseid, params, cb) {
-	var res;
-	var stope = {};
-	var fromdata;
-	var selectors = cloneDeep(this.selectors);
+/**
+	Search class
+	@example
+	SEARCH SUM(/a) FROM ? -- search over parameter object
+*/
 
-	function processSelector(selectors, sidx, value) {
-		//		var val;
+yy.Search = class Search {
+	constructor(params) {
+		Object.assign(this, params);
+	}
 
-		var val, // temp values use many places
-			nest, // temp value used many places
-			r, // temp value used many places
-			sel = selectors[sidx];
+	toString() {
+		let s = 'SEARCH ';
+		if (this.selectors) s += this.selectors.toString();
+		if (this.from) s += 'FROM ' + this.from.toString();
+		return s;
+	}
 
-		//		if(!alasql.srch[sel.srchid]) {
-		//			throw new Error('Selector "'+sel.srchid+'" not found');
-		//		};
+	toJS(context) {
+		const s = `this.queriesfn[${this.queriesidx - 1}](this.params,null,${context})`;
+		return s;
+	}
 
-		var INFINITE_LOOP_BREAK = alasql.options.loopbreak || 100000;
-
-		if (sel.selid) {
-			// TODO Process Selector
-			if (sel.selid === 'PATH') {
-				var queue = [{node: value, stack: []}];
-				var visited = {};
-				//var path = [];
-				var objects = alasql.databases[alasql.useid].objects;
-				while (queue.length > 0) {
-					var q = queue.shift();
-					var node = q.node;
-					var stack = q.stack;
-					var r = processSelector(sel.args, 0, node);
-					if (r.length > 0) {
-						if (sidx + 1 + 1 > selectors.length) {
-							return stack;
+	compile(databaseid) {
+		var dbid = databaseid;
+
+		var statement = (params, cb) => {
+			var res;
+			this.#doSearch(dbid, params, function (data) {
+				res = modify(statement.query, data);
+				if (cb) res = cb(res);
+			});
+			// if(cb) res = cb(res);
+			return res;
+		};
+		statement.query = {};
+		return statement;
+	}
+
+	#doSearch(databaseid, params, cb) {
+		var res;
+		var stope = {};
+		var fromdata;
+		var selectors = cloneDeep(this.selectors);
+
+		function processSelector(selectors, sidx, value) {
+			//		var val;
+
+			var val, // temp values use many places
+				nest, // temp value used many places
+				r, // temp value used many places
+				sel = selectors[sidx];
+
+			//		if(!alasql.srch[sel.srchid]) {
+			//			throw new Error('Selector "'+sel.srchid+'" not found');
+			//		};
+
+			var INFINITE_LOOP_BREAK = alasql.options.loopbreak || 100000;
+
+			if (sel.selid) {
+				// TODO Process Selector
+				if (sel.selid === 'PATH') {
+					var queue = [{node: value, stack: []}];
+					var visited = {};
+					//var path = [];
+					var objects = alasql.databases[alasql.useid].objects;
+					while (queue.length > 0) {
+						var q = queue.shift();
+						var node = q.node;
+						var stack = q.stack;
+						var r = processSelector(sel.args, 0, node);
+						if (r.length > 0) {
+							if (sidx + 1 + 1 > selectors.length) {
+								return stack;
+							} else {
+								var rv = [];
+								if (stack && stack.length > 0) {
+									stack.forEach(function (stv) {
+										rv = rv.concat(processSelector(selectors, sidx + 1, stv));
+									});
+								}
+								return rv;
+								//							return processSelector(selectors,sidx+1,stack);
+							}
 						} else {
-							var rv = [];
-							if (stack && stack.length > 0) {
-								stack.forEach(function (stv) {
-									rv = rv.concat(processSelector(selectors, sidx + 1, stv));
-								});
+							if (typeof visited[node.$id] !== 'undefined') {
+								continue;
+							} else {
+
+								visited[node.$id] = true;
+								if (node.$out && node.$out.length > 0) {
+									node.$out.forEach(function (edgeid) {
+										var edge = objects[edgeid];
+										var stack2 = stack.concat(edge);
+										stack2.push(objects[edge.$out[0]]);
+										queue.push({
+											node: objects[edge.$out[0]],
+											stack: stack2,
+										});
+									});
+								}
 							}
-							return rv;
-							//							return processSelector(selectors,sidx+1,stack);
 						}
+					}
+					// Else return fail
+					return [];
+				}
+				if (sel.selid === 'NOT') {
+					var nest = processSelector(sel.args, 0, value);
+
+					if (nest.length > 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return [value];
+						} else {
+							return processSelector(selectors, sidx + 1, value);
+						}
+					}
+				} else if (sel.selid === 'DISTINCT') {
+					var nest;
+					if (typeof sel.args === 'undefined' || sel.args.length === 0) {
+						nest = distinctArray(value);
+					} else {
+						nest = processSelector(sel.args, 0, value);
+					}
+					if (nest.length === 0) {
+						return [];
+					} else {
+						var res = distinctArray(nest);
+						if (sidx + 1 + 1 > selectors.length) {
+							return res;
+						} else {
+							return processSelector(selectors, sidx + 1, res);
+						}
+					}
+				} else if (sel.selid === 'AND') {
+					var res = true;
+					sel.args.forEach(function (se) {
+						res = res && processSelector(se, 0, value).length > 0;
+					});
+					if (!res) {
+						return [];
 					} else {
-						if (typeof visited[node.$id] !== 'undefined') {
-							continue;
+						if (sidx + 1 + 1 > selectors.length) {
+							return [value];
 						} else {
+							return processSelector(selectors, sidx + 1, value);
+						}
+					}
+				} else if (sel.selid === 'OR') {
+					var res = false;
+					sel.args.forEach(function (se) {
+						res = res || processSelector(se, 0, value).length > 0;
+					});
+					if (!res) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return [value];
+						} else {
+							return processSelector(selectors, sidx + 1, value);
+						}
+					}
+				} else if (sel.selid === 'ALL') {
+					var nest = processSelector(sel.args[0], 0, value);
+					if (nest.length === 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return nest;
+						} else {
+							return processSelector(selectors, sidx + 1, nest);
+						}
+					}
+				} else if (sel.selid === 'ANY') {
+					var nest = processSelector(sel.args[0], 0, value);
+					if (nest.length === 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return [nest[0]];
+						} else {
+							return processSelector(selectors, sidx + 1, [nest[0]]);
+						}
+					}
+				} else if (sel.selid === 'UNIONALL') {
+					var nest = [];
+					sel.args.forEach(function (se) {
+						nest = nest.concat(processSelector(se, 0, value));
+					});
+					if (nest.length === 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return nest;
+						} else {
+							return processSelector(selectors, sidx + 1, nest);
+						}
+					}
+				} else if (sel.selid === 'UNION') {
+					var nest = [];
+					sel.args.forEach(function (se) {
+						nest = nest.concat(processSelector(se, 0, value));
+					});
+					var nest = distinctArray(nest);
+					if (nest.length === 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return nest;
+						} else {
+							return processSelector(selectors, sidx + 1, nest);
+						}
+					}
+				} else if (sel.selid === 'IF') {
+					var nest = processSelector(sel.args, 0, value);
 
-							visited[node.$id] = true;
-							if (node.$out && node.$out.length > 0) {
-								node.$out.forEach(function (edgeid) {
-									var edge = objects[edgeid];
-									var stack2 = stack.concat(edge);
-									stack2.push(objects[edge.$out[0]]);
-									queue.push({
-										node: objects[edge.$out[0]],
-										stack: stack2,
-									});
+					if (nest.length === 0) {
+						return [];
+					} else {
+						if (sidx + 1 + 1 > selectors.length) {
+							return [value];
+						} else {
+							return processSelector(selectors, sidx + 1, value);
+						}
+					}
+				} else if (sel.selid === 'REPEAT') {
+
+					var lvar,
+						lmax,
+						lmin = sel.args[0].value;
+					if (!sel.args[1]) {
+						lmax = lmin; // Add security break
+					} else {
+						lmax = sel.args[1].value;
+					}
+					if (sel.args[2]) {
+						lvar = sel.args[2].variable;
+					}
+					//var lsel = sel.sels;
+
+					var retval = [];
+
+					if (lmin === 0) {
+						if (sidx + 1 + 1 > selectors.length) {
+							retval = [value];
+						} else {
+							if (lvar) {
+								alasql.vars[lvar] = 0;
+							}
+							retval = retval.concat(processSelector(selectors, sidx + 1, value));
+						}
+					}
+
+					// var nests = processSelector(sel.sels,0,value).slice();
+					if (lmax > 0) {
+						var nests = [{value: value, lvl: 1}];
+
+						var i = 0;
+						while (nests.length > 0) {
+							var nest = nests[0];
+
+							nests.shift();
+							if (nest.lvl <= lmax) {
+								if (lvar) {
+									alasql.vars[lvar] = nest.lvl;
+								}
+
+								var nest1 = processSelector(sel.sels, 0, nest.value);
+
+								nest1.forEach(function (n) {
+									nests.push({value: n, lvl: nest.lvl + 1});
 								});
+								if (nest.lvl >= lmin) {
+									if (sidx + 1 + 1 > selectors.length) {
+										retval = retval.concat(nest1);
+										//return nests;
+									} else {
+										nest1.forEach(function (n) {
+											retval = retval.concat(processSelector(selectors, sidx + 1, n));
+										});
+									}
+								}
+							}
+							// Security brake
+							i++;
+							if (i > INFINITE_LOOP_BREAK) {
+								throw new Error('Infinite loop brake. Number of iterations = ' + i);
 							}
 						}
 					}
-				}
-				// Else return fail
-				return [];
-			}
-			if (sel.selid === 'NOT') {
-				var nest = processSelector(sel.args, 0, value);
+					return retval;
+				} else if (sel.selid === 'OF') {
+					if (sidx + 1 + 1 > selectors.length) {
+						return [value];
+					} else {
+						var r1 = [];
+						Object.keys(value).forEach(function (keyv) {
+							alasql.vars[sel.args[0].variable] = keyv;
+							r1 = r1.concat(processSelector(selectors, sidx + 1, value[keyv]));
+						});
+						return r1;
+					}
+				} else if (sel.selid === 'TO') {
+
+					var oldv = alasql.vars[sel.args[0]];
+					var newv = [];
+					if (oldv !== undefined) {
+
+						newv = oldv.slice(0);
+
+					} else {
+						newv = [];
+					}
+					newv.push(value);
 
-				if (nest.length > 0) {
-					return [];
-				} else {
 					if (sidx + 1 + 1 > selectors.length) {
 						return [value];
 					} else {
-						return processSelector(selectors, sidx + 1, value);
+						alasql.vars[sel.args[0]] = newv;
+						var r1 = processSelector(selectors, sidx + 1, value);
+
+						alasql.vars[sel.args[0]] = oldv;
+						return r1;
+					}
+
+				} else if (sel.selid === 'ARRAY') {
+					var nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						val = nest;
+					} else {
+						return [];
 					}
-				}
-			} else if (sel.selid === 'DISTINCT') {
-				var nest;
-				if (typeof sel.args === 'undefined' || sel.args.length === 0) {
-					nest = distinctArray(value);
-				} else {
-					nest = processSelector(sel.args, 0, value);
-				}
-				if (nest.length === 0) {
-					return [];
-				} else {
-					var res = distinctArray(nest);
 					if (sidx + 1 + 1 > selectors.length) {
-						return res;
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, res);
+						return processSelector(selectors, sidx + 1, val);
+					}
+				} else if (sel.selid === 'SUM') {
+					var nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						var val = nest.reduce(function (sum, current) {
+							return sum + current;
+						}, 0);
+					} else {
+						return [];
 					}
-				}
-			} else if (sel.selid === 'AND') {
-				var res = true;
-				sel.args.forEach(function (se) {
-					res = res && processSelector(se, 0, value).length > 0;
-				});
-				if (!res) {
-					return [];
-				} else {
 					if (sidx + 1 + 1 > selectors.length) {
-						return [value];
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, value);
+						return processSelector(selectors, sidx + 1, val);
+					}
+				} else if (sel.selid === 'AVG') {
+					nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						val =
+							nest.reduce(function (sum, current) {
+								return sum + current;
+							}, 0) / nest.length;
+					} else {
+						return [];
 					}
-				}
-			} else if (sel.selid === 'OR') {
-				var res = false;
-				sel.args.forEach(function (se) {
-					res = res || processSelector(se, 0, value).length > 0;
-				});
-				if (!res) {
-					return [];
-				} else {
 					if (sidx + 1 + 1 > selectors.length) {
-						return [value];
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, value);
+						return processSelector(selectors, sidx + 1, val);
+					}
+				} else if (sel.selid === 'COUNT') {
+					nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						val = nest.length;
+					} else {
+						return [];
 					}
-				}
-			} else if (sel.selid === 'ALL') {
-				var nest = processSelector(sel.args[0], 0, value);
-				if (nest.length === 0) {
-					return [];
-				} else {
 					if (sidx + 1 + 1 > selectors.length) {
-						return nest;
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, nest);
+						return processSelector(selectors, sidx + 1, val);
+					}
+				} else if (sel.selid === 'FIRST') {
+					nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						val = nest[0];
+					} else {
+						return [];
 					}
-				}
-			} else if (sel.selid === 'ANY') {
-				var nest = processSelector(sel.args[0], 0, value);
 
-				if (nest.length === 0) {
-					return [];
-				} else {
 					if (sidx + 1 + 1 > selectors.length) {
-						return [nest[0]];
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, [nest[0]]);
+						return processSelector(selectors, sidx + 1, val);
 					}
-				}
-			} else if (sel.selid === 'UNIONALL') {
-				var nest = [];
-				sel.args.forEach(function (se) {
-					nest = nest.concat(processSelector(se, 0, value));
-				});
-				if (nest.length === 0) {
-					return [];
-				} else {
+				} else if (sel.selid === 'LAST') {
+					nest = processSelector(sel.args, 0, value);
+					if (nest.length > 0) {
+						val = nest[nest.length - 1];
+					} else {
+						return [];
+					}
+
 					if (sidx + 1 + 1 > selectors.length) {
-						return nest;
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, nest);
+						return processSelector(selectors, sidx + 1, val);
 					}
-				}
-			} else if (sel.selid === 'UNION') {
-				var nest = [];
-				sel.args.forEach(function (se) {
-					nest = nest.concat(processSelector(se, 0, value));
-				});
-				var nest = distinctArray(nest);
-				if (nest.length === 0) {
-					return [];
-				} else {
+				} else if (sel.selid === 'MIN') {
+					nest = processSelector(sel.args, 0, value);
+					if (nest.length === 0) {
+						return [];
+					}
+					var val = nest.reduce(function (min, current) {
+						return Math.min(min, current);
+					}, Infinity);
 					if (sidx + 1 + 1 > selectors.length) {
-						return nest;
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, nest);
+						return processSelector(selectors, sidx + 1, val);
 					}
-				}
-			} else if (sel.selid === 'IF') {
-				var nest = processSelector(sel.args, 0, value);
-
-				if (nest.length === 0) {
-					return [];
-				} else {
+				} else if (sel.selid === 'MAX') {
+					var nest = processSelector(sel.args, 0, value);
+					if (nest.length === 0) {
+						return [];
+					}
+					var val = nest.reduce(function (max, current) {
+						return Math.max(max, current);
+					}, -Infinity);
 					if (sidx + 1 + 1 > selectors.length) {
-						return [value];
+						return [val];
 					} else {
-						return processSelector(selectors, sidx + 1, value);
+						return processSelector(selectors, sidx + 1, val);
 					}
-				}
-			} else if (sel.selid === 'REPEAT') {
-
-				var lvar,
-					lmax,
-					lmin = sel.args[0].value;
-				if (!sel.args[1]) {
-					lmax = lmin; // Add security break
-				} else {
-					lmax = sel.args[1].value;
-				}
-				if (sel.args[2]) {
-					lvar = sel.args[2].variable;
-				}
-				//var lsel = sel.sels;
-
-				var retval = [];
-
-				if (lmin === 0) {
+				} else if (sel.selid === 'PLUS') {
+					var retval = [];
+					//				retval = retval.concat(processSelector(selectors,sidx+1,n))
+					var nests = processSelector(sel.args, 0, value).slice();
 					if (sidx + 1 + 1 > selectors.length) {
-						retval = [value];
+						retval = retval.concat(nests);
 					} else {
-						if (lvar) {
-							alasql.vars[lvar] = 0;
-						}
-						retval = retval.concat(processSelector(selectors, sidx + 1, value));
+						nests.forEach(function (n) {
+							retval = retval.concat(processSelector(selectors, sidx + 1, n));
+						});
 					}
-				}
-
-				// var nests = processSelector(sel.sels,0,value).slice();
-				if (lmax > 0) {
-					var nests = [{value: value, lvl: 1}];
 
 					var i = 0;
 					while (nests.length > 0) {
-						var nest = nests[0];
+						//					nest = nests[0];
+						//					nests.shift();
+						var nest = nests.shift();
 
-						nests.shift();
-						if (nest.lvl <= lmax) {
-							if (lvar) {
-								alasql.vars[lvar] = nest.lvl;
-							}
+						nest = processSelector(sel.args, 0, nest);
 
-							var nest1 = processSelector(sel.sels, 0, nest.value);
+						nests = nests.concat(nest);
 
-							nest1.forEach(function (n) {
-								nests.push({value: n, lvl: nest.lvl + 1});
+						if (sidx + 1 + 1 > selectors.length) {
+							retval = retval.concat(nest);
+							//return retval;
+						} else {
+							nest.forEach(function (n) {
+
+								var rn = processSelector(selectors, sidx + 1, n);
+
+								retval = retval.concat(rn);
 							});
-							if (nest.lvl >= lmin) {
-								if (sidx + 1 + 1 > selectors.length) {
-									retval = retval.concat(nest1);
-									//return nests;
-								} else {
-									nest1.forEach(function (n) {
-										retval = retval.concat(processSelector(selectors, sidx + 1, n));
-									});
-								}
-							}
 						}
+
 						// Security brake
 						i++;
 						if (i > INFINITE_LOOP_BREAK) {
 							throw new Error('Infinite loop brake. Number of iterations = ' + i);
 						}
 					}
-				}
-				return retval;
-			} else if (sel.selid === 'OF') {
-				if (sidx + 1 + 1 > selectors.length) {
-					return [value];
-				} else {
-					var r1 = [];
-					Object.keys(value).forEach(function (keyv) {
-						alasql.vars[sel.args[0].variable] = keyv;
-						r1 = r1.concat(processSelector(selectors, sidx + 1, value[keyv]));
-					});
-					return r1;
-				}
-			} else if (sel.selid === 'TO') {
-
-				var oldv = alasql.vars[sel.args[0]];
-				var newv = [];
-				if (oldv !== undefined) {
-
-					newv = oldv.slice(0);
-
-				} else {
-					newv = [];
-				}
-				newv.push(value);
-
-				if (sidx + 1 + 1 > selectors.length) {
-					return [value];
-				} else {
-					alasql.vars[sel.args[0]] = newv;
-					var r1 = processSelector(selectors, sidx + 1, value);
-
-					alasql.vars[sel.args[0]] = oldv;
-					return r1;
-				}
-
-			} else if (sel.selid === 'ARRAY') {
-				var nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					val = nest;
-				} else {
-					return [];
-				}
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'SUM') {
-				var nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					var val = nest.reduce(function (sum, current) {
-						return sum + current;
-					}, 0);
-				} else {
-					return [];
-				}
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'AVG') {
-				nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					val =
-						nest.reduce(function (sum, current) {
-							return sum + current;
-						}, 0) / nest.length;
-				} else {
-					return [];
-				}
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'COUNT') {
-				nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					val = nest.length;
-				} else {
-					return [];
-				}
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'FIRST') {
-				nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					val = nest[0];
-				} else {
-					return [];
-				}
-
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'LAST') {
-				nest = processSelector(sel.args, 0, value);
-				if (nest.length > 0) {
-					val = nest[nest.length - 1];
-				} else {
-					return [];
-				}
-
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'MIN') {
-				nest = processSelector(sel.args, 0, value);
-				if (nest.length === 0) {
-					return [];
-				}
-				var val = nest.reduce(function (min, current) {
-					return Math.min(min, current);
-				}, Infinity);
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'MAX') {
-				var nest = processSelector(sel.args, 0, value);
-				if (nest.length === 0) {
-					return [];
-				}
-				var val = nest.reduce(function (max, current) {
-					return Math.max(max, current);
-				}, -Infinity);
-				if (sidx + 1 + 1 > selectors.length) {
-					return [val];
-				} else {
-					return processSelector(selectors, sidx + 1, val);
-				}
-			} else if (sel.selid === 'PLUS') {
-				var retval = [];
-				//				retval = retval.concat(processSelector(selectors,sidx+1,n))
-				var nests = processSelector(sel.args, 0, value).slice();
-				if (sidx + 1 + 1 > selectors.length) {
-					retval = retval.concat(nests);
-				} else {
-					nests.forEach(function (n) {
-						retval = retval.concat(processSelector(selectors, sidx + 1, n));
-					});
-				}
-
-				var i = 0;
-				while (nests.length > 0) {
-					//					nest = nests[0];
-					//					nests.shift();
-					var nest = nests.shift();
-
-					nest = processSelector(sel.args, 0, nest);
-
-					nests = nests.concat(nest);
+					return retval;
 
+				} else if (sel.selid === 'STAR') {
+					var retval = [];
+					retval = processSelector(selectors, sidx + 1, value);
+					var nests = processSelector(sel.args, 0, value).slice();
 					if (sidx + 1 + 1 > selectors.length) {
-						retval = retval.concat(nest);
-						//return retval;
+						retval = retval.concat(nests);
+						//return nests;
 					} else {
-						nest.forEach(function (n) {
-
-							var rn = processSelector(selectors, sidx + 1, n);
-
-							retval = retval.concat(rn);
+						nests.forEach(function (n) {
+							retval = retval.concat(processSelector(selectors, sidx + 1, n));
 						});
 					}
+					var i = 0;
+					while (nests.length > 0) {
+						var nest = nests[0];
+						nests.shift();
 
-					// Security brake
-					i++;
-					if (i > INFINITE_LOOP_BREAK) {
-						throw new Error('Infinite loop brake. Number of iterations = ' + i);
-					}
-				}
-				return retval;
+						nest = processSelector(sel.args, 0, nest);
 
-			} else if (sel.selid === 'STAR') {
-				var retval = [];
-				retval = processSelector(selectors, sidx + 1, value);
-				var nests = processSelector(sel.args, 0, value).slice();
-				if (sidx + 1 + 1 > selectors.length) {
-					retval = retval.concat(nests);
-					//return nests;
-				} else {
-					nests.forEach(function (n) {
-						retval = retval.concat(processSelector(selectors, sidx + 1, n));
-					});
-				}
-				var i = 0;
-				while (nests.length > 0) {
-					var nest = nests[0];
-					nests.shift();
+						nests = nests.concat(nest);
 
-					nest = processSelector(sel.args, 0, nest);
+						if (sidx + 1 + 1 <= selectors.length) {
+							nest.forEach(function (n) {
+								retval = retval.concat(processSelector(selectors, sidx + 1, n));
+							});
+						}
 
-					nests = nests.concat(nest);
+						// Security brake
+						i++;
+						if (i > INFINITE_LOOP_BREAK) {
+							throw new Error('Infinite loop brake. Number of iterations = ' + i);
+						}
+					}
 
+					return retval;
+				} else if (sel.selid === 'QUESTION') {
+					var retval = [];
+					retval = retval.concat(processSelector(selectors, sidx + 1, value));
+					var nest = processSelector(sel.args, 0, value);
 					if (sidx + 1 + 1 <= selectors.length) {
 						nest.forEach(function (n) {
 							retval = retval.concat(processSelector(selectors, sidx + 1, n));
 						});
 					}
+					return retval;
+				} else if (sel.selid === 'WITH') {
+					var nest = processSelector(sel.args, 0, value);
 
-					// Security brake
-					i++;
-					if (i > INFINITE_LOOP_BREAK) {
-						throw new Error('Infinite loop brake. Number of iterations = ' + i);
-					}
-				}
-
-				return retval;
-			} else if (sel.selid === 'QUESTION') {
-				var retval = [];
-				retval = retval.concat(processSelector(selectors, sidx + 1, value));
-				var nest = processSelector(sel.args, 0, value);
-				if (sidx + 1 + 1 <= selectors.length) {
-					nest.forEach(function (n) {
-						retval = retval.concat(processSelector(selectors, sidx + 1, n));
-					});
-				}
-				return retval;
-			} else if (sel.selid === 'WITH') {
-				var nest = processSelector(sel.args, 0, value);
-
-				if (nest.length === 0) {
-					return [];
-				} else {
+					if (nest.length === 0) {
+						return [];
+					} else {
 
-					var r = {status: 1, values: nest};
-				}
-			} else if (sel.selid === 'ROOT') {
-				if (sidx + 1 + 1 > selectors.length) {
-					return [value];
+						var r = {status: 1, values: nest};
+					}
+				} else if (sel.selid === 'ROOT') {
+					if (sidx + 1 + 1 > selectors.length) {
+						return [value];
+					} else {
+						return processSelector(selectors, sidx + 1, fromdata);
+					}
 				} else {
-					return processSelector(selectors, sidx + 1, fromdata);
+					throw new Error('Wrong selector ' + sel.selid);
 				}
+			} else if (sel.srchid) {
+				var r = alasql.srch[sel.srchid.toUpperCase()](value, sel.args, stope, params);
+
 			} else {
-				throw new Error('Wrong selector ' + sel.selid);
+				throw new Error('Selector not found');
 			}
-		} else if (sel.srchid) {
-			var r = alasql.srch[sel.srchid.toUpperCase()](value, sel.args, stope, params);
 
-		} else {
-			throw new Error('Selector not found');
-		}
-
-		if (typeof r === 'undefined') {
-			r = {status: 1, values: [value]};
-		}
+			if (typeof r === 'undefined') {
+				r = {status: 1, values: [value]};
+			}
 
-		var res = [];
-		if (r.status === 1) {
-			var arr = r.values;
+			var res = [];
+			if (r.status === 1) {
+				var arr = r.values;
 
-			if (sidx + 1 + 1 > selectors.length) {
-				//			if(sidx+1+1 > selectors.length) {
-				res = arr;
+				if (sidx + 1 + 1 > selectors.length) {
+					//			if(sidx+1+1 > selectors.length) {
+					res = arr;
 
-			} else {
-				for (var i = 0; i < r.values.length; i++) {
-					res = res.concat(processSelector(selectors, sidx + 1, arr[i]));
+				} else {
+					for (var i = 0; i < r.values.length; i++) {
+						res = res.concat(processSelector(selectors, sidx + 1, arr[i]));
+					}
 				}
 			}
+			return res;
 		}
-		return res;
-	}
 
-	if (selectors !== undefined && selectors.length > 0) {
+		if (selectors !== undefined && selectors.length > 0) {
 
-		if (
-			selectors &&
-			selectors[0] &&
-			selectors[0].srchid === 'PROP' &&
-			selectors[0].args &&
-			selectors[0].args[0]
-		) {
+			if (
+				selectors &&
+				selectors[0] &&
+				selectors[0].srchid === 'PROP' &&
+				selectors[0].args &&
+				selectors[0].args[0]
+			) {
 
-			if (selectors[0].args[0].toUpperCase() === 'XML') {
-				stope.mode = 'XML';
-				selectors.shift();
-			} else if (selectors[0].args[0].toUpperCase() === 'HTML') {
-				stope.mode = 'HTML';
-				selectors.shift();
-			} else if (selectors[0].args[0].toUpperCase() === 'JSON') {
-				stope.mode = 'JSON';
+				if (selectors[0].args[0].toUpperCase() === 'XML') {
+					stope.mode = 'XML';
+					selectors.shift();
+				} else if (selectors[0].args[0].toUpperCase() === 'HTML') {
+					stope.mode = 'HTML';
+					selectors.shift();
+				} else if (selectors[0].args[0].toUpperCase() === 'JSON') {
+					stope.mode = 'JSON';
+					selectors.shift();
+				}
+			}
+			if (selectors.length > 0 && selectors[0].srchid === 'VALUE') {
+				stope.value = true;
 				selectors.shift();
 			}
 		}
-		if (selectors.length > 0 && selectors[0].srchid === 'VALUE') {
-			stope.value = true;
-			selectors.shift();
-		}
-	}
-
-	if (this.from instanceof yy.Column) {
-		var dbid = this.from.databaseid || databaseid;
-		fromdata = alasql.databases[dbid].tables[this.from.columnid].data;
-		//selectors.unshift({srchid:'CHILD'});
-	} else if (this.from instanceof yy.FuncValue && alasql.from[this.from.funcid.toUpperCase()]) {
-		var args = this.from.args.map(function (arg) {
-			var as = arg.toJS();
-
-			var fn = new Function('params,alasql', 'var y;return ' + as).bind(this);
-			return fn(params, alasql);
-		});
-
-		fromdata = alasql.from[this.from.funcid.toUpperCase()].apply(this, args);
-
-	} else if (typeof this.from === 'undefined') {
-		fromdata = alasql.databases[databaseid].objects;
-	} else {
-		var fromfn = new Function('params,alasql', 'var y;return ' + this.from.toJS());
-		fromdata = fromfn(params, alasql);
-		// Check for Mogo Collections
-		if (
-			typeof Mongo === 'object' &&
-			typeof Mongo.Collection !== 'object' &&
-			fromdata instanceof Mongo.Collection
-		) {
-			fromdata = fromdata.find().fetch();
-		}
-
-		//		if(typeof fromdata == 'object' && Array.isArray(fromdata)) {
-		//			selectors.unshift({srchid:'CHILD'});
-		//		}
-	}
 
-	// If source data is array than first step is to run over array
-	//	var selidx = 0;
-	//	var selvalue = fromdata;
+		if (this.from instanceof yy.Column) {
+			var dbid = this.from.databaseid || databaseid;
+			fromdata = alasql.databases[dbid].tables[this.from.columnid].data;
+			//selectors.unshift({srchid:'CHILD'});
+		} else if (this.from instanceof yy.FuncValue && alasql.from[this.from.funcid.toUpperCase()]) {
+			var args = this.from.args.map(function (arg) {
+				var as = arg.toJS();
 
-	if (selectors !== undefined && selectors.length > 0) {
-		// Init variables for TO() selectors
-
-		if (false) {
-			selectors.forEach(function (selector) {
-				if (selector.srchid === 'TO') {
-					//* @todo move to TO selector
-					alasql.vars[selector.args[0]] = [];
-					// TODO - process nested selectors
-				}
+				var fn = new Function('params,alasql', 'var y;return ' + as).bind(this);
+				return fn(params, alasql);
 			});
-		}
-
-		res = processSelector(selectors, 0, fromdata);
-	} else {
-		res = fromdata;
-	}
-
-	if (this.into) {
-		var a1, a2;
-		if (typeof this.into.args[0] !== 'undefined') {
-			a1 = new Function('params,alasql', 'var y;return ' + this.into.args[0].toJS())(
-				params,
-				alasql
-			);
-		}
-		if (typeof this.into.args[1] !== 'undefined') {
-			a2 = new Function('params,alasql', 'var y;return ' + this.into.args[1].toJS())(
-				params,
-				alasql
-			);
-		}
-		res = alasql.into[this.into.funcid.toUpperCase()](a1, a2, res, [], cb);
-	} else {
-		if (stope.value && res.length > 0) {
-			res = res[0];
-		}
-		if (cb) {
-			res = cb(res);
-		}
-	}
-	return res;
-}
 
-/**	
-	Search class
-	@class
-	@example
-	SEARCH SUM(/a) FROM ? -- search over parameter object
-*/
-
-yy.Search = function (params) {
-	return yy.extend(this, params);
-};
+			fromdata = alasql.from[this.from.funcid.toUpperCase()].apply(this, args);
 
-yy.Search.prototype.toString = function () {
-	var s = 'SEARCH' + ' ';
-	if (this.selectors) {
-		s += this.selectors.toString();
-	}
-	if (this.from) {
-		s += 'FROM' + ' ' + this.from.toString();
-	}
-
-	return s;
-};
-
-yy.Search.prototype.toJS = function (context) {
+		} else if (typeof this.from === 'undefined') {
+			fromdata = alasql.databases[databaseid].objects;
+		} else {
+			var fromfn = new Function('params,alasql', 'var y;return ' + this.from.toJS());
+			fromdata = fromfn(params, alasql);
+			// Check for Mogo Collections
+			if (
+				typeof Mongo === 'object' &&
+				typeof Mongo.Collection !== 'object' &&
+				fromdata instanceof Mongo.Collection
+			) {
+				fromdata = fromdata.find().fetch();
+			}
 
-	var s = 'this.queriesfn[' + (this.queriesidx - 1) + '](this.params,null,' + context + ')';
-	// var s = '';
-	return s;
-};
+			//		if(typeof fromdata == 'object' && Array.isArray(fromdata)) {
+			//			selectors.unshift({srchid:'CHILD'});
+			//		}
+		}
 
-yy.Search.prototype.compile = function (databaseid) {
-	var dbid = databaseid;
-	var self = this;
+		// If source data is array than first step is to run over array
+		//	var selidx = 0;
+		//	var selvalue = fromdata;
 
-	var statement = function (params, cb) {
+		if (selectors !== undefined && selectors.length > 0) {
+			// Init variables for TO() selectors
 
-		var res;
-		doSearch.bind(self)(dbid, params, function (data) {
+			if (false) {
+				selectors.forEach(function (selector) {
+					if (selector.srchid === 'TO') {
+						//* @todo move to TO selector
+						alasql.vars[selector.args[0]] = [];
+						// TODO - process nested selectors
+					}
+				});
+			}
 
-			res = modify(statement.query, data);
+			res = processSelector(selectors, 0, fromdata);
+		} else {
+			res = fromdata;
+		}
 
+		if (this.into) {
+			var a1, a2;
+			if (typeof this.into.args[0] !== 'undefined') {
+				a1 = new Function('params,alasql', 'var y;return ' + this.into.args[0].toJS())(
+					params,
+					alasql
+				);
+			}
+			if (typeof this.into.args[1] !== 'undefined') {
+				a2 = new Function('params,alasql', 'var y;return ' + this.into.args[1].toJS())(
+					params,
+					alasql
+				);
+			}
+			res = alasql.into[this.into.funcid.toUpperCase()](a1, a2, res, [], cb);
+		} else {
+			if (stope.value && res.length > 0) {
+				res = res[0];
+			}
 			if (cb) {
 				res = cb(res);
 			}
-		});
-
-		//		if(cb) res = cb(res);
-		return res;
-	};
-	statement.query = {};
-	return statement;
+		}
+		return res;
+	}
 };
 
 // List of search functions
-alasql.srch = {};
+alasql.srch = {
+	PROP(val, args, stope) {
 
-alasql.srch.PROP = function (val, args, stope) {
+		if (stope.mode === 'XML') {
+			const values = val.children.filter((v) => v.name.toUpperCase() === args[0].toUpperCase());
 
-	if (stope.mode === 'XML') {
-		var arr = [];
-		val.children.forEach(function (v) {
-			if (v.name.toUpperCase() === args[0].toUpperCase()) {
-				arr.push(v);
-			}
-		});
-		if (arr.length > 0) {
-			return {status: 1, values: arr};
+			return {
+				status: values.length ? 1 : -1,
+				values,
+			};
 		} else {
-			return {status: -1, values: []};
+			if (
+				typeof val !== 'object' ||
+				val === null ||
+				typeof args !== 'object' ||
+				typeof val[args[0]] === 'undefined'
+			) {
+				return {status: -1, values: []};
+			} else {
+				return {status: 1, values: [val[args[0]]]};
+			}
 		}
-	} else {
+	},
+
+	APROP(val, args) {
 		if (
 			typeof val !== 'object' ||
 			val === null ||
 			typeof args !== 'object' ||
 			typeof val[args[0]] === 'undefined'
 		) {
-			return {status: -1, values: []};
+			return {status: 1, values: [undefined]};
 		} else {
 			return {status: 1, values: [val[args[0]]]};
 		}
-	}
-};
+	},
 
-alasql.srch.APROP = function (val, args) {
-	if (
-		typeof val !== 'object' ||
-		val === null ||
-		typeof args !== 'object' ||
-		typeof val[args[0]] === 'undefined'
-	) {
-		return {status: 1, values: [undefined]};
-	} else {
-		return {status: 1, values: [val[args[0]]]};
-	}
-};
-
-// Test expression
-alasql.srch.EQ = function (val, args, stope, params) {
-	var exprs = args[0].toJS('x', '');
-	var exprfn = new Function('x,alasql,params', 'return ' + exprs);
-	if (val === exprfn(val, alasql, params)) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
-
-// Test expression
-alasql.srch.LIKE = function (val, args, stope, params) {
-	var exprs = args[0].toJS('x', '');
-	var exprfn = new Function('x,alasql,params', 'return ' + exprs);
-	if (
-		val
-			.toUpperCase()
-			.match(
-				new RegExp(
-					'^' +
-						exprfn(val, alasql, params).toUpperCase().replace(/%/g, '.*').replace(/\?|_/g, '.') +
-						'$'
-				),
-				'g'
-			)
-	) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	EQ(val, args, stope, params) {
+		var exprs = args[0].toJS('x', '');
+		var exprfn = new Function('x,alasql,params', 'return ' + exprs);
+		if (val === exprfn(val, alasql, params)) {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-alasql.srch.ATTR = function (val, args, stope) {
-	if (stope.mode === 'XML') {
-		if (typeof args === 'undefined') {
-			return {status: 1, values: [val.attributes]};
+	// Test expression
+	LIKE(val, args, stope, params) {
+		var exprs = args[0].toJS('x', '');
+		var exprfn = new Function('x,alasql,params', 'return ' + exprs);
+		if (
+			val
+				.toUpperCase()
+				.match(
+					new RegExp(
+						'^' +
+							exprfn(val, alasql, params).toUpperCase().replace(/%/g, '.*').replace(/\?|_/g, '.') +
+							'$'
+					),
+					'g'
+				)
+		) {
+			return {status: 1, values: [val]};
 		} else {
-			if (
-				typeof val === 'object' &&
-				typeof val.attributes === 'object' &&
-				typeof val.attributes[args[0]] !== 'undefined'
-			) {
-				return {status: 1, values: [val.attributes[args[0]]]};
+			return {status: -1, values: []};
+		}
+	},
+
+	ATTR(val, args, stope) {
+		if (stope.mode === 'XML') {
+			if (typeof args === 'undefined') {
+				return {status: 1, values: [val.attributes]};
 			} else {
-				return {status: -1, values: []};
+				if (
+					typeof val === 'object' &&
+					typeof val.attributes === 'object' &&
+					typeof val.attributes[args[0]] !== 'undefined'
+				) {
+					return {status: 1, values: [val.attributes[args[0]]]};
+				} else {
+					return {status: -1, values: []};
+				}
 			}
+		} else {
+			throw new Error('ATTR is not using in usual mode');
 		}
-	} else {
-		throw new Error('ATTR is not using in usual mode');
-	}
-};
+	},
 
-alasql.srch.CONTENT = function (val, args, stope) {
-	if (stope.mode === 'XML') {
+	CONTENT(val, args, stope) {
+		if (stope.mode !== 'XML') {
+			throw new Error('ATTR is not using in usual mode');
+		}
 		return {status: 1, values: [val.content]};
-	} else {
-		throw new Error('ATTR is not using in usual mode');
-	}
-};
-
-alasql.srch.SHARP = function (val, args) {
-	var obj = alasql.databases[alasql.useid].objects[args[0]];
-	if (typeof val !== 'undefined' && val === obj) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	},
 
-alasql.srch.PARENT = function (/*val,args,stope*/) {
-	// TODO: implement
-	console.error('PARENT not implemented', arguments);
-
-	return {status: -1, values: []};
-};
-
-alasql.srch.CHILD = function (val, args, stope) {
-
-	if (typeof val === 'object') {
-		if (Array.isArray(val)) {
-			return {status: 1, values: val};
+	SHARP(val, args) {
+		const obj = alasql.databases[alasql.useid].objects[args[0]];
+		if (val !== undefined && val === obj) {
+			return {status: 1, values: [val]};
 		} else {
-			if (stope.mode === 'XML') {
-				return {
-					status: 1,
-					values: Object.keys(val.children).map(function (key) {
-						return val.children[key];
-					}),
-				};
-			} else {
-				return {
-					status: 1,
-					values: Object.keys(val).map(function (key) {
-						return val[key];
-					}),
-				};
-			}
+			return {status: -1, values: []};
 		}
-	} else {
-		// If primitive value
-		return {status: 1, values: []};
-	}
-};
-
-// Return all keys
-alasql.srch.KEYS = function (val) {
-	if (typeof val === 'object' && val !== null) {
-		return {status: 1, values: Object.keys(val)};
-	} else {
-		// If primitive value
-		return {status: 1, values: []};
-	}
-};
+	},
 
-// Test expression
-alasql.srch.WHERE = function (val, args, stope, params) {
-	var exprs = args[0].toJS('x', '');
-	var exprfn = new Function('x,alasql,params', 'return ' + exprs);
-	if (exprfn(val, alasql, params)) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
-
-alasql.srch.NAME = function (val, args) {
-	if (val.name === args[0]) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
-
-alasql.srch.CLASS = function (val, args) {
-
-	// Please avoid `===` here
-	if (val.$class == args) {
-		// jshint ignore:line
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	PARENT(/*val,args,stope*/) {
+		// TODO: implement
+		console.error('PARENT not implemented', arguments);
 
-// Transform expression
-alasql.srch.VERTEX = function (val) {
-	if (val.$node === 'VERTEX') {
-		return {status: 1, values: [val]};
-	} else {
 		return {status: -1, values: []};
-	}
-};
+	},
 
-// Transform expression
-alasql.srch.INSTANCEOF = function (val, args) {
-	if (val instanceof alasql.fn[args[0]]) {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	CHILD(val, args, stope) {
 
-// Transform expression
-alasql.srch.EDGE = function (val) {
-	if (val.$node === 'EDGE') {
-		return {status: 1, values: [val]};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+		if (typeof val === 'object') {
+			if (Array.isArray(val)) {
+				return {status: 1, values: val};
+			} else {
+				if (stope.mode === 'XML') {
+					return {
+						status: 1,
+						values: Object.keys(val.children).map(function (key) {
+							return val.children[key];
+						}),
+					};
+				} else {
+					return {
+						status: 1,
+						values: Object.keys(val).map(function (key) {
+							return val[key];
+						}),
+					};
+				}
+			}
+		} else {
+			// If primitive value
+			return {status: 1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.EX = function (val, args, stope, params) {
-	var exprs = args[0].toJS('x', '');
-	var exprfn = new Function('x,alasql,params', 'return ' + exprs);
-	return {status: 1, values: [exprfn(val, alasql, params)]};
-};
+	// Return all keys
+	KEYS(val) {
+		if (typeof val === 'object' && val !== null) {
+			return {status: 1, values: Object.keys(val)};
+		} else {
+			// If primitive value
+			return {status: 1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.RETURN = function (val, args, stope, params) {
-	var res = {};
-	if (args && args.length > 0) {
-		args.forEach(function (arg) {
-			var exprs = arg.toJS('x', '');
-			var exprfn = new Function('x,alasql,params', 'return ' + exprs);
-			if (typeof arg.as === 'undefined') {
-				arg.as = arg.toString();
-			}
-			res[arg.as] = exprfn(val, alasql, params);
-		});
-	}
-	return {status: 1, values: [res]};
-};
+	// Test expression
+	WHERE(val, args, stope, params) {
+		var exprs = args[0].toJS('x', '');
+		var exprfn = new Function('x,alasql,params', 'return ' + exprs);
+		if (exprfn(val, alasql, params)) {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.REF = function (val) {
-	return {status: 1, values: [alasql.databases[alasql.useid].objects[val]]};
-};
+	NAME(val, args) {
+		if (val.name === args[0]) {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.OUT = function (val) {
-	if (val.$out && val.$out.length > 0) {
-		var res = val.$out.map(function (v) {
-			return alasql.databases[alasql.useid].objects[v];
-		});
-		return {status: 1, values: res};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	CLASS(val, args) {
 
-alasql.srch.OUTOUT = function (val) {
-	if (val.$out && val.$out.length > 0) {
-		var res = [];
-		val.$out.forEach(function (v) {
-			var av = alasql.databases[alasql.useid].objects[v];
-			if (av && av.$out && av.$out.length > 0) {
-				av.$out.forEach(function (vv) {
-					res = res.concat(alasql.databases[alasql.useid].objects[vv]);
-				});
-			}
-		});
-		return {status: 1, values: res};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+		// Please avoid `===` here
+		if (val.$class == args) {
+			// jshint ignore:line
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.IN = function (val) {
-	if (val.$in && val.$in.length > 0) {
-		var res = val.$in.map(function (v) {
-			return alasql.databases[alasql.useid].objects[v];
-		});
-		return {status: 1, values: res};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	// Transform expression
+	VERTEX(val) {
+		if (val.$node === 'VERTEX') {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-alasql.srch.ININ = function (val) {
-	if (val.$in && val.$in.length > 0) {
-		var res = [];
-		val.$in.forEach(function (v) {
-			var av = alasql.databases[alasql.useid].objects[v];
-			if (av && av.$in && av.$in.length > 0) {
-				av.$in.forEach(function (vv) {
-					res = res.concat(alasql.databases[alasql.useid].objects[vv]);
-				});
-			}
-		});
-		return {status: 1, values: res};
-	} else {
-		return {status: -1, values: []};
-	}
-};
+	// Transform expression
+	INSTANCEOF(val, args) {
+		if (val instanceof alasql.fn[args[0]]) {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.AS = function (val, args) {
-	alasql.vars[args[0]] = val;
-	return {status: 1, values: [val]};
-};
+	// Transform expression
+	EDGE(val) {
+		if (val.$node === 'EDGE') {
+			return {status: 1, values: [val]};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
+
+	// Transform expression
+	EX(val, args, stope, params) {
+		var exprs = args[0].toJS('x', '');
+		var exprfn = new Function('x,alasql,params', 'return ' + exprs);
+		return {status: 1, values: [exprfn(val, alasql, params)]};
+	},
+
+	// Transform expression
+	RETURN(val, args, stope, params) {
+		var res = {};
+		if (args && args.length > 0) {
+			args.forEach(function (arg) {
+				var exprs = arg.toJS('x', '');
+				var exprfn = new Function('x,alasql,params', 'return ' + exprs);
+				if (typeof arg.as === 'undefined') {
+					arg.as = arg.toString();
+				}
+				res[arg.as] = exprfn(val, alasql, params);
+			});
+		}
+		return {status: 1, values: [res]};
+	},
 
-// Transform expression
-alasql.srch.AT = function (val, args) {
-	var v = alasql.vars[args[0]];
-	return {status: 1, values: [v]};
-};
+	// Transform expression
+	REF(val) {
+		return {status: 1, values: [alasql.databases[alasql.useid].objects[val]]};
+	},
 
-// Transform expression
-alasql.srch.CLONEDEEP = function (val) {
-	// TODO something wrong
-	var z = cloneDeep(val);
-	return {status: 1, values: [z]};
-};
+	// Transform expression
+	OUT(val) {
+		if (val.$out && val.$out.length > 0) {
+			var res = val.$out.map(function (v) {
+				return alasql.databases[alasql.useid].objects[v];
+			});
+			return {status: 1, values: res};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// // Transform expression
-// alasql.srch.DELETE = function(val,args) {
+	OUTOUT(val) {
+		if (val.$out && val.$out.length > 0) {
+			var res = [];
+			val.$out.forEach(function (v) {
+				var av = alasql.databases[alasql.useid].objects[v];
+				if (av && av.$out && av.$out.length > 0) {
+					av.$out.forEach(function (vv) {
+						res = res.concat(alasql.databases[alasql.useid].objects[vv]);
+					});
+				}
+			});
+			return {status: 1, values: res};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// };
+	// Transform expression
+	IN(val) {
+		if (val.$in && val.$in.length > 0) {
+			var res = val.$in.map(function (v) {
+				return alasql.databases[alasql.useid].objects[v];
+			});
+			return {status: 1, values: res};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-// Transform expression
-alasql.srch.SET = function (val, args, stope, params) {
+	ININ(val) {
+		if (val.$in && val.$in.length > 0) {
+			var res = [];
+			val.$in.forEach(function (v) {
+				var av = alasql.databases[alasql.useid].objects[v];
+				if (av && av.$in && av.$in.length > 0) {
+					av.$in.forEach(function (vv) {
+						res = res.concat(alasql.databases[alasql.useid].objects[vv]);
+					});
+				}
+			});
+			return {status: 1, values: res};
+		} else {
+			return {status: -1, values: []};
+		}
+	},
 
-	var s = args
-		.map(function (st) {
+	// Transform expression
+	AS(val, args) {
+		alasql.vars[args[0]] = val;
+		return {status: 1, values: [val]};
+	},
+
+	// Transform expression
+	AT(val, args) {
+		var v = alasql.vars[args[0]];
+		return {status: 1, values: [v]};
+	},
+
+	// Transform expression
+	CLONEDEEP(val) {
+		// TODO something wrong
+		var z = cloneDeep(val);
+		return {status: 1, values: [z]};
+	},
+
+	// // Transform expression
+	// DELETE (val,args) {
+	// 	// TODO something wrong
+	// 	delete val;
+	//   return {status: 1, values: []};
+	// },
+
+	// Transform expression
+	SET(val, args, stope, params) {
+
+		var s = args
+			.map(function (st) {
 
-			if (st.method === '@') {
-				return "alasql.vars['" + st.variable + "']=" + st.expression.toJS('x', '');
-			} else if (st.method === '$') {
-				return "params['" + st.variable + "']=" + st.expression.toJS('x', '');
-			} else {
-				return "x['" + st.column.columnid + "']=" + st.expression.toJS('x', '');
-			}
-		})
-		.join(';');
-	var setfn = new Function('x,params,alasql', s);
+				if (st.method === '@') {
+					return "alasql.vars['" + st.variable + "']=" + st.expression.toJS('x', '');
+				} else if (st.method === '$') {
+					return "params['" + st.variable + "']=" + st.expression.toJS('x', '');
+				} else {
+					return "x['" + st.column.columnid + "']=" + st.expression.toJS('x', '');
+				}
+			})
+			.join(';');
+		var setfn = new Function('x,params,alasql', s);
 
-	setfn(val, params, alasql);
+		setfn(val, params, alasql);
 
-	return {status: 1, values: [val]};
-};
+		return {status: 1, values: [val]};
+	},
 
-alasql.srch.ROW = function (val, args, stope, params) {
-	var s = 'var y;return [';
+	ROW(val, args, stope, params) {
+		var s = 'var y;return [';
+		s += args.map((arg) => arg.toJS('x', '')).join(',');
+		s += ']';
+		var setfn = new Function('x,params,alasql', s);
+		var rv = setfn(val, params, alasql);
 
-	s += args
-		.map(function (arg) {
-			return arg.toJS('x', '');
-		})
-		.join(',');
-	s += ']';
-	var setfn = new Function('x,params,alasql', s);
-	var rv = setfn(val, params, alasql);
+		return {status: 1, values: [rv]};
+	},
 
-	return {status: 1, values: [rv]};
-};
+	D3(val) {
+		if (val.$node !== 'VERTEX' && val.$node === 'EDGE') {
+			val.source = val.$in[0];
+			val.target = val.$out[0];
+		}
 
-alasql.srch.D3 = function (val) {
-	if (val.$node !== 'VERTEX' && val.$node === 'EDGE') {
-		val.source = val.$in[0];
-		val.target = val.$out[0];
-	}
+		return {status: 1, values: [val]};
+	},
 
-	return {status: 1, values: [val]};
+	ORDERBY(val, args /*, stope */) {
+		var res = val.sort(compileSearchOrder(args));
+		return {status: 1, values: res};
+	},
 };
 
 var compileSearchOrder = function (order) {
 	if (order) {
-
-		if (
-			order &&
-			order.length === 1 &&
-			order[0].expression &&
-			typeof order[0].expression === 'function'
-		) {
-
+		if (typeof order?.[0]?.expression === 'function') {
 			var func = order[0].expression;
-
 			return function (a, b) {
 				var ra = func(a),
 					rb = func(b);
@@ -6447,12 +6420,6 @@ var compileSearchOrder = function (order) {
 	}
 };
 
-alasql.srch.ORDERBY = function (val, args /*,stope*/) {
-
-	var res = val.sort(compileSearchOrder(args));
-	return {status: 1, values: res};
-};
-
 // Main query procedure
 function queryfn(query, oldscope, cb, A, B) {
 	var aaa = query.sources.length;
@@ -7284,7 +7251,7 @@ function swapSources(query, h) {
 /* global yy */
 
 yy.Select = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Select.prototype.toString = function () {
 	var s;
@@ -7808,7 +7775,7 @@ yy.Select.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.ExistsValue = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ExistsValue.prototype.toString = function () {
 	return 'EXISTS(' + this.value.toString() + ')';
@@ -10128,7 +10095,7 @@ yy.Select.prototype.compileDefCols = function (query, databaseid) {
 // SELECT UNION statement
 
 yy.Union = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Union.prototype.toString = function () {
 	return 'UNION';
@@ -10147,7 +10114,7 @@ yy.Union.prototype.compile = function (tableid) {
 */
 
 yy.Apply = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 
 yy.Apply.prototype.toString = function () {
@@ -10167,7 +10134,7 @@ yy.Apply.prototype.toString = function () {
 */
 
 yy.Over = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Over.prototype.toString = function () {
 	var s = 'OVER (';
@@ -10190,13 +10157,15 @@ yy.Over.prototype.toString = function () {
 //
 */
 
+var assign = Object.assign;
+
 /**
 		Expression statement ( = 2*2; )
 		@class
 	@param {object} params Initial parameters
 */
 yy.ExpressionStatement = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 
 /**
@@ -10237,7 +10206,7 @@ yy.ExpressionStatement.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Expression = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 
 /**
@@ -10309,7 +10278,7 @@ yy.Expression.prototype.compile = function (context, tableid, defcols) {
 	@class
 */
 yy.JavaScript = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.JavaScript.prototype.toString = function () {
 	var s = '``' + this.value + '``';
@@ -10337,7 +10306,7 @@ yy.JavaScript.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Literal = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.Literal.prototype.toString = function () {
 	var s = this.value;
@@ -10354,7 +10323,7 @@ yy.Literal.prototype.toString = function () {
 */
 
 yy.Join = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.Join.prototype.toString = function () {
 	var s = ' ';
@@ -10371,7 +10340,7 @@ yy.Join.prototype.toString = function () {
 */
 
 yy.Table = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.Table.prototype.toString = function () {
 	var s = this.tableid;
@@ -10388,7 +10357,7 @@ yy.Table.prototype.toString = function () {
 */
 
 yy.View = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.View.prototype.toString = function () {
 	var s = this.viewid;
@@ -10404,7 +10373,7 @@ yy.View.prototype.toString = function () {
 	@class
 */
 yy.Op = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.Op.prototype.toString = function () {
 	if (this.op === 'IN' || this.op === 'NOT IN') {
@@ -10602,9 +10571,9 @@ yy.Op.prototype.toJS = function (context, tableid, defcols) {
 					||
 					(
 						${leftOperand}  < 0
-						&& 
-						true == ${rightOperand} 
-					) 
+						&&
+						true == ${rightOperand}
+					)
 				)`;
 		}
 	}
@@ -10790,7 +10759,7 @@ yy.Op.prototype.toJS = function (context, tableid, defcols) {
 };
 
 yy.VarValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.VarValue.prototype.toString = function () {
 	return '@' + this.variable;
@@ -10805,7 +10774,7 @@ yy.VarValue.prototype.toJS = function () {
 };
 
 yy.NumValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.NumValue.prototype.toString = function () {
 	return this.value.toString();
@@ -10820,7 +10789,7 @@ yy.NumValue.prototype.toJS = function () {
 };
 
 yy.StringValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.StringValue.prototype.toString = function () {
 	return "'" + this.value.toString() + "'";
@@ -10835,7 +10804,7 @@ yy.StringValue.prototype.toJS = function () {
 };
 
 yy.DomainValueValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.DomainValueValue.prototype.toString = function () {
 	return 'VALUE';
@@ -10852,7 +10821,7 @@ yy.DomainValueValue.prototype.toJS = function (context, tableid, defcols) {
 };
 
 yy.ArrayValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.ArrayValue.prototype.toString = function () {
 	return 'ARRAY[]';
@@ -10875,7 +10844,7 @@ yy.ArrayValue.prototype.toJS = function (context, tableid, defcols) {
 };
 
 yy.LogicValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.LogicValue.prototype.toString = function () {
 	return this.value ? 'TRUE' : 'FALSE';
@@ -10890,7 +10859,7 @@ yy.LogicValue.prototype.toJS = function () {
 };
 
 yy.NullValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.NullValue.prototype.toString = function () {
 	return 'NULL';
@@ -10901,7 +10870,7 @@ yy.NullValue.prototype.toJS = function () {
 };
 
 yy.ParamValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.ParamValue.prototype.toString = function () {
 	return '$' + this.param;
@@ -10915,7 +10884,7 @@ yy.ParamValue.prototype.toJS = function () {
 };
 
 yy.UniOp = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.UniOp.prototype.toString = function () {
 	var s;
@@ -11005,7 +10974,7 @@ yy.UniOp.prototype.toJS = function (context, tableid, defcols) {
 };
 
 yy.Column = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.Column.prototype.toString = function () {
 	var s;
@@ -11086,7 +11055,7 @@ yy.Column.prototype.toJS = function (context, tableid, defcols) {
 };
 
 yy.AggrValue = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.AggrValue.prototype.toString = function () {
 	var s = '';
@@ -11161,13 +11130,13 @@ yy.AggrValue.prototype.toJS = function () {
 };
 
 yy.OrderExpression = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 
 yy.OrderExpression.prototype.toString = yy.Expression.prototype.toString;
 
 yy.GroupExpression = function (params) {
-	return yy.extend(this, params);
+	return assign(this, params);
 };
 yy.GroupExpression.prototype.toString = function () {
 	return this.type + '(' + this.group.toString() + ')';
@@ -11348,7 +11317,7 @@ yy.Select.prototype.Where = function (expr) {
 */
 
 yy.FuncValue = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 
 var re_invalidFnNameChars = /[^0-9A-Z_$]+/i;
@@ -11810,7 +11779,7 @@ stdfn.NEWID =
 */
 
 yy.CaseValue = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CaseValue.prototype.toString = function () {
 	var s = 'CASE ';
@@ -11884,7 +11853,7 @@ yy.CaseValue.prototype.toJS = function (context, tableid, defcols) {
 */
 
 yy.Json = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Json.prototype.toString = function () {
 	var s = ''; // '@'
@@ -11993,7 +11962,7 @@ yy.Json.prototype.toJS = function (context, tableid, defcols) {
 */
 
 yy.Convert = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Convert.prototype.toString = function () {
 	var s = 'CONVERT(';
@@ -12287,7 +12256,7 @@ alasql.stdfn.CONVERT = function (value, args) {
 /* global alasql, yy, hash */
 
 yy.ColumnDef = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ColumnDef.prototype.toString = function () {
 	var s = this.columnid;
@@ -12315,7 +12284,7 @@ yy.ColumnDef.prototype.toString = function () {
 };
 
 yy.CreateTable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateTable.prototype.toString = function () {
 	var s = 'CREATE';
@@ -13133,7 +13102,7 @@ function newDate(d) {
 */
 
 yy.DropTable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.DropTable.prototype.toString = function () {
 	var s = 'DROP' + ' ';
@@ -13206,7 +13175,7 @@ yy.DropTable.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.TruncateTable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.TruncateTable.prototype.toString = function () {
 	var s = 'TRUNCATE TABLE';
@@ -13242,7 +13211,7 @@ yy.TruncateTable.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.CreateVertex = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateVertex.prototype.toString = function () {
 	var s = 'CREATE VERTEX ';
@@ -13325,7 +13294,7 @@ yy.CreateVertex.prototype.compile = function (databaseid) {
 };
 
 yy.CreateEdge = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateEdge.prototype.toString = function () {
 
@@ -13418,7 +13387,7 @@ yy.CreateEdge.prototype.compile = function (databaseid) {
 };
 
 yy.CreateGraph = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateGraph.prototype.toString = function () {
 	var s = 'CREATE GRAPH' + ' ';
@@ -13683,7 +13652,7 @@ yy.CreateGraph.prototype.compile1 = function (databaseid) {
 
 // ALTER TABLE table1 RENAME TO table2
 yy.AlterTable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.AlterTable.prototype.toString = function () {
 	var s = 'ALTER TABLE ' + this.table.toString();
@@ -13860,7 +13829,7 @@ yy.AlterTable.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.CreateIndex = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateIndex.prototype.toString = function () {
 	var s = 'CREATE';
@@ -13923,7 +13892,7 @@ yy.CreateIndex.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.Reindex = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Reindex.prototype.toString = function () {
 	var s = 'REINDEX ' + this.indexid;
@@ -13953,7 +13922,7 @@ yy.Reindex.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.DropIndex = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.DropIndex.prototype.toString = function () {
 	return 'DROP INDEX' + this.indexid;
@@ -13976,7 +13945,7 @@ yy.DropIndex.prototype.compile = function (db) {
 */
 
 yy.WithSelect = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.WithSelect.prototype.toString = function () {
 	var s = 'WITH ';
@@ -14025,7 +13994,7 @@ yy.WithSelect.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.If = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.If.prototype.toString = function () {
 	var s = 'IF' + ' ';
@@ -14065,7 +14034,7 @@ yy.If.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.While = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.While.prototype.toString = function () {
 	var s = 'WHILE ';
@@ -14107,7 +14076,7 @@ yy.While.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.Break = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Break.prototype.toString = function () {
 	var s = 'BREAK';
@@ -14121,7 +14090,7 @@ yy.Break.prototype.execute = function (databaseid, params, cb, scope) {
 };
 
 yy.Continue = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Continue.prototype.toString = function () {
 	var s = 'CONTINUE';
@@ -14135,7 +14104,7 @@ yy.Continue.prototype.execute = function (databaseid, params, cb, scope) {
 };
 
 yy.BeginEnd = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.BeginEnd.prototype.toString = function () {
 	var s = 'BEGIN ' + this.statements.toString() + ' END';
@@ -14169,7 +14138,7 @@ yy.BeginEnd.prototype.execute = function (databaseid, params, cb, scope) {
 
 /* global yy alasql*/
 yy.Insert = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Insert.prototype.toString = function () {
 	var s = 'INSERT ';
@@ -14437,7 +14406,7 @@ yy.Insert.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.CreateTrigger = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateTrigger.prototype.toString = function () {
 	var s = 'CREATE TRIGGER ' + this.trigger + ' ';
@@ -14490,7 +14459,7 @@ yy.CreateTrigger.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.DropTrigger = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.DropTrigger.prototype.toString = function () {
 	var s = 'DROP TRIGGER ' + this.trigger;
@@ -14549,7 +14518,7 @@ yy.DropTrigger.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Delete = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Delete.prototype.toString = function () {
 	var s = 'DELETE FROM ' + this.table.toString();
@@ -14708,7 +14677,7 @@ yy.Delete.prototype.execute = function (databaseid, params, cb) {
 /* global yy alasql */
 
 yy.Update = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Update.prototype.toString = function () {
 	var s = 'UPDATE ' + this.table.toString();
@@ -14718,7 +14687,7 @@ yy.Update.prototype.toString = function () {
 };
 
 yy.SetColumn = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.SetColumn.prototype.toString = function () {
 	return this.column.toString() + '=' + this.expression.toString();
@@ -14820,7 +14789,7 @@ yy.Update.prototype.execute = function (databaseid, params, cb) {
 /* global alasql, yy */
 
 yy.Merge = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Merge.prototype.toString = function () {
 	var s = 'MERGE ';
@@ -14878,7 +14847,7 @@ yy.Merge.prototype.execute = function (databaseid, params, cb) {
 
 // CREATE DATABASE databaseid
 yy.CreateDatabase = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CreateDatabase.prototype.toString = function () {
 	var s = 'CREATE';
@@ -14931,7 +14900,7 @@ yy.CreateDatabase.prototype.execute = function (databaseid, params, cb) {
 
 // CREATE DATABASE databaseid
 yy.AttachDatabase = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.AttachDatabase.prototype.toString = function (args) {
 	var s = 'ATTACH';
@@ -14969,7 +14938,7 @@ yy.AttachDatabase.prototype.execute = function (databaseid, params, cb) {
 
 // CREATE DATABASE databaseid
 yy.DetachDatabase = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.DetachDatabase.prototype.toString = function () {
 	var s = 'DETACH';
@@ -15030,7 +14999,7 @@ yy.DetachDatabase.prototype.execute = function (databaseid, params, cb) {
 // USE DATABSE databaseid
 // USE databaseid
 yy.UseDatabase = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.UseDatabase.prototype.toString = function () {
 	return 'USE' + ' ' + 'DATABASE' + ' ' + this.databaseid;
@@ -15049,7 +15018,7 @@ yy.UseDatabase.prototype.execute = function (databaseid, params, cb) {
 
 // DROP DATABASE databaseid
 yy.DropDatabase = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.DropDatabase.prototype.toString = function () {
 	var s = 'DROP';
@@ -15099,7 +15068,7 @@ yy.DropDatabase.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Declare = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Declare.prototype.toString = function () {
 	var s = 'DECLARE ';
@@ -15171,7 +15140,7 @@ yy.Declare.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.ShowDatabases = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ShowDatabases.prototype.toString = function () {
 	var s = 'SHOW DATABASES';
@@ -15199,7 +15168,7 @@ yy.ShowDatabases.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.ShowTables = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ShowTables.prototype.toString = function () {
 	var s = 'SHOW TABLES';
@@ -15226,7 +15195,7 @@ yy.ShowTables.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.ShowColumns = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ShowColumns.prototype.toString = function () {
 	var s = 'SHOW COLUMNS';
@@ -15252,7 +15221,7 @@ yy.ShowColumns.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.ShowIndex = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ShowIndex.prototype.toString = function () {
 	var s = 'SHOW INDEX';
@@ -15275,7 +15244,7 @@ yy.ShowIndex.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.ShowCreateTable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.ShowCreateTable.prototype.toString = function () {
 	var s = 'SHOW CREATE TABLE ' + this.table.tableid;
@@ -15314,7 +15283,7 @@ yy.ShowCreateTable.prototype.execute = function (databaseid) {
 */
 
 yy.SetVariable = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.SetVariable.prototype.toString = function () {
 	var s = 'SET ';
@@ -15705,7 +15674,7 @@ alasql.prompt = function (el, useidel, firstsql) {
 //
 */
 yy.BeginTransaction = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.BeginTransaction.prototype.toString = function () {
 	return 'BEGIN TRANSACTION';
@@ -15723,7 +15692,7 @@ yy.BeginTransaction.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.CommitTransaction = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.CommitTransaction.prototype.toString = function () {
 	return 'COMMIT TRANSACTION';
@@ -15741,7 +15710,7 @@ yy.CommitTransaction.prototype.execute = function (databaseid, params, cb) {
 };
 
 yy.RollbackTransaction = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.RollbackTransaction.prototype.toString = function () {
 	return 'ROLLBACK TRANSACTION';
@@ -17610,7 +17579,7 @@ alasql.from.GEXF = function (filename, opts, cb, idx, query) {
 /* globals: alasql, yy */
 
 /**
-	Print statement 
+	Print statement
 	@class
 	@param {object} params Initial setup properties
 */
@@ -17618,11 +17587,11 @@ alasql.from.GEXF = function (filename, opts, cb, idx, query) {
 /* global alasql, yy */
 
 yy.Print = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 
-/** 
-	Generate SQL string 
+/**
+	Generate SQL string
 	@this Print statement object
 */
 yy.Print.prototype.toString = function () {
@@ -17635,7 +17604,7 @@ yy.Print.prototype.toString = function () {
  	Print result of select statement or expression
  	@param {string} databaseid Database identificator
  	@param {object} params Query parameters
- 	@param {statement-callback} cb Callback function 
+ 	@param {statement-callback} cb Callback function
 	@this Print statement object
 */
 yy.Print.prototype.execute = function (databaseid, params, cb) {
@@ -17676,7 +17645,7 @@ yy.Print.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Source = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Source.prototype.toString = function () {
 	var s = 'SOURCE';
@@ -17716,7 +17685,7 @@ yy.Source.prototype.execute = function (databaseid, params, cb) {
 /* global alasql, yy */
 
 yy.Require = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Require.prototype.toString = function () {
 	var s = 'REQUIRE';
@@ -17788,7 +17757,7 @@ yy.Require.prototype.execute = function (databaseid, params, cb) {
 */
 
 yy.Assert = function (params) {
-	return yy.extend(this, params);
+	return Object.assign(this, params);
 };
 yy.Source.prototype.toString = function () {
 	var s = 'ASSERT';
@@ -17865,29 +17834,46 @@ var IDB = (alasql.engines.INDEXEDDB = function () {
 	'';
 });
 
-if (utils.hasIndexedDB) {
-	// For Chrome it work normally, for Firefox - simple shim
-	if (typeof utils.global.indexedDB.webkitGetDatabaseNames == 'function') {
-		IDB.getDatabaseNames = utils.global.indexedDB.webkitGetDatabaseNames.bind(
-			utils.global.indexedDB
-		);
-	} else {
-		IDB.getDatabaseNames = function () {
-			var request = {};
-			var result = {
-				contains: function (name) {
-					return true; // Always return true
-				},
-				notsupported: true,
-			};
-			setTimeout(function () {
-				var event = {target: {result: result}};
-				request.onsuccess(event);
-			}, 0);
-			return request;
-		};
-		IDB.getDatabaseNamesNotSupported = true;
+/**
+ * @param {string} name
+ * @returns {Promise<{name: string, version: number}|0>}
+ */
+async function _databaseExists(name) {
+	const indexedDB = globalThis.indexedDB;
+
+	if (!indexedDB) {
+		throw new Error('IndexedDB is not supported in this browser');
+	}
+
+	if (indexedDB.databases) {
+		const dbs = await indexedDB.databases();
+		const db = dbs.find((db) => db.name === name);
+		// @ts-ignore
+		return db || 0;
 	}
+
+	// Try if it exist
+	const req = indexedDB.open(name);
+
+	return new Promise(function (resolve, reject) {
+		req.onsuccess = () => {
+			req.result.close();
+			resolve({name, version: req.result.version});
+		};
+
+		req.onupgradeneeded = (evt) => {
+			evt.target.transaction.abort();
+			resolve(0);
+		};
+
+		req.onerror = () => {
+			reject(new Error('IndexedDB error'));
+		};
+
+		req.onblocked = () => {
+			resolve({name, version: req.result.version});
+		};
+	});
 }
 
 //
@@ -17895,333 +17881,235 @@ if (utils.hasIndexedDB) {
 // work only in chrome
 //
 IDB.showDatabases = function (like, cb) {
+	if (!indexedDB.databases) {
+		cb(null, new Error('SHOW DATABASE is not supported in this browser'));
+		return;
+	}
+
+	indexedDB.databases().then((dblist) => {
+		const res = [];
+		const relike = like && new RegExp(like.value.replace(/\%/g, '.*'), 'g');
 
-	var request = IDB.getDatabaseNames();
-	request.onsuccess = function (event) {
-		var dblist = event.target.result;
-		if (IDB.getDatabaseNamesNotSupported) {
-			throw new Error('SHOW DATABASE is not supported in this browser');
-		}
-		var res = [];
-		if (like) {
-			var relike = new RegExp(like.value.replace(/\%/g, '.*'), 'g');
-		}
 		for (var i = 0; i < dblist.length; i++) {
-			if (!like || dblist[i].match(relike)) {
-				res.push({databaseid: dblist[i]});
+			if (!like || dblist[i].name.match(relike)) {
+				res.push({databaseid: dblist[i].name});
 			}
 		}
+
 		cb(res);
-	};
+	});
 };
 
-IDB.createDatabase = function (ixdbid, args, ifnotexists, dbid, cb) {
-
-	var indexedDB = utils.global.indexedDB;
-	if (ifnotexists) {
-		var request2 = indexedDB.open(ixdbid, 1);
-		request2.onsuccess = function (event) {
-			event.target.result.close();
-			if (cb) cb(1);
-		};
-	} else {
-		var request1 = indexedDB.open(ixdbid, 1);
-		request1.onupgradeneeded = function (e) {
-
-			e.target.transaction.abort();
-		};
-		request1.onsuccess = function (e) {
-
-			if (ifnotexists) {
-				if (cb) cb(0);
-			} else {
-				throw new Error(
-					'IndexedDB: Cannot create new database "' + ixdbid + '" because it already exists'
-				);
-			}
-		};
-	}
-
-};
+IDB.createDatabase = async function (ixdbid, args, ifnotexists, dbid, cb) {
+	const found = await _databaseExists(ixdbid).catch((err) => {
+		if (cb) cb(null, err);
+		throw err;
+	});
 
-IDB.createDatabase = function (ixdbid, args, ifnotexists, dbid, cb) {
-	var indexedDB = utils.global.indexedDB;
-	if (IDB.getDatabaseNamesNotSupported) {
-		// Hack for Firefox
+	if (found) {
 		if (ifnotexists) {
-
-			var dbExists = true;
-			var request2 = indexedDB.open(ixdbid);
-
-			request2.onupgradeneeded = function (e) {
-
-				dbExists = false;
-				//			    e.target.transaction.abort();
-				//			    cb(0);
-			};
-			request2.onsuccess = function (event) {
-
-				event.target.result.close();
-				if (dbExists) {
-					if (cb) cb(0);
-				} else {
-					if (cb) cb(1);
-				}
-			};
+			cb && cb(0);
 		} else {
-
-			var request1 = indexedDB.open(ixdbid);
-			request1.onupgradeneeded = function (e) {
-				e.target.transaction.abort();
-			};
-			request1.onabort = function (event) {
-				if (cb) cb(1);
-			};
-			request1.onsuccess = function (event) {
-				event.target.result.close();
-				throw new Error(
-					'IndexedDB: Cannot create new database "' + ixdbid + '" because it already exists'
-				);
-				//				cb(0);
-			};
+			const err = new Error(
+				`IndexedDB: Cannot create new database "${ixdbid}" because it already exists`
+			);
+			if (cb) cb(null, err);
 		}
 	} else {
-		var request1 = IDB.getDatabaseNames();
-		request1.onsuccess = function (event) {
-			var dblist = event.target.result;
-			if (dblist.contains(ixdbid)) {
-				if (ifnotexists) {
-					if (cb) cb(0);
-					return;
-				} else {
-					throw new Error(
-						'IndexedDB: Cannot create new database "' + ixdbid + '" because it already exists'
-					);
-				}
-			}
-
-			var request2 = indexedDB.open(ixdbid, 1);
-			request2.onsuccess = function (event) {
-				event.target.result.close();
-				if (cb) cb(1);
-			};
+		const request = indexedDB.open(ixdbid, 1);
+		request.onsuccess = () => {
+			request.result.close();
+			cb(1);
 		};
 	}
 };
 
-IDB.dropDatabase = function (ixdbid, ifexists, cb) {
-	var indexedDB = utils.global.indexedDB;
-	var request1 = IDB.getDatabaseNames();
-	request1.onsuccess = function (event) {
-		var dblist = event.target.result;
-		if (!dblist.contains(ixdbid)) {
-			if (ifexists) {
-				if (cb) cb(0);
-				return;
-			} else {
-				throw new Error(
-					'IndexedDB: Cannot drop new database "' + ixdbid + '" because it does not exist'
-				);
-			}
-		}
-		var request2 = indexedDB.deleteDatabase(ixdbid);
-		request2.onsuccess = function (event) {
+IDB.dropDatabase = async function (ixdbid, ifexists, cb) {
+	const found = await _databaseExists(ixdbid).catch((err) => {
+		if (cb) cb(null, err);
+		throw err;
+	});
 
+	if (found) {
+		const request = indexedDB.deleteDatabase(ixdbid);
+		request.onsuccess = () => {
 			if (cb) cb(1);
 		};
-	};
-};
-
-IDB.attachDatabase = function (ixdbid, dbid, args, params, cb) {
-	if (!utils.hasIndexedDB) {
-		throw new Error('The current browser does not support IndexedDB');
-	}
-	var indexedDB = utils.global.indexedDB;
-	var request1 = IDB.getDatabaseNames();
-	request1.onsuccess = function (event) {
-		var dblist = event.target.result;
-		if (!dblist.contains(ixdbid)) {
-			throw new Error(
-				'IndexedDB: Cannot attach database "' + ixdbid + '" because it does not exist'
-			);
+	} else {
+		if (ifexists) {
+			cb && cb(0);
+		} else {
+			cb &&
+				cb(
+					null,
+					new Error(`IndexedDB: Cannot drop new database "${ixdbid}" because it does not exist'`)
+				);
 		}
-		var request2 = indexedDB.open(ixdbid);
-		request2.onsuccess = function (event) {
-			var ixdb = event.target.result;
-			var db = new alasql.Database(dbid || ixdbid);
-			db.engineid = 'INDEXEDDB';
-			db.ixdbid = ixdbid;
-			db.tables = [];
-			var tblist = ixdb.objectStoreNames;
-			for (var i = 0; i < tblist.length; i++) {
-				db.tables[tblist[i]] = {};
-			}
-
-			event.target.result.close();
-			if (cb) cb(1);
-		};
-	};
+	}
 };
 
-IDB.createTable = function (databaseid, tableid, ifnotexists, cb) {
-	var indexedDB = utils.global.indexedDB;
-
-	var ixdbid = alasql.databases[databaseid].ixdbid;
+IDB.attachDatabase = async function (ixdbid, dbid, args, params, cb) {
+	const found = await _databaseExists(ixdbid).catch((err) => {
+		if (cb) cb(null, err);
+		throw err;
+	});
 
-	var request1 = IDB.getDatabaseNames();
-	request1.onsuccess = function (event__) {
-		var dblist = event__.target.result;
-		if (!dblist.contains(ixdbid)) {
-			throw new Error(
-				'IndexedDB: Cannot create table in database "' + ixdbid + '" because it does not exist'
-			);
-		}
-		var request2 = indexedDB.open(ixdbid);
-		request2.onversionchange = function (event_) {
+	if (!found) {
+		const err = new Error(
+			`IndexedDB: Cannot attach database "${ixdbid}" because it does not exist`
+		);
+		if (cb) cb(null, err);
+		throw err;
+	}
 
-			event_.target.result.close();
+	const stores = await new Promise((resolve, reject) => {
+		const request = indexedDB.open(ixdbid);
+		request.onsuccess = () => {
+			resolve(request.result.objectStoreNames);
+			request.result.close();
 		};
-		request2.onsuccess = function (event_) {
-			var version = event_.target.result.version;
-			event_.target.result.close();
+	});
 
-			var request3 = indexedDB.open(ixdbid, version + 1);
-			request3.onupgradeneeded = function (event) {
-				var ixdb = event.target.result;
+	const db = new alasql.Database(dbid || ixdbid);
+	db.engineid = 'INDEXEDDB';
+	db.ixdbid = ixdbid;
+	db.tables = [];
 
-				var store = ixdb.createObjectStore(tableid, {autoIncrement: true});
+	for (var i = 0; i < stores.length; i++) {
+		db.tables[stores[i]] = {};
+	}
 
-			};
-			request3.onsuccess = function (event) {
+	if (cb) cb(1);
+};
 
-				event.target.result.close();
-				if (cb) cb(1);
-			};
-			request3.onerror = function (event) {
-				throw event;
+IDB.createTable = async function (databaseid, tableid, ifnotexists, cb) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const found = await _databaseExists(ixdbid).catch((err) => {
+		if (cb) cb(null, err);
+		throw err;
+	});
 
-			};
-			request3.onblocked = function (event) {
-				throw new Error(
-					'Cannot create table "' + tableid + '" because database "' + databaseid + '"  is blocked'
-				);
+	if (!found) {
+		const err = new Error(
+			'IndexedDB: Cannot create table in database "' + ixdbid + '" because it does not exist'
+		);
+		if (cb) cb(null, err);
+		throw err;
+	}
 
-			};
-		};
+	const request = indexedDB.open(ixdbid, found.version + 1);
+	request.onupgradeneeded = function (event) {
+		request.result.createObjectStore(tableid, {autoIncrement: true});
+	};
+	request.onsuccess = function (event) {
+		request.result.close();
+		if (cb) cb(1);
+	};
+	request.onerror = (evt) => {
+		cb(null, evt);
+	};
+	request.onblocked = function (event) {
+		cb(
+			null,
+			new Error(`Cannot create table "${tableid}" because database "${databaseid}"  is blocked`)
+		);
 	};
 };
 
-IDB.dropTable = function (databaseid, tableid, ifexists, cb) {
-	var indexedDB = utils.global.indexedDB;
-	var ixdbid = alasql.databases[databaseid].ixdbid;
-
-	var request1 = IDB.getDatabaseNames();
-	request1.onsuccess = function (event) {
-		var dblist = event.target.result;
-
-		if (!dblist.contains(ixdbid)) {
-			throw new Error(
-				'IndexedDB: Cannot drop table in database "' + ixdbid + '" because it does not exist'
-			);
-		}
-
-		var request2 = indexedDB.open(ixdbid);
-		request2.onversionchange = function (event) {
-			event.target.result.close();
-		};
-
-		request2.onsuccess = function (event) {
-			var version = event.target.result.version;
-			event.target.result.close();
-
-			var request3 = indexedDB.open(ixdbid, version + 1);
-			request3.onupgradeneeded = function (event) {
-				var ixdb = event.target.result;
-				if (ixdb.objectStoreNames.contains(tableid)) {
-					ixdb.deleteObjectStore(tableid);
-					delete alasql.databases[databaseid].tables[tableid];
-				} else {
-					if (!ifexists) {
-						throw new Error(
-							'IndexedDB: Cannot drop table "' + tableid + '" because it does not exist'
-						);
-					}
-				}
-				//				var store = ixdb.createObjectStore(tableid);
-
-			};
-			request3.onsuccess = function (event) {
+IDB.dropTable = async function (databaseid, tableid, ifexists, cb) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const found = await _databaseExists(ixdbid).catch((err) => {
+		if (cb) cb(null, err);
+		throw err;
+	});
 
-				event.target.result.close();
-				if (cb) cb(1);
-			};
-			request3.onerror = function (event) {
+	if (!found) {
+		const err = new Error(
+			'IndexedDB: Cannot drop table in database "' + ixdbid + '" because it does not exist'
+		);
+		if (cb) cb(null, err);
+		throw err;
+	}
 
-				throw event;
-			};
-			request3.onblocked = function (event) {
-				throw new Error(
-					'Cannot drop table "' + tableid + '" because database "' + databaseid + '" is blocked'
-				);
+	const request = indexedDB.open(ixdbid, found.version + 1);
 
-			};
-		};
+	let err;
+	request.onupgradeneeded = function (evt) {
+		var ixdb = request.result;
+		if (ixdb.objectStoreNames.contains(tableid)) {
+			ixdb.deleteObjectStore(tableid);
+			delete alasql.databases[databaseid].tables[tableid];
+		} else {
+			if (!ifexists) {
+				err = new Error(`IndexedDB: Cannot drop table "${tableid}" because it does not exist`);
+				evt.target.transaction.abort();
+			}
+		}
+	};
+	request.onsuccess = function (event) {
+		request.result.close();
+		if (cb) cb(1);
+	};
+	request.onerror = function (event) {
+		cb && cb(null, err || event);
+	};
+	request.onblocked = function (event) {
+		cb(
+			null,
+			new Error(`Cannot drop table "${tableid}" because database "${databaseid}" is blocked`)
+		);
 	};
 };
 
 IDB.intoTable = function (databaseid, tableid, value, columns, cb) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const request = indexedDB.open(ixdbid);
 
-	// console.trace();
+	request.onupgradeneeded = (evt) => {
+		evt.target.transaction.abort();
+		const err = new Error(
+			`Cannot insert into table "${tableid}" because database "${databaseid}" does not exist`
+		);
+		if (cb) cb(null, err);
+	};
 
-	var indexedDB = utils.global.indexedDB;
-	var ixdbid = alasql.databases[databaseid].ixdbid;
-	var request1 = indexedDB.open(ixdbid);
-	request1.onsuccess = function (event) {
-		var ixdb = event.target.result;
+	request.onsuccess = () => {
+		var ixdb = request.result;
 		var tx = ixdb.transaction([tableid], 'readwrite');
 		var tb = tx.objectStore(tableid);
-
 		for (var i = 0, ilen = value.length; i < ilen; i++) {
 			tb.add(value[i]);
 		}
 		tx.oncomplete = function () {
 			ixdb.close();
-
 			if (cb) cb(ilen);
 		};
 	};
-
 };
 
 IDB.fromTable = function (databaseid, tableid, cb, idx, query) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const request = indexedDB.open(ixdbid);
 
-	// console.trace();
-	var indexedDB = utils.global.indexedDB;
-	var ixdbid = alasql.databases[databaseid].ixdbid;
-	var request = indexedDB.open(ixdbid);
-	request.onsuccess = function (event) {
-		var res = [];
-		var ixdb = event.target.result;
-
-		var tx = ixdb.transaction([tableid]);
-		var store = tx.objectStore(tableid);
-		var cur = store.openCursor();
-
-		cur.onblocked = function (event) {
-
-		};
-		cur.onerror = function (event) {
-
-		};
-		cur.onsuccess = function (event) {
+	request.onupgradeneeded = (evt) => {
+		evt.target.transaction.abort();
+		const err = new Error(
+			`Cannot select from table "${tableid}" because database "${databaseid}" does not exist`
+		);
+		if (cb) cb(null, err);
+	};
 
-			var cursor = event.target.result;
+	request.onsuccess = () => {
+		const res = [];
+		const ixdb = request.result;
+		const cur = ixdb.transaction([tableid]).objectStore(tableid).openCursor();
 
+		cur.onsuccess = () => {
+			const cursor = cur.result;
 			if (cursor) {
 				res.push(cursor.value);
 				cursor.continue();
 			} else {
-
 				ixdb.close();
 				if (cb) cb(res, idx, query);
 			}
@@ -18230,39 +18118,23 @@ IDB.fromTable = function (databaseid, tableid, cb, idx, query) {
 };
 
 IDB.deleteFromTable = function (databaseid, tableid, wherefn, params, cb) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const request = indexedDB.open(ixdbid);
 
-	// console.trace();
-	var indexedDB = utils.global.indexedDB;
-	var ixdbid = alasql.databases[databaseid].ixdbid;
-	var request = indexedDB.open(ixdbid);
-	request.onsuccess = function (event) {
-		var res = [];
-		var ixdb = event.target.result;
-
-		var tx = ixdb.transaction([tableid], 'readwrite');
-		var store = tx.objectStore(tableid);
-		var cur = store.openCursor();
-		var num = 0;
-
-		cur.onblocked = function (event) {
-
-		};
-		cur.onerror = function (event) {
-
-		};
-		cur.onsuccess = function (event) {
-
-			var cursor = event.target.result;
+	request.onsuccess = () => {
+		const ixdb = request.result;
+		const cur = ixdb.transaction([tableid], 'readwrite').objectStore(tableid).openCursor();
 
+		let num = 0;
+		cur.onsuccess = () => {
+			var cursor = cur.result;
 			if (cursor) {
-				if (!wherefn || wherefn(cursor.value, params)) {
-
+				if (!wherefn || wherefn(cursor.value, params, alasql)) {
 					cursor.delete();
 					num++;
 				}
 				cursor.continue();
 			} else {
-
 				ixdb.close();
 				if (cb) cb(num);
 			}
@@ -18271,42 +18143,24 @@ IDB.deleteFromTable = function (databaseid, tableid, wherefn, params, cb) {
 };
 
 IDB.updateTable = function (databaseid, tableid, assignfn, wherefn, params, cb) {
-
-	// console.trace();
-	var indexedDB = utils.global.indexedDB;
-	var ixdbid = alasql.databases[databaseid].ixdbid;
-	var request = indexedDB.open(ixdbid);
-	request.onsuccess = function (event) {
-		var res = [];
-		var ixdb = event.target.result;
-
-		var tx = ixdb.transaction([tableid], 'readwrite');
-		var store = tx.objectStore(tableid);
-		var cur = store.openCursor();
-		var num = 0;
-
-		cur.onblocked = function (event) {
-
-		};
-		cur.onerror = function (event) {
-
-		};
-		cur.onsuccess = function (event) {
-
-			var cursor = event.target.result;
-
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const request = indexedDB.open(ixdbid);
+	request.onsuccess = function () {
+		const ixdb = request.result;
+		const cur = ixdb.transaction([tableid], 'readwrite').objectStore(tableid).openCursor();
+
+		let num = 0;
+		cur.onsuccess = () => {
+			var cursor = cur.result;
 			if (cursor) {
 				if (!wherefn || wherefn(cursor.value, params)) {
-
 					var r = cursor.value;
 					assignfn(r, params);
-
 					cursor.update(r);
 					num++;
 				}
 				cursor.continue();
 			} else {
-
 				ixdb.close();
 				if (cb) cb(num);
 			}