@nshiab/simple-data-analysis-core 0.0.12

package/script/methods/rollingQuery.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rollingQuery;
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+function rollingQuery(table, column, newColumn, summary, preceding, following, options = {}) {
+    const aggregates = {
+        count: "COUNT",
+        min: "MIN",
+        max: "MAX",
+        mean: "AVG",
+        median: "MEDIAN",
+        sum: "SUM",
+    };
+    const categories = options.categories
+        ? (0, stringToArray_js_1.default)(options.categories)
+        : [];
+    const partition = categories.length > 0
+        ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`
+        : "";
+    const tempQuery = `${aggregates[summary]}("${column}") OVER (${partition}
+                ROWS BETWEEN ${preceding} PRECEDING AND ${following} FOLLOWING)`;
+    const query = `CREATE OR REPLACE TABLE "${table}" AS SELECT *,
+    ${typeof options.decimals === "number"
+        ? `ROUND(${tempQuery}, ${options.decimals})`
+        : tempQuery} AS "${newColumn}",
+        COUNT("${column}") OVER (${partition}
+            ROWS BETWEEN ${preceding} PRECEDING AND ${following} FOLLOWING) as tempCountForRolling
+        FROM "${table}";
+        UPDATE "${table}" SET "${newColumn}" = CASE
+            WHEN "tempCountForRolling" != ${preceding + following + 1} THEN NULL
+            ELSE "${newColumn}"
+        END;
+        ALTER TABLE "${table}" DROP COLUMN "tempCountForRolling";
+        `;
+    return query;
+}

package/script/methods/roundQuery.d.ts

@@ -0,0 +1,5 @@
+export default function roundQuery(table: string, columns: string[], options: {
+    method?: "round" | "ceiling" | "floor";
+    decimals?: number;
+}): string;
+//# sourceMappingURL=roundQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roundQuery.d.ts","sourceRoot":"","sources":["../../src/methods/roundQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,UAiBvE"}

package/script/methods/roundQuery.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = roundQuery;
+function roundQuery(table, columns, options) {
+    let query = `UPDATE "${table}" SET`;
+    const method = options.method?.toUpperCase() ?? "ROUND";
+    const decimals = options.decimals ?? 0;
+    if (method === "ROUND") {
+        for (const column of columns) {
+            query += `\n"${column}" = ${method}("${column}", ${decimals}),`;
+        }
+    }
+    else {
+        for (const column of columns) {
+            query += `\n"${column}" = ${method}("${column}"),`;
+        }
+    }
+    return query.slice(0, query.length - 1);
+}

package/script/methods/selectRowsQuery.d.ts

@@ -0,0 +1,5 @@
+export default function selectRowsQuery(table: string, count: number | string, options?: {
+    offset?: number;
+    outputTable?: string | boolean;
+}): string;
+//# sourceMappingURL=selectRowsQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectRowsQuery.d.ts","sourceRoot":"","sources":["../../src/methods/selectRowsQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAO,UAOlE"}

package/script/methods/selectRowsQuery.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = selectRowsQuery;
+function selectRowsQuery(table, count, options = {}) {
+    return `CREATE OR REPLACE TABLE "${options.outputTable ?? table}" AS SELECT * FROM "${table}" LIMIT ${count}${typeof options.offset === "number" ? ` OFFSET ${options.offset}` : ""};`;
+}

package/script/methods/sortQuery.d.ts

@@ -0,0 +1,8 @@
+export default function sortQuery(table: string, order: {
+    [key: string]: "asc" | "desc";
+} | null, options?: {
+    lang?: {
+        [key: string]: string;
+    };
+}): string;
+//# sourceMappingURL=sortQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sortQuery.d.ts","sourceRoot":"","sources":["../../src/methods/sortQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAA;CAAE,GAAG,IAAI,EAC/C,OAAO,GAAE;IACP,IAAI,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC7B,UAsBP"}

package/script/methods/sortQuery.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortQuery;
+function sortQuery(table, order, options = {}) {
+    let query = `CREATE OR REPLACE TABLE "${table}" AS SELECT * FROM "${table}"
+    ORDER BY`;
+    if (order === null) {
+        query += " ALL; ";
+    }
+    else {
+        for (const column of Object.keys(order)) {
+            if (options.lang && options.lang[column]) {
+                query += `\n"${column}" COLLATE ${options.lang[column]} ${order[column].toUpperCase()},`;
+            }
+            else {
+                query += `\n"${column}" ${order[column].toUpperCase()},`;
+            }
+        }
+    }
+    return query.slice(0, query.length - 1);
+}

package/script/methods/splitSpread.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function splitSpread(simpleTable: SimpleTable, column: string, separator: string, newColumns: string[], options?: {
+    noCheck?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=splitSpread.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"splitSpread.d.ts","sourceRoot":"","sources":["../../src/methods/splitSpread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,WAAW,CACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBAiGP"}

package/script/methods/splitSpread.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = splitSpread;
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+async function splitSpread(simpleTable, column, separator, newColumns, options = {}) {
+    const nbParts = newColumns.length;
+    if (!options.noCheck) {
+        // Check if any row has more parts than expected
+        const maxPartsResult = await (0, queryDB_js_1.default)(simpleTable, `SELECT MAX(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as max_parts FROM "${simpleTable.name}"`, (0, mergeOptions_js_1.default)(simpleTable, {
+            table: simpleTable.name,
+            method: "splitSpread()",
+            parameters: { column, separator, newColumns },
+            returnDataFrom: "query",
+        }));
+        if (maxPartsResult && maxPartsResult.length > 0) {
+            const maxParts = maxPartsResult[0].max_parts;
+            if (maxParts > nbParts) {
+                // Get the first 5 rows with more parts than expected
+                const problematicRows = await (0, queryDB_js_1.default)(simpleTable, `SELECT "${column}" 
+         FROM "${simpleTable.name}" 
+         WHERE ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}')) > ${nbParts}
+         LIMIT 5`, (0, mergeOptions_js_1.default)(simpleTable, {
+                    table: simpleTable.name,
+                    method: "splitSpread()",
+                    parameters: { column, separator, newColumns },
+                    returnDataFrom: "query",
+                }));
+                const exampleRows = problematicRows
+                    ? problematicRows.map((row) => row[column]).join("\n  - ")
+                    : "";
+                throw new Error(`Some rows contain more values after splitting (${maxParts}) than the number of new columns specified (${nbParts}).
+When splitting by '${separator}', each row must produce at most ${nbParts} value(s) to fit in the columns: ${newColumns.join(", ")}.
+
+First 5 rows with too many values:\n  - ${exampleRows}`);
+            }
+        }
+        // Check if any row has fewer parts than expected
+        const minPartsResult = await (0, queryDB_js_1.default)(simpleTable, `SELECT MIN(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as min_parts FROM "${simpleTable.name}"`, (0, mergeOptions_js_1.default)(simpleTable, {
+            table: simpleTable.name,
+            method: "splitSpread()",
+            parameters: { column, separator, newColumns },
+            returnDataFrom: "query",
+        }));
+        if (minPartsResult && minPartsResult.length > 0) {
+            const minParts = minPartsResult[0].min_parts;
+            if (minParts < nbParts) {
+                console.warn(`splitSpread() warning: Some rows contain fewer values after splitting (${minParts}) than the number of new columns (${nbParts}). Empty strings will be used for missing values.`);
+            }
+        }
+    }
+    const alterStatements = newColumns
+        .map((col) => `ALTER TABLE "${simpleTable.name}" ADD "${col}" VARCHAR;`)
+        .join("\n");
+    const updateStatements = newColumns
+        .map((col, i) => `UPDATE "${simpleTable.name}" SET "${col}" = SPLIT_PART("${column}", '${separator}', ${i + 1});`)
+        .join("\n");
+    await (0, queryDB_js_1.default)(simpleTable, `${alterStatements}
+    ${updateStatements}`, (0, mergeOptions_js_1.default)(simpleTable, {
+        table: simpleTable.name,
+        method: "splitSpread()",
+        parameters: { column, separator, newColumns },
+    }));
+}

package/script/methods/summarize.d.ts

@@ -0,0 +1,13 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function summarize(SimpleTable: SimpleTable, options?: {
+    outputTable?: string | boolean;
+    values?: string | string[];
+    categories?: string | string[];
+    summaries?: ("count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var") | ("count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var")[] | {
+        [key: string]: "count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var";
+    };
+    decimals?: number;
+    toMs?: boolean;
+    noColumnValue?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=summarize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/methods/summarize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,SAAS,CAAC,EACN,CACE,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CACR,GACC,CACE,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CACR,EAAE,GACD;QACA,CAAC,GAAG,EAAE,MAAM,GACR,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CAAC;KACX,CAAC;IACJ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACpB,iBAiFP"}

package/script/methods/summarize.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = summarize;
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+const summarizeQuery_js_1 = __importDefault(require("./summarizeQuery.js"));
+async function summarize(SimpleTable, options = {}) {
+    const outputTable = typeof options.outputTable === "string"
+        ? options.outputTable
+        : SimpleTable.name;
+    options.values = options.values ? (0, stringToArray_js_1.default)(options.values) : [];
+    if (options.values.length === 0) {
+        await SimpleTable.addRowNumber("rowNumberToSummarizeQuerySDA");
+        options.values = ["rowNumberToSummarizeQuerySDA"];
+    }
+    options.categories = options.categories
+        ? (0, stringToArray_js_1.default)(options.categories)
+        : [];
+    let columns;
+    if (options.summaries === undefined) {
+        if (options.values.length === 1 &&
+            options.values[0] === "rowNumberToSummarizeQuerySDA") {
+            options.summaries = ["count"];
+        }
+        else {
+            options.summaries = [];
+        }
+    }
+    else if (typeof options.summaries === "string") {
+        options.summaries = [options.summaries];
+    }
+    else if (!Array.isArray(options.summaries) && typeof options.summaries === "object") {
+        const entries = Object.entries(options.summaries);
+        columns = entries.map((d) => d[0]);
+        options.summaries = entries.map((d) => d[1]);
+    }
+    const types = await SimpleTable.getTypes();
+    if (options.toMs) {
+        const toMsObj = {};
+        for (const key of Object.keys(types)) {
+            if (types[key].includes("TIME") || types[key].includes("DATE")) {
+                toMsObj[key] = "bigint";
+                types[key] = "bigint";
+            }
+        }
+        await SimpleTable.convert(toMsObj);
+    }
+    options.values = options.values.filter((d) => !options.categories?.includes(d));
+    await (0, queryDB_js_1.default)(SimpleTable, (0, summarizeQuery_js_1.default)(SimpleTable.name, types, outputTable, options.values, options.categories, options.summaries, options, columns), (0, mergeOptions_js_1.default)(SimpleTable, {
+        table: outputTable,
+        method: "summarize()",
+        parameters: {
+            options,
+        },
+    }));
+    if (options.values.includes("rowNumberToSummarizeQuerySDA")) {
+        if (await SimpleTable.hasColumn("rowNumberToSummarizeQuerySDA")) {
+            await SimpleTable.removeColumns("rowNumberToSummarizeQuerySDA");
+        }
+        SimpleTable.sdb.customQuery(`ALTER TABLE "${outputTable}" DROP COLUMN value;`);
+    }
+}

package/script/methods/summarizeQuery.d.ts

@@ -0,0 +1,7 @@
+export default function summarizeQuery(table: string, types: {
+    [key: string]: string;
+}, outputTable: string, values: string[], categories: string[], summaries: ("count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var")[], options: {
+    decimals?: number;
+    noColumnValue?: boolean;
+} | undefined, columns: string[] | undefined): string;
+//# sourceMappingURL=summarizeQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summarizeQuery.d.ts","sourceRoot":"","sources":["../../src/methods/summarizeQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB,EACD,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EAAE,EAChB,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,CACP,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CACR,EAAE,EACH,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,YAAK,EAC5D,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,UA4J9B"}

package/script/methods/summarizeQuery.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = summarizeQuery;
+function summarizeQuery(table, types, outputTable, values, categories, summaries, options = {}, columns) {
+    if (values.length > 1 && options.noColumnValue) {
+        throw new Error("The options `noColumnValue` works only when you aggregate the values from one column. Remove the option `noColumnValue` or specify just one column in the option `values`.");
+    }
+    const typesOfValues = values.map((d) => types[d]);
+    const doubleAndDate = Object.values(typesOfValues).includes("DOUBLE") &&
+        Object.values(typesOfValues).filter((d) => [
+            "DATE",
+            "TIME",
+            "TIMESTAMP",
+            "TIMESTAMP_MS",
+            "TIMESTAMP WITH TIME ZONE",
+        ].includes(d)).length >= 1;
+    if (doubleAndDate) {
+        throw new Error("You are trying to summarize numbers and timestamps/dates/times. You can specify values in the options (just numbers or just timestamps/dates/times) or convert your timestamps/dates/times to the number of ms since 1970-01-01 00:00:00 by passing the option { toMs: true }.");
+    }
+    const aggregates = {
+        count: "count", // specific implementation
+        countUnique: "countUnique", // specific implementation
+        countNull: "countNull", // Specific implementation
+        min: "MIN(",
+        max: "MAX(",
+        mean: "AVG(",
+        median: "MEDIAN(",
+        sum: "SUM(",
+        skew: "SKEWNESS(",
+        stdDev: "STDDEV(",
+        var: "VARIANCE(",
+    };
+    if (summaries.length === 0) {
+        summaries = Object.keys(aggregates);
+    }
+    let query = `CREATE OR REPLACE TABLE "${outputTable}" AS`;
+    let firstValue = true;
+    for (const value of values) {
+        if (firstValue) {
+            firstValue = false;
+        }
+        else {
+            query += "\nUNION";
+        }
+        query += `\nSELECT ${options.noColumnValue ? "" : `'${value}' AS 'value'`}${categories.length > 0
+            ? `, ${categories.map((d) => `"${d}"`).join(", ")}`
+            : ""},${summaries.map((summary, i) => {
+            if (value === "rowNumberToSummarizeQuerySDA" &&
+                aggregates[summary] !== "count") {
+                return `\nNULL as '${columns ? columns[i] : summary}'`;
+            }
+            else if (types[value] === "GEOMETRY") {
+                return `\nNULL AS '${columns ? columns[i] : summary}'`;
+            }
+            else if (types[value] === "VARCHAR" &&
+                [
+                    "MIN(",
+                    "MAX(",
+                    "AVG(",
+                    "MEDIAN(",
+                    "SUM(",
+                    "SKEWNESS(",
+                    "STDDEV(",
+                    "VARIANCE(",
+                ].includes(aggregates[summary])) {
+                return `\nNULL AS '${columns ? columns[i] : summary}'`;
+            }
+            else if ([
+                "DATE",
+                "TIME",
+                "TIMESTAMP",
+                "TIMESTAMP_MS",
+                "TIMESTAMP WITH TIME ZONE",
+            ].includes(types[value]) &&
+                ["AVG(", "SUM(", "SKEWNESS(", "STDDEV(", "VARIANCE("].includes(aggregates[summary])) {
+                return `\nNULL AS '${columns ? columns[i] : summary}'`;
+            }
+            else if (summary === "count") {
+                return `\nCAST(COUNT(*) AS INTEGER) AS '${columns ? columns[i] : "count"}'`;
+            }
+            else if (summary === "countUnique") {
+                return `\nCAST(COUNT(DISTINCT "${value}") AS INTEGER) AS '${columns ? columns[i] : "countUnique"}'`;
+            }
+            else if (summary === "countNull") {
+                return `\nCAST(COUNT(CASE WHEN "${value}" IS NULL THEN 1 END) AS INTEGER) as '${columns ? columns[i] : "countNull"}'`;
+            }
+            else {
+                return typeof options.decimals === "number" &&
+                    ![
+                        "VARCHAR",
+                        "DATE",
+                        "TIME",
+                        "TIMESTAMP",
+                        "TIMESTAMP WITH TIME ZONE",
+                    ].includes(types[value])
+                    ? `\nROUND(${aggregates[summary]}"${value}"), ${options.decimals}) AS '${columns ? columns[i] : summary}'`
+                    : `\n${aggregates[summary]}"${value}") AS '${columns ? columns[i] : summary}'`;
+            }
+        })}\nFROM "${table}"`;
+        if (categories.length > 0) {
+            query += `\nGROUP BY ${categories.map((d) => `"${d}"`).join(", ")}`;
+        }
+    }
+    if (options.noColumnValue) {
+        if (categories.length > 0) {
+            query += `\nORDER BY ${categories.map((d) => `"${d}" ASC`).join(", ")}`;
+        }
+    }
+    else {
+        query += `\nORDER BY ${["value", ...categories]
+            .map((d) => `"${d}" ASC`)
+            .join(", ")}`;
+    }
+    return query.replace("SELECT ,", "SELECT ");
+}

package/script/methods/trimQuery.d.ts

@@ -0,0 +1,5 @@
+export default function trimQuery(table: string, columns: string[], options: {
+    character?: string;
+    method?: "leftTrim" | "rightTrim" | "trim";
+}): string;
+//# sourceMappingURL=trimQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trimQuery.d.ts","sourceRoot":"","sources":["../../src/methods/trimQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,CAAA;CAAE,UA8B5E"}

package/script/methods/trimQuery.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = trimQuery;
+function trimQuery(table, columns, options) {
+    let query = ``;
+    const method = options.method ?? "trim";
+    const specialCharacter = typeof options.character === "string"
+        ? `, '${options.character}'`
+        : "";
+    if (method === "trim") {
+        for (const column of columns) {
+            query +=
+                `\nUPDATE "${table}" SET "${column}" = TRIM("${column}"${specialCharacter});`;
+        }
+    }
+    else if (method === "leftTrim") {
+        for (const column of columns) {
+            query +=
+                `\nUPDATE "${table}" SET "${column}" = LTRIM("${column}"${specialCharacter});`;
+        }
+    }
+    else if (method === "rightTrim") {
+        for (const column of columns) {
+            query +=
+                `\nUPDATE "${table}" SET "${column}" = RTRIM("${column}"${specialCharacter});`;
+        }
+    }
+    else {
+        throw new Error(`Unknown method ${options.method}`);
+    }
+    return query;
+}

package/script/methods/truncateQuery.d.ts

@@ -0,0 +1,2 @@
+export default function truncateQuery(table: string, column: string, length: number): string;
+//# sourceMappingURL=truncateQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"truncateQuery.d.ts","sourceRoot":"","sources":["../../src/methods/truncateQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,aAAa,CACnC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,UAGf"}

package/script/methods/truncateQuery.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = truncateQuery;
+function truncateQuery(table, column, length) {
+    return `UPDATE "${table}" SET "${column}" = LEFT("${column}", ${length});`;
+}

package/script/methods/upperQuery.d.ts

@@ -0,0 +1,2 @@
+export default function upperQuery(table: string, columns: string[]): string;
+//# sourceMappingURL=upperQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upperQuery.d.ts","sourceRoot":"","sources":["../../src/methods/upperQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAQlE"}

package/script/methods/upperQuery.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = upperQuery;
+function upperQuery(table, columns) {
+    let query = "";
+    for (const column of columns) {
+        query += `\nUPDATE "${table}" SET "${column}" = UPPER("${column}");`;
+    }
+    return query;
+}

package/script/methods/writeDataQuery.d.ts

@@ -0,0 +1,5 @@
+export default function writeDataQuery(table: string, file: string, fileExtension: string, options: {
+    compression?: boolean;
+    formatDates?: boolean;
+}): string;
+//# sourceMappingURL=writeDataQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeDataQuery.d.ts","sourceRoot":"","sources":["../../src/methods/writeDataQuery.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,UAgD1D"}

package/script/methods/writeDataQuery.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = writeDataQuery;
+const node_fs_1 = require("node:fs");
+const cleanPath_js_1 = __importDefault(require("../helpers/cleanPath.js"));
+function writeDataQuery(table, file, fileExtension, options) {
+    const cleanedFile = (0, cleanPath_js_1.default)(file);
+    if (fileExtension === "csv") {
+        return `COPY "${table}" TO '${options.compression ? cleanedFile + ".gz" : cleanedFile}' (DELIMITER ',', HEADER TRUE${options.compression ? ", COMPRESSION GZIP" : ""}${options.formatDates
+            ? ", DATEFORMAT '%xT%X.%gZ', TIMESTAMPFORMAT '%xT%X.%gZ'"
+            : ""});`;
+    }
+    else if (fileExtension === "json") {
+        return `COPY "${table}" TO '${options.compression ? cleanedFile + ".gz" : cleanedFile}' (FORMAT JSON, ARRAY TRUE${options.compression ? ", COMPRESSION GZIP" : ""}${options.formatDates
+            ? ", DATEFORMAT '%xT%X.%gZ', TIMESTAMPFORMAT '%xT%X.%gZ'"
+            : ""});`;
+    }
+    else if (fileExtension === "parquet") {
+        if (options.compression) {
+            return `COPY "${table}" TO '${cleanedFile}' (FORMAT PARQUET, COMPRESSION ZSTD);`;
+        }
+        else {
+            return `COPY "${table}" TO '${cleanedFile}' (FORMAT PARQUET);`;
+        }
+    }
+    else if (fileExtension === "db") {
+        if ((0, node_fs_1.existsSync)(file)) {
+            (0, node_fs_1.rmSync)(file);
+        }
+        return `ATTACH '${cleanedFile}' AS "my_database";
+COPY FROM DATABASE memory TO "my_database";
+CREATE OR REPLACE TABLE "my_database"."${table}" AS SELECT * FROM "${table}";
+DETACH "my_database";`;
+    }
+    else if (fileExtension === "sqlite") {
+        if ((0, node_fs_1.existsSync)(file)) {
+            (0, node_fs_1.rmSync)(file);
+        }
+        return `INSTALL sqlite; LOAD sqlite;
+    ATTACH '${cleanedFile}' AS "my_sqlite_db" (TYPE SQLITE);
+    CREATE TABLE "my_sqlite_db"."${table}" AS SELECT * FROM "${table}";
+    DETACH "my_sqlite_db";`;
+    }
+    else {
+        throw new Error(`Unknown extension ${fileExtension}`);
+    }
+}

package/script/methods/writeGeoDataQuery.d.ts

@@ -0,0 +1,4 @@
+export default function writeGeoDataQuery(table: string, file: string, fileExtension: string, options?: {
+    precision?: number;
+}): string;
+//# sourceMappingURL=writeGeoDataQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeGeoDataQuery.d.ts","sourceRoot":"","sources":["../../src/methods/writeGeoDataQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,UAqBrC"}

package/script/methods/writeGeoDataQuery.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = writeGeoDataQuery;
+const cleanPath_js_1 = __importDefault(require("../helpers/cleanPath.js"));
+function writeGeoDataQuery(table, file, fileExtension, options = {}) {
+    if (fileExtension === "geojson" || fileExtension === "json") {
+        const layerOptions = [];
+        if (typeof options.precision === "number") {
+            layerOptions.push(`COORDINATE_PRECISION=${options.precision}`);
+        }
+        layerOptions.push(`RFC7946=YES`);
+        return `COPY "${table}" to '${(0, cleanPath_js_1.default)(file)}' WITH (FORMAT GDAL, DRIVER 'GeoJSON'${layerOptions.length > 0
+            ? `, LAYER_CREATION_OPTIONS ('WRITE_NAME=NO', ${layerOptions.map((d) => `'${d}'`).join(", ")})`
+            : ""})`;
+    }
+    else {
+        throw new Error(`Unknown extension ${fileExtension}`);
+    }
+}

package/script/methods/zScoreQuery.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"zScoreQuery.d.ts","sourceRoot":"","sources":["../../src/methods/zScoreQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,UA0BP"}

package/script/methods/zScoreQuery.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = zScoreQuery;
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+function zScoreQuery(table, column, newColumn, options = {}) {
+    const categories = options.categories
+        ? (0, stringToArray_js_1.default)(options.categories)
+        : [];
+    const partition = categories.length > 0
+        ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`
+        : "";
+    const tempQuery = `("${column}"-AVG("${column}") OVER(${partition}))
+            /
+            STDDEV_POP("${column}") OVER(${partition})`;
+    const query = `
+    CREATE OR REPLACE TABLE "${table}" AS
+    SELECT *, (
+        ${typeof options.decimals === "number"
+        ? `ROUND(${tempQuery}, ${options.decimals})`
+        : tempQuery}
+        
+        ) AS ${newColumn},
+    FROM "${table}"
+    `;
+    return query;
+}

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}