alasql 4.6.4 → 4.6.6

package/dist/alasql-worker.js

@@ -1,7 +1,7 @@
-//! AlaSQL v4.6.3 build: develop-3129f37a | © 2014-2024 Andrey Gershun & Mathias Wulff | License: MIT
+//! AlaSQL v4.6.5 build: develop-f6e298b2 | © 2014-2024 Andrey Gershun & Mathias Wulff | License: MIT
 /*
 @module alasql
-@version 4.6.3
+@version 4.6.5
 
 AlaSQL - JavaScript SQL database
 © 2014-2024	Andrey Gershun & Mathias Wulff

package/dist/alasql.fs.js

@@ -1,7 +1,7 @@
-//! AlaSQL v4.6.3 build: develop-3129f37a | © 2014-2024 Andrey Gershun & Mathias Wulff | License: MIT
+//! AlaSQL v4.6.5 build: develop-f6e298b2 | © 2014-2024 Andrey Gershun & Mathias Wulff | License: MIT
 /*
 @module alasql
-@version 4.6.3
+@version 4.6.5
 
 AlaSQL - JavaScript SQL database
 © 2014-2024	Andrey Gershun & Mathias Wulff
@@ -141,8 +141,8 @@ SOFTWARE.
 		Current version of alasql
 		  @constant {string}
 	*/
-	alasql.version = '4.6.3';
-	alasql.build = 'develop-3129f37a';
+	alasql.version = '4.6.5';
+	alasql.build = 'develop-f6e298b2';
 
 	/**
 		Debug flag
@@ -9473,104 +9473,220 @@ yy.Select.prototype.compilePivot = function (query) {
 		});
 	}
 
-	// Function for PIVOT post production
+	// Function for PIVOT post production (returned by compilePivot)
 	return function () {
-		var query = this;
-		var cols = query.columns
-			.filter(function (col) {
-				return col.columnid != columnid && col.columnid != exprcolid;
-			})
-			.map(function (col) {
-				return col.columnid;
-			});
+		var query = this; // Keep reference to the query object
+
+		// Exit if no data to pivot
+		if (!query.data || query.data.length === 0) {
+			query.columns = []; // Reset columns if no data
+			return;
+		}
+
+		// --- Determine grouping columns robustly ---
+		var firstRowKeys = Object.keys(query.data[0]);
+		var cols = firstRowKeys.filter(function (key) {
+			return key !== columnid && key !== exprcolid;
+		});
+		// -----------------------------------------
+
+		var newcols = []; // Stores the new column headers (e.g., 'MON', 'TUE')
+		var gnewcols = {}; // Tracks unique new columns encountered
+		var gr = {}; // Stores the grouped & pivoted results (key: gx, value: g)
+		var ga = {}; // Stores counts for AVG calculation (key: gx, value: {day: count})
+		var data = []; // The final pivoted data array
 
-		var newcols = [];
-		var gnewcols = {};
-		var gr = {};
-		var ga = {};
-		var data = [];
 		query.data.forEach(function (d) {
-			if (!inlist || inlist.indexOf(d[columnid]) > -1) {
-				var gx = cols
-					.map(function (colid) {
-						return d[colid];
-					})
-					.join('`');
-				var g = gr[gx];
-				if (!g) {
-					g = {};
-					gr[gx] = g;
-					data.push(g);
-					cols.forEach(function (colid) {
-						g[colid] = d[colid];
-					});
-				}
+			// Skip row if the pivot column value is not in the IN list (if provided)
+			if (inlist && inlist.indexOf(d[columnid]) === -1) {
+				return;
+			}
 
-				if (!ga[gx]) {
-					ga[gx] = {};
-				}
+			var gx = cols
+				.map(function (colid) {
+					return d[colid] === undefined || d[colid] === null ? '' : d[colid];
+				})
+				.join('`');
 
-				if (ga[gx][d[columnid]]) {
-					ga[gx][d[columnid]]++;
-				} else {
-					ga[gx][d[columnid]] = 1;
-				}
+			var g = gr[gx];
+			if (!g) {
+				g = {};
+				gr[gx] = g;
+				data.push(g);
+				cols.forEach(function (colid) {
+					g[colid] = d[colid];
+				});
+			}
+
+			if (!ga[gx]) {
+				ga[gx] = {};
+			}
 
-				if (!gnewcols[d[columnid]]) {
-					gnewcols[d[columnid]] = true;
-					newcols.push(d[columnid]);
+			var pivotColValue = d[columnid];
+			var aggValue = d[exprcolid];
+
+			// Increment count only for non-null/undefined values when calculating AVG
+			if (ga[gx][pivotColValue]) {
+				if (aggValue !== null && typeof aggValue !== 'undefined') {
+					ga[gx][pivotColValue]++;
 				}
+			} else {
+				ga[gx][pivotColValue] = aggValue !== null && typeof aggValue !== 'undefined' ? 1 : 0;
+			}
+
+			if (!gnewcols[pivotColValue]) {
+				gnewcols[pivotColValue] = true;
+				newcols.push(pivotColValue);
+			}
 
-				if (aggr == 'SUM' || aggr == 'AVG' || aggr == 'TOTAL') {
-					if (typeof g[d[columnid]] == 'undefined') g[d[columnid]] = 0;
-					g[d[columnid]] += +d[exprcolid];
-				} else if (aggr == 'COUNT') {
-					if (typeof g[d[columnid]] == 'undefined') g[d[columnid]] = 0;
-					g[d[columnid]]++;
-				} else if (aggr == 'MIN') {
-					if (typeof g[d[columnid]] == 'undefined') g[d[columnid]] = d[exprcolid];
-					if (d[exprcolid] < g[d[columnid]]) g[d[columnid]] = d[exprcolid];
-				} else if (aggr == 'MAX') {
-					if (typeof g[d[columnid]] == 'undefined') g[d[columnid]] = d[exprcolid];
-					if (d[exprcolid] > g[d[columnid]]) g[d[columnid]] = d[exprcolid];
-				} else if (aggr == 'FIRST') {
-					if (typeof g[d[columnid]] == 'undefined') g[d[columnid]] = d[exprcolid];
-				} else if (aggr == 'LAST') {
-					g[d[columnid]] = d[exprcolid];
-				} else if (alasql.aggr[aggr]) {
-					// Custom aggregator
-					alasql.aggr[aggr](g[d[columnid]], d[exprcolid]);
+			// Apply the specified aggregation
+			if (aggr == 'SUM' || aggr == 'AVG' || aggr == 'TOTAL') {
+				if (aggValue !== null && typeof aggValue !== 'undefined') {
+					g[pivotColValue] =
+						typeof g[pivotColValue] === 'undefined' || g[pivotColValue] === null
+							? Number(aggValue)
+							: g[pivotColValue] + Number(aggValue);
+				} else if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = null;
+				}
+			} else if (aggr == 'COUNT') {
+				if (exprcolid === '*' || (aggValue !== null && typeof aggValue !== 'undefined')) {
+					g[pivotColValue] = (g[pivotColValue] || 0) + 1;
+				} else if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = 0;
+				}
+			} else if (aggr == 'MIN') {
+				if (aggValue !== null && typeof aggValue !== 'undefined') {
+					if (
+						typeof g[pivotColValue] === 'undefined' ||
+						g[pivotColValue] === null ||
+						aggValue < g[pivotColValue]
+					) {
+						g[pivotColValue] = aggValue;
+					}
+				} else if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = null;
+				}
+			} else if (aggr == 'MAX') {
+				if (aggValue !== null && typeof aggValue !== 'undefined') {
+					if (
+						typeof g[pivotColValue] === 'undefined' ||
+						g[pivotColValue] === null ||
+						aggValue > g[pivotColValue]
+					) {
+						g[pivotColValue] = aggValue;
+					}
+				} else if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = null;
+				}
+			} else if (aggr == 'FIRST') {
+				if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = aggValue;
+				}
+			} else if (aggr == 'LAST') {
+				g[pivotColValue] = aggValue;
+			} else if (alasql.aggr[aggr]) {
+				if (typeof g[pivotColValue] === 'undefined') {
+					g[pivotColValue] = alasql.aggr[aggr](aggValue, undefined, 1);
 				} else {
-					throw new Error('Wrong aggregator in PIVOT clause');
+					g[pivotColValue] = alasql.aggr[aggr](aggValue, g[pivotColValue], 2);
 				}
+			} else {
+				throw new Error('Unknown aggregator in PIVOT clause: ' + aggr);
 			}
 		});
 
+		// Finalize AVG calculation
 		if (aggr == 'AVG') {
 			for (var gx in gr) {
 				var d = gr[gx];
-				for (var colid in d) {
-					if (cols.indexOf(colid) == -1 && colid != exprcolid) {
-						d[colid] = d[colid] / ga[gx][colid];
+				for (var pivotColValue in ga[gx]) {
+					if (d.hasOwnProperty(pivotColValue) && d[pivotColValue] !== null) {
+						var count = ga[gx][pivotColValue];
+						if (count > 0) {
+							d[pivotColValue] = d[pivotColValue] / count;
+						} else {
+							d[pivotColValue] = null;
+						}
 					}
 				}
 			}
 		}
 
-		// columns
+		// --- Rebuild query.columns ---
 		query.data = data;
 
-		if (inlist) newcols = inlist;
+		if (inlist) {
+			newcols = inlist;
+		} else {
+			newcols.sort();
+		}
+
+		// Find original column definition - might be basic if SELECT * was used
+		let aggColDef = query.columns.find(col => col.columnid === exprcolid);
+		// If SELECT * was used, aggColDef might be missing, find it from the table definition if possible
+		if (!aggColDef && query.sources && query.sources.length > 0) {
+			let sourceTableId = query.sources[0].tableid;
+			let sourceDbId = query.sources[0].databaseid;
+			if (
+				sourceTableId &&
+				sourceDbId &&
+				alasql.databases[sourceDbId]?.tables?.[sourceTableId]?.xcolumns
+			) {
+				aggColDef = alasql.databases[sourceDbId].tables[sourceTableId].xcolumns[exprcolid];
+			}
+		}
+		// Provide a fallback if still not found
+		aggColDef = aggColDef || {columnid: exprcolid, dbtypeid: 'OBJECT'};
 
-		var ncol = query.columns.filter(function (col) {
-			return col.columnid == exprcolid;
-		})[0];
+		// Keep only the grouping columns initially
 		query.columns = query.columns.filter(function (col) {
-			return !(col.columnid == columnid || col.columnid == exprcolid);
+			return cols.includes(col.columnid);
 		});
-		newcols.forEach(function (colid) {
-			var nc = cloneDeep(ncol);
-			nc.columnid = colid;
+
+		// Add the new pivoted columns
+		newcols.forEach(function (newColId) {
+			var nc = cloneDeep(aggColDef);
+			nc.columnid = newColId;
+
+			// ---- Final Refined Type Logic ----
+			const originalType = (aggColDef.dbtypeid || 'OBJECT').toUpperCase();
+			const integerTypes = [
+				'INT',
+				'INTEGER',
+				'SMALLINT',
+				'BIGINT',
+				'SERIAL',
+				'SMALLSERIAL',
+				'BIGSERIAL',
+			];
+			const numericTypes = [...integerTypes, 'NUMBER', 'FLOAT', 'DECIMAL', 'NUMERIC', 'MONEY'];
+
+			if (aggr === 'COUNT') {
+				nc.dbtypeid = 'INT';
+			} else if (aggr === 'AVG') {
+				// Keep INT type if original was INT-like, otherwise use FLOAT
+				if (integerTypes.includes(originalType)) {
+					nc.dbtypeid = aggColDef.dbtypeid; // Preserve original INT-like type
+				} else {
+					nc.dbtypeid = 'FLOAT';
+				}
+			} else if (aggr === 'SUM' || aggr === 'TOTAL') {
+				// Preserve numeric types, default to FLOAT otherwise
+				if (numericTypes.includes(originalType)) {
+					nc.dbtypeid = aggColDef.dbtypeid;
+				} else {
+					nc.dbtypeid = 'FLOAT'; // Default for non-numeric or unknown sums
+				}
+			} else if (aggr === 'MIN' || aggr === 'MAX' || aggr === 'FIRST' || aggr === 'LAST') {
+				// Preserve original type as comparisons work across types
+				nc.dbtypeid = aggColDef.dbtypeid;
+			}
+			// For custom aggregators (AGGR, REDUCE), inherit type from clone, ensure fallback
+			else if (!nc.dbtypeid) {
+				nc.dbtypeid = 'OBJECT';
+			}
+
 			query.columns.push(nc);
 		});
 	};
@@ -16429,7 +16545,12 @@ alasql.from.JSON = function (filename, opts, cb, idx, query) {
 		}
 	}),
 		err => {
-			throw new Error(err);
+			const error = err instanceof Error ? err : new Error(err);
+			if(query && query.cb) {
+				query.cb(null, error);
+				return;
+			}
+			throw error;
 		};
 	return res;
 };
@@ -16454,11 +16575,16 @@ const jsonl = ext => {
 					}
 				});
 				if (cb) {
-					res = cb(out, idx, query);
+					out = cb(out, idx, query);
 				}
 			},
 			err => {
-				throw new Error(err);
+				const error = err instanceof Error ? err : new Error(err);
+				if(query && query.cb) {
+					query.cb(null, error);
+					return;
+				}
+				throw error;
 			}
 		);
 		return out;
@@ -16783,7 +16909,7 @@ function XLSXLSX(X, filename, opts, cb, idx, query) {
 			}
 		},
 		function (err) {
-			if(query && query.cb) {
+			if (query && query.cb) {
 				query.cb(null, err);
 				return;
 			}