@nshiab/simple-data-analysis-core 0.0.12

package/esm/methods/ranksQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranksQuery.d.ts","sourceRoot":"","sources":["../../src/methods/ranksQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,UAkBP"}

package/esm/methods/ranksQuery.js

@@ -0,0 +1,12 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function rankQuery(table, values, newColumn, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories)
+        : [];
+    const partition = categories.length === 0
+        ? ""
+        : `PARTITION BY ${categories.map((d) => `"${d}"`).join(",")} `;
+    const query = `CREATE OR REPLACE TABLE "${table}" AS SELECT *, ${options.noGaps ? "dense_rank()" : "rank()"} OVER (${partition}ORDER BY "${values}" ${typeof options.order === "string" ? options.order.toUpperCase() : ""}) AS "${newColumn}"
+    FROM "${table}"`;
+    return query;
+}

package/esm/methods/removeDuplicatesQuery.d.ts

@@ -0,0 +1,4 @@
+export default function removeDuplicatesQuery(table: string, options?: {
+    on?: string | string[];
+}): string;
+//# sourceMappingURL=removeDuplicatesQuery.d.ts.map

package/esm/methods/removeDuplicatesQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeDuplicatesQuery.d.ts","sourceRoot":"","sources":["../../src/methods/removeDuplicatesQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,UAWP"}

package/esm/methods/removeDuplicatesQuery.js

@@ -0,0 +1,12 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function removeDuplicatesQuery(table, options = {}) {
+    const columnsOn = options.on ? stringToArray(options.on) : null;
+    let distinct;
+    if (columnsOn) {
+        distinct = `DISTINCT ON(${columnsOn.map((d) => `"${d}"`).join(",")}) *`;
+    }
+    else {
+        distinct = "DISTINCT *";
+    }
+    return `CREATE OR REPLACE TABLE "${table}" AS SELECT ${distinct} FROM "${table}";`;
+}

package/esm/methods/removeMissing.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function removeMissing(simpleTable: SimpleTable, options?: {
+    columns?: string | string[];
+    missingValues?: (string | number)[];
+    invert?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=removeMissing.d.ts.map

package/esm/methods/removeMissing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeMissing.d.ts","sourceRoot":"","sources":["../../src/methods/removeMissing.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,aAAa,CACzC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,aAAa,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,iBA8BP"}

package/esm/methods/removeMissing.js

@@ -0,0 +1,21 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import stringToArray from "../helpers/stringToArray.js";
+import removeMissingQuery from "./removeMissingQuery.js";
+export default async function removeMissing(simpleTable, options = {}) {
+    options.missingValues = options.missingValues ?? [
+        "undefined",
+        "NaN",
+        "null",
+        "NULL",
+        "",
+    ];
+    const types = await simpleTable.getTypes();
+    const allColumns = Object.keys(types);
+    options.columns = stringToArray(options.columns ?? []);
+    await queryDB(simpleTable, removeMissingQuery(simpleTable.name, allColumns, types, options.columns.length === 0 ? allColumns : options.columns, options), mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "removeMissing()",
+        parameters: { options },
+    }));
+}

package/esm/methods/removeMissingQuery.d.ts

@@ -0,0 +1,7 @@
+export default function removeMissingQuery(table: string, allColumns: string[], types: {
+    [key: string]: string;
+}, columns: string[], options?: {
+    missingValues?: (string | number)[];
+    invert?: boolean;
+}): string;
+//# sourceMappingURL=removeMissingQuery.d.ts.map

package/esm/methods/removeMissingQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeMissingQuery.d.ts","sourceRoot":"","sources":["../../src/methods/removeMissingQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAAE,EACpB,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB,EACD,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,UAoDP"}

package/esm/methods/removeMissingQuery.js

@@ -0,0 +1,43 @@
+export default function removeMissingQuery(table, allColumns, types, columns, options = {}) {
+    let query = `CREATE OR REPLACE TABLE "${table}" AS SELECT ${allColumns
+        .map((d) => `"${d}"`)
+        .join(", ")} FROM "${table}"
+        WHERE`;
+    if (options.invert) {
+        for (let i = 0; i < columns.length; i++) {
+            query += `\n"${columns[i]}" IS NULL OR`;
+            if (options.missingValues) {
+                for (const otherMissingValue of options.missingValues) {
+                    if (typeof otherMissingValue === "string" &&
+                        types[columns[i]] === "VARCHAR") {
+                        query += `\n"${columns[i]}" = '${otherMissingValue}' OR`;
+                    }
+                    else if (typeof otherMissingValue === "number" &&
+                        ["BIGINT", "DOUBLE"].includes(types[columns[i]])) {
+                        query += `\n"${columns[i]}" = ${otherMissingValue} OR`;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < columns.length; i++) {
+            query += `\n"${columns[i]}" IS NOT NULL AND`;
+            if (options.missingValues) {
+                for (const otherMissingValue of options.missingValues) {
+                    if (typeof otherMissingValue === "string" &&
+                        types[columns[i]] === "VARCHAR") {
+                        query += `\n"${columns[i]}" != '${otherMissingValue}' AND`;
+                    }
+                    else if (typeof otherMissingValue === "number" &&
+                        ["BIGINT", "DOUBLE"].includes(types[columns[i]])) {
+                        query += `\n"${columns[i]}" != ${otherMissingValue} AND`;
+                    }
+                }
+            }
+        }
+    }
+    return options.invert
+        ? query.slice(0, query.length - 3)
+        : query.slice(0, query.length - 4);
+}

package/esm/methods/removeQuery.d.ts

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

package/esm/methods/removeQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeQuery.d.ts","sourceRoot":"","sources":["../../src/methods/removeQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,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/esm/methods/removeQuery.js

@@ -0,0 +1,15 @@
+import parseValue from "../helpers/parseValue.js";
+export default function removeQuery(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}" NOT IN (${values.map((d) => parseValue(d)).join(", ")})`);
+    }
+    query += conditions.join("\nAND ");
+    return query;
+}

package/esm/methods/renameColumnQuery.d.ts

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

package/esm/methods/renameColumnQuery.d.ts.map

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

package/esm/methods/renameColumnQuery.js

@@ -0,0 +1,7 @@
+export default function renameColumnQuery(table, oldColumns, newColumns) {
+    let query = "";
+    for (let i = 0; i < oldColumns.length; i++) {
+        query += `ALTER TABLE "${table}" RENAME COLUMN "${oldColumns[i]}" TO "${newColumns[i]}";\n`;
+    }
+    return query;
+}

package/esm/methods/replaceNullsQuery.d.ts

@@ -0,0 +1,2 @@
+export default function replaceNullsQuery(table: string, columns: string[], value: number | string | Date | boolean): string;
+//# sourceMappingURL=replaceNullsQuery.d.ts.map

package/esm/methods/replaceNullsQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceNullsQuery.d.ts","sourceRoot":"","sources":["../../src/methods/replaceNullsQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,UAUxC"}

package/esm/methods/replaceNullsQuery.js

@@ -0,0 +1,10 @@
+import parseValue from "../helpers/parseValue.js";
+export default function replaceNullsQuery(table, columns, value) {
+    let query = "";
+    const valueParsed = parseValue(value);
+    for (const column of columns) {
+        query +=
+            `UPDATE "${table}" SET "${column}" = ${valueParsed} WHERE "${column}" IS NULL;`;
+    }
+    return query;
+}

package/esm/methods/replaceQuery.d.ts

@@ -0,0 +1,5 @@
+export default function replaceQuery(table: string, columns: string[], oldTexts: string[], newTexts: string[], options?: {
+    entireString?: boolean;
+    regex?: boolean;
+}): string;
+//# sourceMappingURL=replaceQuery.d.ts.map

package/esm/methods/replaceQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceQuery.d.ts","sourceRoot":"","sources":["../../src/methods/replaceQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,UA6B1D"}

package/esm/methods/replaceQuery.js

@@ -0,0 +1,24 @@
+export default function replaceQuery(table, columns, oldTexts, newTexts, options = {}) {
+    let query = "";
+    oldTexts = oldTexts.map((d) => d.replace(/'/g, "''"));
+    newTexts = newTexts.map((d) => d.replace(/'/g, "''"));
+    for (const column of columns) {
+        for (let i = 0; i < oldTexts.length; i++) {
+            if (options.entireString) {
+                query += `UPDATE "${table}" SET "${column}" = 
+                CASE
+                    WHEN "${column}" = '${oldTexts[i]}' THEN '${newTexts[i]}'
+                    ELSE "${column}"
+                END;\n`;
+            }
+            else if (options.regex) {
+                query +=
+                    `UPDATE "${table}" SET "${column}" = REGEXP_REPLACE("${column}", '${oldTexts[i]}', '${newTexts[i]}', 'g');\n`;
+            }
+            else {
+                query += `UPDATE "${table}" SET "${column}" = REPLACE("${column}", '${oldTexts[i]}', '${newTexts[i]}');\n`;
+            }
+        }
+    }
+    return query;
+}

package/esm/methods/rollingQuery.d.ts

@@ -0,0 +1,5 @@
+export default function rollingQuery(table: string, column: string, newColumn: string, summary: "count" | "min" | "max" | "mean" | "median" | "sum", preceding: number, following: number, options?: {
+    categories?: string | string[];
+    decimals?: number;
+}): string;
+//# sourceMappingURL=rollingQuery.d.ts.map

package/esm/methods/rollingQuery.d.ts.map

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

package/esm/methods/rollingQuery.js

@@ -0,0 +1,33 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default 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
+        ? stringToArray(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/esm/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/esm/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/esm/methods/roundQuery.js

@@ -0,0 +1,16 @@
+export default 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/esm/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/esm/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/esm/methods/selectRowsQuery.js

@@ -0,0 +1,3 @@
+export default 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/esm/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/esm/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/esm/methods/sortQuery.js

@@ -0,0 +1,18 @@
+export default 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/esm/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/esm/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/esm/methods/splitSpread.js

@@ -0,0 +1,61 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default 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 queryDB(simpleTable, `SELECT MAX(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as max_parts FROM "${simpleTable.name}"`, mergeOptions(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 queryDB(simpleTable, `SELECT "${column}" 
+         FROM "${simpleTable.name}" 
+         WHERE ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}')) > ${nbParts}
+         LIMIT 5`, mergeOptions(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 queryDB(simpleTable, `SELECT MIN(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as min_parts FROM "${simpleTable.name}"`, mergeOptions(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 queryDB(simpleTable, `${alterStatements}
+    ${updateStatements}`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "splitSpread()",
+        parameters: { column, separator, newColumns },
+    }));
+}

package/esm/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/esm/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/esm/methods/summarize.js

@@ -0,0 +1,60 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import stringToArray from "../helpers/stringToArray.js";
+import summarizeQuery from "./summarizeQuery.js";
+export default async function summarize(SimpleTable, options = {}) {
+    const outputTable = typeof options.outputTable === "string"
+        ? options.outputTable
+        : SimpleTable.name;
+    options.values = options.values ? stringToArray(options.values) : [];
+    if (options.values.length === 0) {
+        await SimpleTable.addRowNumber("rowNumberToSummarizeQuerySDA");
+        options.values = ["rowNumberToSummarizeQuerySDA"];
+    }
+    options.categories = options.categories
+        ? stringToArray(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 queryDB(SimpleTable, summarizeQuery(SimpleTable.name, types, outputTable, options.values, options.categories, options.summaries, options, columns), mergeOptions(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/esm/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/esm/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/esm/methods/summarizeQuery.js

@@ -0,0 +1,112 @@
+export default 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 ");
+}