@nshiab/simple-data-analysis-core 0.0.12

package/esm/methods/joinGeoQuery.js

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

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

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

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

@@ -0,0 +1,37 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function linearRegressionQuery(table, outputTable, permutations, options) {
+    let query = `CREATE OR REPLACE TABLE "${outputTable}" AS`;
+    const categories = options.categories
+        ? stringToArray(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/esm/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/esm/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/esm/methods/linearRegressions.js

@@ -0,0 +1,43 @@
+import getCombinations from "../helpers/getCombinations.js";
+import keepNumericalColumns from "../helpers/keepNumericalColumns.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import linearRegressionQuery from "./linearRegressionQuery.js";
+export default 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 = keepNumericalColumns(types);
+        const combinations = getCombinations(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 = keepNumericalColumns(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 queryDB(SimpleTable, linearRegressionQuery(SimpleTable.name, outputTable, permutations, options), mergeOptions(SimpleTable, {
+        table: outputTable,
+        method: "linearRegressions()",
+        parameters: {
+            options,
+            "permutations (computed)": permutations,
+        },
+    }));
+}

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

@@ -0,0 +1,78 @@
+import { arrayValue, DuckDBDataChunk, DuckDBTimestampValue, } from "@duckdb/node-api";
+import parseType from "../helpers/parseTypes.js";
+import parseDuckDBType from "../helpers/parseDuckDBType.js";
+export default 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 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] = arrayValue(d);
+                }
+            }
+            else {
+                throw new Error(`Type object not supported for ${key}. Value: ${value}`);
+            }
+        }
+        else {
+            types[i] = parseType(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 = DuckDBDataChunk.create(types.map((d) => parseDuckDBType(d)), chunk.length);
+        dataChunk.setRows(chunk);
+        appender.appendDataChunk(dataChunk);
+    }
+    appender.flushSync();
+}

package/esm/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/esm/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"}

package/esm/methods/loadDataQuery.js

@@ -0,0 +1,77 @@
+import cleanPath from "../helpers/cleanPath.js";
+import getExtension from "../helpers/getExtension.js";
+export default function loadDataQuery(table, files, options = {}) {
+    const fileExtension = getExtension(files[0]);
+    const filesAsString = JSON.stringify(files.map((d) => cleanPath(d)));
+    // General options, except for parquet
+    const autoDetect = typeof options.autoDetect === "boolean"
+        ? `, auto_detect=${String(options.autoDetect).toUpperCase()}`
+        : ", auto_detect=TRUE";
+    const columnTypes = options.columnTypes
+        ? `, columns=${JSON.stringify(options.columnTypes)}`
+        : "";
+    const fileName = typeof options.fileName === "boolean"
+        ? `, filename=${String(options.fileName).toUpperCase()}`
+        : "";
+    const unifyColumns = typeof options.unifyColumns === "boolean"
+        ? `, union_by_name='${String(options.unifyColumns).toUpperCase()}'`
+        : "";
+    const generalOptions = `${autoDetect}${columnTypes}${fileName}${unifyColumns}`;
+    const limit = typeof options.limit === "number"
+        ? ` LIMIT ${options.limit}`
+        : "";
+    if (options.fileType === "csv" ||
+        fileExtension === "csv" ||
+        options.fileType === "dsv" ||
+        typeof options.delim === "string") {
+        const header = typeof options.header === "boolean"
+            ? `, header=${String(options.header).toUpperCase()}`
+            : ", header=TRUE";
+        const allText = typeof options.allText === "boolean"
+            ? `, all_varchar=${String(options.allText).toUpperCase()}`
+            : "";
+        const delim = options.delim ? `, delim='${options.delim}'` : "";
+        const skip = options.skip ? `, skip=${options.skip}` : "";
+        const ignoreErrors = options.ignoreErrors
+            ? `, ignore_errors	=${options.ignoreErrors}`
+            : "";
+        const nullPadding = options.nullPadding
+            ? `, null_padding=${options.nullPadding}`
+            : "";
+        const compression = options.compression
+            ? `, compression=${options.compression}`
+            : "";
+        const encoding = options.encoding ? `, encoding='${options.encoding}'` : "";
+        const strict = options.strict === false ? `, strict_mode=FALSE` : "";
+        return `CREATE OR REPLACE TABLE "${table}"
+            AS SELECT * FROM read_csv_auto(${filesAsString}${generalOptions}${header}${allText}${delim}${skip}${compression}${encoding}${strict}${nullPadding}${ignoreErrors})${limit};`;
+    }
+    else if (options.fileType === "json" || fileExtension === "json") {
+        const jsonFormat = options.jsonFormat
+            ? `, format='${options.jsonFormat}'`
+            : "";
+        const records = typeof options.records === "boolean"
+            ? `, records=${String(options.records).toUpperCase()}`
+            : "";
+        return `CREATE OR REPLACE TABLE "${table}"
+            AS SELECT * FROM read_json_auto(${filesAsString}${generalOptions}${jsonFormat}${records})${limit};`;
+    }
+    else if (options.fileType === "parquet" || fileExtension === "parquet") {
+        return `CREATE OR REPLACE TABLE "${table}" AS SELECT * FROM read_parquet(${filesAsString}${fileName}${unifyColumns})${limit};`;
+    }
+    else if (options.fileType === "excel" || fileExtension === "xlsx") {
+        if (files.length > 1) {
+            throw new Error("For excel files or files with extension .xlsx, you can pass only one file at the time.");
+        }
+        const header = typeof options.header === "boolean"
+            ? `, header=${String(options.header).toUpperCase()}`
+            : ", header=TRUE";
+        const allText = typeof options.allText === "boolean"
+            ? `, all_varchar=${String(options.allText).toUpperCase()}`
+            : "";
+        return `CREATE OR REPLACE TABLE "${table}" AS SELECT * FROM read_xlsx('${files[0]}'${options.sheet ? `, sheet='${options.sheet}'` : ""}${header}${allText});`;
+    }
+    else {
+        throw new Error(`Unknown options.fileType ${options.fileType} or fileExtension ${fileExtension}`);
+    }
+}

package/esm/methods/lowerQuery.d.ts

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

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

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

package/esm/methods/lowerQuery.js

@@ -0,0 +1,7 @@
+export default function lowerQuery(table, columns) {
+    let query = "";
+    for (const column of columns) {
+        query += `\nUPDATE "${table}" SET "${column}" = LOWER("${column}");`;
+    }
+    return query;
+}

package/esm/methods/normalizeQuery.d.ts

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

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

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

@@ -0,0 +1,22 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function normalizeQuery(table, column, newColumn, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories)
+        : [];
+    const partition = categories.length > 0
+        ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`
+        : "";
+    const tempQuery = `("${column}" - MIN("${column}") OVER(${partition}))
+    /
+    (MAX("${column}") OVER(${partition}) - MIN("${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/esm/methods/normalizeString.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeString.d.ts","sourceRoot":"","sources":["../../src/methods/normalizeString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,eAAe,CAC3C,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/esm/methods/normalizeString.js

@@ -0,0 +1,26 @@
+import queryDB from "../helpers/queryDB.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+export default async function normalizeString(simpleTable, column, newColumn, options = {}) {
+    const { stripPunctuation = true } = options;
+    const accentRemoved = `strip_accents("${column}")`;
+    const lowercased = `lower(${accentRemoved})`;
+    const punctuationRemoved = stripPunctuation
+        ? `regexp_replace(${lowercased}, '[[:punct:]]', '', 'g')`
+        : lowercased;
+    const normalizedClause = `trim(regexp_replace(${punctuationRemoved}, '\\s+', ' ', 'g'))`;
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS 
+    SELECT *,
+      CASE 
+        WHEN "${column}" IS NULL THEN NULL
+        ELSE ${normalizedClause}
+      END AS "${newColumn}"
+    FROM "${simpleTable.name}"`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "normalizeString()",
+        parameters: {
+            column,
+            newColumn,
+            stripPunctuation,
+        },
+    }));
+}

package/esm/methods/outliersIQRQuery.d.ts

@@ -0,0 +1,4 @@
+export default function outliersIQRQuery(table: string, column: string, newColumn: string, parity: "even" | "odd", options?: {
+    categories?: string | string[];
+}): string;
+//# sourceMappingURL=outliersIQRQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outliersIQRQuery.d.ts","sourceRoot":"","sources":["../../src/methods/outliersIQRQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACtC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,KAAK,EACtB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B,UAoCP"}

package/esm/methods/outliersIQRQuery.js

@@ -0,0 +1,31 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function outliersIQRQuery(table, column, newColumn, parity, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories).map((d) => `"${d}"`)
+        : [];
+    const quantileFunc = parity === "even" ? "quantile_disc" : "quantile_cont";
+    const where = categories.length > 0
+        ? `WHERE ${categories
+            .map((d) => `"${table}".${d} = "iqr".${d}`)
+            .join(" AND ")}`
+        : "";
+    const query = `ALTER TABLE "${table}"
+    ADD COLUMN "${newColumn}" BOOLEAN;
+    WITH "iqr" AS (
+        SELECT${categories.length > 0 ? `\n${categories.join(", ")},` : ""}
+            ${quantileFunc}("${column}", 0.25) as "q1",
+            ${quantileFunc}("${column}", 0.75) as "q3",
+            ("q3"-"q1")*1.5 as "range",
+            "q1"-"range" as "lowThreshold",
+            "q3"+"range" as "highThreshold"
+        FROM "${table}"
+        ${categories.length > 0 ? `GROUP BY ${categories.join(", ")}` : ""}
+    )
+    UPDATE "${table}"
+    SET "${newColumn}" = CASE
+        WHEN "${column}" > (SELECT "highThreshold" FROM "iqr" ${where}) OR "${column}" < (SELECT "lowThreshold" FROM "iqr" ${where}) THEN TRUE
+        ELSE FALSE
+    END;
+    `;
+    return query;
+}

package/esm/methods/proportionsHorizontalQuery.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"proportionsHorizontalQuery.d.ts","sourceRoot":"","sources":["../../src/methods/proportionsHorizontalQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAChD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,UAmBP"}

package/esm/methods/proportionsHorizontalQuery.js

@@ -0,0 +1,15 @@
+export default function proportionsHorizontalQuery(table, columns, options = {}) {
+    let query = `CREATE OR REPLACE TABLE "${table}" AS SELECT *,`;
+    for (const col of columns) {
+        const tempQuery = `"${col}" / (${columns.map((d) => `"${d}"`).join(" + ")})`;
+        if (typeof options.decimals === "number") {
+            query += ` ROUND(${tempQuery}, ${options.decimals})`;
+        }
+        else {
+            query += ` ${tempQuery}`;
+        }
+        query += ` AS "${col}${options.suffix ?? "Perc"}",`;
+    }
+    query += `FROM "${table}"`;
+    return query;
+}

package/esm/methods/proportionsVerticalQuery.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"proportionsVerticalQuery.d.ts","sourceRoot":"","sources":["../../src/methods/proportionsVerticalQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,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,UAoBP"}

package/esm/methods/proportionsVerticalQuery.js

@@ -0,0 +1,19 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function proportionsVerticalQuery(table, column, newColumn, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories)
+        : [];
+    const partition = categories.length === 0
+        ? ""
+        : `PARTITION BY ${categories.map((d) => `"${d}"`).join(",")}`;
+    let query = "";
+    if (typeof options.decimals === "number") {
+        query =
+            `CREATE OR REPLACE TABLE "${table}" AS SELECT *, ROUND("${column}" / sum("${column}") OVER(${partition}), ${options.decimals}) AS "${newColumn}" FROM "${table}"`;
+    }
+    else {
+        query =
+            `CREATE OR REPLACE TABLE "${table}" AS SELECT *, "${column}" / sum("${column}") OVER(${partition}) AS "${newColumn}" FROM "${table}"`;
+    }
+    return query;
+}

package/esm/methods/quantilesQuery.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"quantilesQuery.d.ts","sourceRoot":"","sources":["../../src/methods/quantilesQuery.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B,UAeP"}

package/esm/methods/quantilesQuery.js

@@ -0,0 +1,12 @@
+import stringToArray from "../helpers/stringToArray.js";
+export default function quantilesQuery(table, values, nbQuantiles, 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 *, ntile(${nbQuantiles}) OVER (${partition}ORDER BY "${values}") AS "${newColumn}"
+    FROM "${table}"`;
+    return query;
+}

package/esm/methods/ranksQuery.d.ts

@@ -0,0 +1,6 @@
+export default function rankQuery(table: string, values: string, newColumn: string, options?: {
+    order?: "asc" | "desc";
+    categories?: string | string[];
+    noGaps?: boolean;
+}): string;
+//# sourceMappingURL=ranksQuery.d.ts.map