@nshiab/simple-data-analysis-core 0.0.12

package/script/methods/insertRowsQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertRowsQuery.d.ts","sourceRoot":"","sources":["../../src/methods/insertRowsQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,UAenC"}

package/script/methods/insertRowsQuery.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = insertRowsQuery;
+const parseValue_js_1 = __importDefault(require("../helpers/parseValue.js"));
+function insertRowsQuery(table, rows) {
+    const columns = Object.keys(rows[0]);
+    let query = `INSERT INTO "${table}" (${columns.map((d) => `"${d}"`).join(", ")})
+        VALUES`;
+    for (const row of rows) {
+        const values = Object.values(row);
+        query += `\n(${values.map((d) => (0, parseValue_js_1.default)(d)).join(", ")}),`;
+    }
+    return query.slice(0, query.length - 1);
+}

package/script/methods/join.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function join(leftTable: SimpleTable, rightTable: SimpleTable, options?: {
+    commonColumn?: string | string[];
+    type?: "inner" | "left" | "right" | "full";
+    outputTable?: string | boolean;
+}): Promise<SimpleTable>;
+//# sourceMappingURL=join.d.ts.map

package/script/methods/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/methods/join.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,wBAA8B,IAAI,CAChC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACjC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,wBA4FP"}

package/script/methods/join.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = join;
+const getIdenticalColumns_js_1 = __importDefault(require("../helpers/getIdenticalColumns.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const joinQuery_js_1 = __importDefault(require("./joinQuery.js"));
+async function join(leftTable, rightTable, options = {}) {
+    const leftTableColumns = await leftTable.getColumns();
+    const rightTableColumns = await rightTable.getColumns();
+    const identicalColumns = (0, getIdenticalColumns_js_1.default)(leftTableColumns, rightTableColumns);
+    let commonColumn;
+    if (typeof options.commonColumn === "string") {
+        commonColumn = [options.commonColumn];
+    }
+    else if (Array.isArray(options.commonColumn)) {
+        commonColumn = options.commonColumn;
+    }
+    else {
+        if (identicalColumns.length === 0) {
+            throw new Error("No common column");
+        }
+        else if (identicalColumns.length === 1) {
+            commonColumn = identicalColumns;
+        }
+        else {
+            throw new Error("Multiple columns with identical names in the tables. You need to pick the ones you want.");
+        }
+    }
+    const identicalColumnsForError = identicalColumns.filter((d) => !commonColumn.includes(d));
+    if (identicalColumnsForError.length > 0) {
+        if (identicalColumnsForError.length === 1) {
+            throw new Error(`The tables have columns with identical names (excluding ${commonColumn.map((d) => `"${d}"`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add it to the commonColumn option.`);
+        }
+        else {
+            throw new Error(`The tables have columns with identical names (excluding ${commonColumn.map((d) => `"${d}"`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add them to the commonColumn option.`);
+        }
+    }
+    await (0, queryDB_js_1.default)(leftTable, (0, joinQuery_js_1.default)(leftTable.name, rightTable.name, commonColumn, options.type ?? "left", typeof options.outputTable === "string"
+        ? options.outputTable
+        : leftTable.name), (0, mergeOptions_js_1.default)(leftTable, {
+        table: typeof options.outputTable === "string"
+            ? options.outputTable
+            : leftTable.name,
+        method: "join()",
+        parameters: {
+            rightTable,
+            options,
+        },
+    }));
+    const outputTable = typeof options.outputTable === "string"
+        ? leftTable.sdb.newTable(options.outputTable, leftTable.projections) // missing projections here...
+        : leftTable;
+    // So we reassign here
+    const allProjections = {
+        ...leftTable.projections,
+        ...rightTable.projections,
+    };
+    outputTable.projections = allProjections;
+    const columns = await outputTable.getColumns();
+    const extraCommonColumns = columns.filter((d) => commonColumn.map((c) => `${c}_1`).includes(d));
+    if (extraCommonColumns.length > 0) {
+        await outputTable.removeColumns(extraCommonColumns);
+    }
+    return outputTable;
+}

package/script/methods/joinGeo.d.ts

@@ -0,0 +1,10 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function joinGeo(leftTable: SimpleTable, method: "intersect" | "inside" | "within", rightTable: SimpleTable, options?: {
+    leftTableColumn?: string;
+    rightTableColumn?: string;
+    type?: "inner" | "left" | "right" | "full";
+    distance?: number;
+    distanceMethod?: "srs" | "haversine" | "spheroid";
+    outputTable?: string | boolean;
+}): Promise<SimpleTable>;
+//# sourceMappingURL=joinGeo.d.ts.map

package/script/methods/joinGeo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinGeo.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,wBAA8B,OAAO,CACnC,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,EACzC,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAClD,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,wBAyGP"}

package/script/methods/joinGeo.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = joinGeo;
+const capitalize_js_1 = __importDefault(require("../helpers/capitalize.js"));
+const findGeoColumn_js_1 = __importDefault(require("../helpers/findGeoColumn.js"));
+const getIdenticalColumns_js_1 = __importDefault(require("../helpers/getIdenticalColumns.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const joinGeoQuery_js_1 = __importDefault(require("./joinGeoQuery.js"));
+async function joinGeo(leftTable, method, rightTable, options = {}) {
+    const leftTableColumn = options.leftTableColumn ??
+        (await (0, findGeoColumn_js_1.default)(leftTable));
+    const rightTableColumn = options.rightTableColumn ??
+        (await (0, findGeoColumn_js_1.default)(rightTable));
+    const commonColumn = leftTableColumn === rightTableColumn
+        ? leftTableColumn
+        : "";
+    const identicalColumns = ((0, getIdenticalColumns_js_1.default)(await leftTable.getColumns(), await rightTable.getColumns())).filter((d) => d !== commonColumn);
+    if (identicalColumns.length > 0) {
+        throw new Error(`The tables have columns with identical names ${commonColumn !== ""
+            ? `(excluding the columns "${commonColumn}" used for the geospatial join)`
+            : ""}. Rename or remove ${identicalColumns.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join.`);
+    }
+    let leftTableColumnForQuery = leftTableColumn;
+    let rightTableColumnForQuery = rightTableColumn;
+    // We change the column names for geometries
+    if (leftTableColumn === rightTableColumn) {
+        leftTableColumnForQuery = `${leftTableColumn}${(0, capitalize_js_1.default)(leftTable.name)}`;
+        const leftObj = {};
+        leftObj[leftTableColumn] = leftTableColumnForQuery;
+        await leftTable.renameColumns(leftObj);
+        rightTableColumnForQuery = `${rightTableColumn}${(0, capitalize_js_1.default)(rightTable.name)}`;
+        const rightObj = {};
+        rightObj[rightTableColumn] = rightTableColumnForQuery;
+        await rightTable.renameColumns(rightObj);
+    }
+    const type = options.type ?? "left";
+    const outputTable = typeof options.outputTable === "string"
+        ? options.outputTable
+        : leftTable.name;
+    await (0, queryDB_js_1.default)(leftTable, (0, joinGeoQuery_js_1.default)(leftTable.name, leftTableColumnForQuery, method, rightTable.name, rightTableColumnForQuery, type, outputTable, options.distance, options.distanceMethod), (0, mergeOptions_js_1.default)(leftTable, {
+        table: outputTable,
+        method: "joinGeo()",
+        parameters: {
+            leftTable: leftTable.name,
+            method,
+            rightTable: rightTable.name,
+            options,
+        },
+    }));
+    // We bring back the column names for geometries
+    let allProjections = {};
+    if (leftTableColumn === rightTableColumn) {
+        const leftObj = {};
+        leftObj[leftTableColumnForQuery] = leftTableColumn;
+        await leftTable.renameColumns(leftObj);
+        // Before renaming columns in original tables
+        allProjections = {
+            ...leftTable.projections,
+            ...rightTable.projections,
+        };
+        const rightObj = {};
+        rightObj[rightTableColumnForQuery] = rightTableColumn;
+        await rightTable.renameColumns(rightObj);
+    }
+    else {
+        allProjections = {
+            ...leftTable.projections,
+            ...rightTable.projections,
+        };
+    }
+    if (typeof options.outputTable === "string") {
+        return leftTable.sdb.newTable(options.outputTable, allProjections);
+    }
+    else {
+        leftTable.projections = allProjections;
+        return leftTable;
+    }
+}

package/script/methods/joinGeoQuery.d.ts

@@ -0,0 +1,2 @@
+export default function joinGeoQuery(leftTable: string, leftTableColumn: string, method: "intersect" | "inside" | "within", rightTable: string, rightTableColumn: string, join: "inner" | "left" | "right" | "full", outputTable: string, distance: number | undefined, distanceMethod: "srs" | "haversine" | "spheroid" | undefined): string;
+//# sourceMappingURL=joinGeoQuery.d.ts.map

package/script/methods/joinGeoQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinGeoQuery.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeoQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,EACzC,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EACxB,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EACzC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,UA8C7D"}

package/script/methods/joinGeoQuery.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = joinGeoQuery;
+function joinGeoQuery(leftTable, leftTableColumn, method, rightTable, rightTableColumn, join, outputTable, distance, distanceMethod) {
+    let query = `CREATE OR REPLACE TABLE "${outputTable}" AS SELECT *`;
+    if (join === "inner") {
+        query += ` FROM "${leftTable}" JOIN "${rightTable}"`;
+    }
+    else if (join === "left") {
+        query += ` FROM "${leftTable}" LEFT JOIN "${rightTable}"`;
+    }
+    else if (join === "right") {
+        query += ` FROM "${leftTable}" RIGHT JOIN "${rightTable}"`;
+    }
+    else if (join === "full") {
+        query += ` FROM "${leftTable}" FULL JOIN "${rightTable}"`;
+    }
+    else {
+        throw new Error(`Unknown ${join} join.`);
+    }
+    if (method === "intersect") {
+        query +=
+            ` ON ST_Intersects("${leftTable}"."${leftTableColumn}", "${rightTable}"."${rightTableColumn}");`;
+    }
+    else if (method === "inside") {
+        // Order is important
+        query +=
+            ` ON ST_Covers("${rightTable}"."${rightTableColumn}", "${leftTable}"."${leftTableColumn}");`;
+    }
+    else if (method === "within") {
+        if (typeof distance === "number") {
+            if (distanceMethod === undefined || distanceMethod === "srs") {
+                query +=
+                    ` ON ST_DWithin("${leftTable}"."${leftTableColumn}", "${rightTable}"."${rightTableColumn}", ${distance})`;
+            }
+            else if (distanceMethod === "haversine") {
+                // Maybe ST_DWithin_Sphere will be available soon?
+                query +=
+                    ` ON ST_Distance_Sphere("${leftTable}"."${leftTableColumn}", "${rightTable}"."${rightTableColumn}") < ${distance}`;
+            }
+            else if (distanceMethod === "spheroid") {
+                // Should be using ST_DWithin_Spheroid but doesn't work?
+                query +=
+                    ` ON ST_Distance_Spheroid("${leftTable}"."${leftTableColumn}", "${rightTable}"."${rightTableColumn}") < ${distance}`;
+            }
+            else {
+                throw new Error(`Unknown ${distanceMethod}`);
+            }
+        }
+        else {
+            throw new Error("options.distance must be a number");
+        }
+    }
+    else {
+        throw new Error(`Unknown ${method} method`);
+    }
+    return query;
+}

package/script/methods/joinQuery.d.ts

@@ -0,0 +1,2 @@
+export default function joinQuery(leftTable: string, rightTable: string, commonColumn: string[], join: "inner" | "left" | "right" | "full", outputTable: string): string;
+//# sourceMappingURL=joinQuery.d.ts.map

package/script/methods/joinQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinQuery.d.ts","sourceRoot":"","sources":["../../src/methods/joinQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EACzC,WAAW,EAAE,MAAM,UAwBpB"}

package/script/methods/joinQuery.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = joinQuery;
+function joinQuery(leftTable, rightTable, commonColumn, join, outputTable) {
+    let query = `CREATE OR REPLACE TABLE "${outputTable}" AS SELECT *`;
+    if (join === "inner") {
+        query += ` FROM "${leftTable}" JOIN "${rightTable}"`;
+    }
+    else if (join === "left") {
+        query += ` FROM "${leftTable}" LEFT JOIN "${rightTable}"`;
+    }
+    else if (join === "right") {
+        query += ` FROM "${leftTable}" RIGHT JOIN "${rightTable}"`;
+    }
+    else if (join === "full") {
+        query += ` FROM "${leftTable}" FULL JOIN "${rightTable}"`;
+    }
+    else {
+        throw new Error(`Unknown ${join} join.`);
+    }
+    query += ` ON (${commonColumn.map((d) => `"${leftTable}"."${d}" = "${rightTable}"."${d}"`)
+        .join(" AND ")});\n`;
+    return query;
+}

package/script/methods/keepQuery.d.ts

@@ -0,0 +1,4 @@
+export default function keepQuery(table: string, columnsAndValues: {
+    [key: string]: (number | string | Date | boolean | null)[] | (number | string | Date | boolean | null);
+}): string;
+//# sourceMappingURL=keepQuery.d.ts.map

package/script/methods/keepQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keepQuery.d.ts","sourceRoot":"","sources":["../../src/methods/keepQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE;IAChB,CAAC,GAAG,EAAE,MAAM,GACR,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,GAC3C,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;CAC/C,UAqBF"}

package/script/methods/keepQuery.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = keepQuery;
+const parseValue_js_1 = __importDefault(require("../helpers/parseValue.js"));
+function keepQuery(table, columnsAndValues) {
+    let query = `CREATE OR REPLACE TABLE "${table}" AS SELECT * FROM "${table}" WHERE\n`;
+    const columns = Object.keys(columnsAndValues);
+    const conditions = [];
+    for (const column of columns) {
+        let values = columnsAndValues[column];
+        if (!Array.isArray(values)) {
+            values = [values];
+        }
+        conditions.push(`"${column}" IN (${values.map((d) => (0, parseValue_js_1.default)(d)).join(", ")})`);
+    }
+    query += conditions.join("\nAND ");
+    return query;
+}

package/script/methods/linearRegressionQuery.d.ts

@@ -0,0 +1,5 @@
+export default function linearRegressionQuery(table: string, outputTable: string, permutations: [string, string][], options: {
+    categories?: string | string[];
+    decimals?: number;
+}): string;
+//# sourceMappingURL=linearRegressionQuery.d.ts.map

package/script/methods/linearRegressionQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearRegressionQuery.d.ts","sourceRoot":"","sources":["../../src/methods/linearRegressionQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAChC,OAAO,EAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,UAkDF"}

package/script/methods/linearRegressionQuery.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = linearRegressionQuery;
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+function linearRegressionQuery(table, outputTable, permutations, options) {
+    let query = `CREATE OR REPLACE TABLE "${outputTable}" AS`;
+    const categories = options.categories
+        ? (0, stringToArray_js_1.default)(options.categories)
+        : [];
+    const groupBy = categories.length === 0
+        ? ""
+        : ` GROUP BY ${categories.map((d) => `"${d}"`).join(",")}`;
+    let firstValue = true;
+    for (const perm of permutations) {
+        if (firstValue) {
+            firstValue = false;
+        }
+        else {
+            query += "\nUNION";
+        }
+        let tempSlop;
+        let tempIntercept;
+        let tempR2;
+        if (typeof options.decimals === "number") {
+            tempSlop = `ROUND(REGR_SLOPE("${perm[1]}", "${perm[0]}"), ${options.decimals})`;
+            tempIntercept = `ROUND(REGR_INTERCEPT("${perm[1]}", "${perm[0]}"), ${options.decimals})`;
+            tempR2 = `ROUND(REGR_R2("${perm[1]}", "${perm[0]}"), ${options.decimals})`;
+        }
+        else {
+            tempSlop = `REGR_SLOPE("${perm[1]}", "${perm[0]}")`;
+            tempIntercept = `REGR_INTERCEPT("${perm[1]}", "${perm[0]}")`;
+            tempR2 = `REGR_R2("${perm[1]}", "${perm[0]}")`;
+        }
+        query += `\nSELECT ${categories.length > 0
+            ? `${categories.map((d) => `"${d}"`).join(",")}, `
+            : ""}'${perm[0]}' AS "x", '${perm[1]}' AS "y", ${tempSlop} AS "slope", ${tempIntercept} AS "yIntercept", ${tempR2} as "r2"
+        FROM "${table}"${groupBy}`;
+    }
+    return query;
+}

package/script/methods/linearRegressions.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function linearRegressions(SimpleTable: SimpleTable, options?: {
+    x?: string;
+    y?: string;
+    categories?: string | string[];
+    decimals?: number;
+    outputTable?: string | boolean;
+}): Promise<void>;
+//# sourceMappingURL=linearRegressions.d.ts.map

package/script/methods/linearRegressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearRegressions.d.ts","sourceRoot":"","sources":["../../src/methods/linearRegressions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,iBAAiB,CAC7C,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,iBA8CP"}

package/script/methods/linearRegressions.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = linearRegressions;
+const getCombinations_js_1 = __importDefault(require("../helpers/getCombinations.js"));
+const keepNumericalColumns_js_1 = __importDefault(require("../helpers/keepNumericalColumns.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const linearRegressionQuery_js_1 = __importDefault(require("./linearRegressionQuery.js"));
+async function linearRegressions(SimpleTable, options = {}) {
+    const outputTable = typeof options.outputTable === "string"
+        ? options.outputTable
+        : SimpleTable.name;
+    const permutations = [];
+    if (!options.x && !options.y) {
+        const types = await SimpleTable.getTypes();
+        const columns = (0, keepNumericalColumns_js_1.default)(types);
+        const combinations = (0, getCombinations_js_1.default)(columns, 2);
+        for (const c of combinations) {
+            permutations.push(c);
+            permutations.push([c[1], c[0]]);
+        }
+    }
+    else if (options.x && !options.y) {
+        const types = await SimpleTable.getTypes();
+        const columns = (0, keepNumericalColumns_js_1.default)(types);
+        for (const col of columns) {
+            if (col !== options.x) {
+                permutations.push([options.x, col]);
+            }
+        }
+    }
+    else if (options.x && options.y) {
+        permutations.push([options.x, options.y]);
+    }
+    else {
+        throw new Error("No combinations of x and y");
+    }
+    await (0, queryDB_js_1.default)(SimpleTable, (0, linearRegressionQuery_js_1.default)(SimpleTable.name, outputTable, permutations, options), (0, mergeOptions_js_1.default)(SimpleTable, {
+        table: outputTable,
+        method: "linearRegressions()",
+        parameters: {
+            options,
+            "permutations (computed)": permutations,
+        },
+    }));
+}

package/script/methods/loadArray.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function loadArray(simpleTable: SimpleTable, arrayOfObjects: {
+    [key: string]: unknown;
+}[]): Promise<void>;
+//# sourceMappingURL=loadArray.d.ts.map

package/script/methods/loadArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadArray.d.ts","sourceRoot":"","sources":["../../src/methods/loadArray.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,iBAkG7C"}

package/script/methods/loadArray.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadArray;
+const node_api_1 = require("@duckdb/node-api");
+const parseTypes_js_1 = __importDefault(require("../helpers/parseTypes.js"));
+const parseDuckDBType_js_1 = __importDefault(require("../helpers/parseDuckDBType.js"));
+async function loadArray(simpleTable, arrayOfObjects) {
+    if (simpleTable.connection === undefined) {
+        await simpleTable.sdb.start();
+        simpleTable.connection = simpleTable.sdb.connection;
+    }
+    const keys = Object.keys(arrayOfObjects[0]);
+    const firstNonNullValue = keys.map((key) => arrayOfObjects.find((obj) => obj[key] !== null && obj[key] !== undefined)?.[key]);
+    const types = [];
+    const dataForChunk = arrayOfObjects.map(() => []);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = firstNonNullValue[i];
+        const type = typeof value;
+        if (type === "symbol" ||
+            type === "function") {
+            throw new Error(`Type ${type} not supported for ${key}. Value: ${value}`);
+        }
+        else if (type === "undefined") {
+            // If all values in the column are null or undefined, default to VARCHAR type.
+            types[i] = "VARCHAR";
+            for (let j = 0; j < arrayOfObjects.length; j++) {
+                dataForChunk[j][i] = null;
+            }
+        }
+        else if (type === "object") {
+            if (value instanceof Date) {
+                types[i] = "TIMESTAMP";
+                for (let j = 0; j < arrayOfObjects.length; j++) {
+                    const d = arrayOfObjects[j][key];
+                    if (d === null || d === undefined || Number.isNaN(d)) {
+                        dataForChunk[j][i] = null;
+                    }
+                    else {
+                        const date = d;
+                        dataForChunk[j][i] = new node_api_1.DuckDBTimestampValue(BigInt(date.getTime() * 1000));
+                    }
+                }
+            }
+            else if (Array.isArray(value)) {
+                types[i] = `FLOAT[${value.length}]`;
+                for (let j = 0; j < arrayOfObjects.length; j++) {
+                    const d = arrayOfObjects[j][key];
+                    dataForChunk[j][i] = (0, node_api_1.arrayValue)(d);
+                }
+            }
+            else {
+                throw new Error(`Type object not supported for ${key}. Value: ${value}`);
+            }
+        }
+        else {
+            types[i] = (0, parseTypes_js_1.default)(type);
+            for (let j = 0; j < arrayOfObjects.length; j++) {
+                const d = arrayOfObjects[j][key];
+                if (d === null || d === undefined || Number.isNaN(d)) {
+                    dataForChunk[j][i] = null;
+                }
+                else {
+                    dataForChunk[j][i] = d;
+                }
+            }
+        }
+    }
+    await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE "${simpleTable.name}"(${keys.map((key, i) => `"${key}" ${types[i]}`).join(", ")})`);
+    const appender = await simpleTable.connection
+        .createAppender(simpleTable.name);
+    // The maximum capacity of a DuckDB data chunk is 2048 rows.
+    const chunkSize = 2000;
+    for (let i = 0; i < dataForChunk.length; i += chunkSize) {
+        const chunk = dataForChunk.slice(i, i + chunkSize);
+        const dataChunk = node_api_1.DuckDBDataChunk.create(types.map((d) => (0, parseDuckDBType_js_1.default)(d)), chunk.length);
+        dataChunk.setRows(chunk);
+        appender.appendDataChunk(dataChunk);
+    }
+    appender.flushSync();
+}

package/script/methods/loadDataQuery.d.ts

@@ -0,0 +1,23 @@
+export default function loadDataQuery(table: string, files: string[], options?: {
+    fileType?: "csv" | "dsv" | "json" | "parquet" | "excel";
+    autoDetect?: boolean;
+    limit?: number;
+    fileName?: boolean;
+    unifyColumns?: boolean;
+    columnTypes?: {
+        [key: string]: string;
+    };
+    header?: boolean;
+    allText?: boolean;
+    delim?: string;
+    skip?: number;
+    nullPadding?: boolean;
+    ignoreErrors?: boolean;
+    compression?: "none" | "gzip" | "zstd";
+    encoding?: string;
+    strict?: boolean;
+    jsonFormat?: "unstructured" | "newlineDelimited" | "array";
+    records?: boolean;
+    sheet?: string;
+}): string;
+//# sourceMappingURL=loadDataQuery.d.ts.map

package/script/methods/loadDataQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDataQuery.d.ts","sourceRoot":"","sources":["../../src/methods/loadDataQuery.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,aAAa,CACnC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAExC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,UAAU,CAAC,EAAE,cAAc,GAAG,kBAAkB,GAAG,OAAO,CAAC;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,UAwFP"}