@nshiab/simple-data-analysis-core 0.0.12

package/esm/methods/fill.js

@@ -0,0 +1,60 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import stringToArray from "../helpers/stringToArray.js";
+export default async function fill(simpleTable, columns, options = {}) {
+    const categories = options.categories
+        ? stringToArray(options.categories)
+        : [];
+    const tempRowCol = `rowNumberForFill`;
+    if (options.interpolateBy && options.interpolate === false) {
+        throw new Error(`interpolate cannot be false when interpolateBy is set.`);
+    }
+    if (options.interpolate || options.interpolateBy) {
+        const cols = stringToArray(columns);
+        let orderCol;
+        let excludeList;
+        if (options.interpolateBy) {
+            orderCol = options.interpolateBy;
+            excludeList = cols.join(", ");
+        }
+        else {
+            await simpleTable.addRowNumber(tempRowCol);
+            orderCol = tempRowCol;
+            excludeList = [`"${tempRowCol}"`, ...cols].join(", ");
+        }
+        const overClause = categories.length > 0
+            ? `(PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")})`
+            : `()`;
+        const selectList = cols
+            .map((col) => `fill(${col} ORDER BY "${orderCol}") OVER ${overClause} as ${col}`)
+            .join(", ");
+        await queryDB(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM "${simpleTable.name}" ORDER BY "${orderCol}";`, mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            method: "fill()",
+            parameters: { columns, ...options },
+        }));
+    }
+    else if (categories.length > 0) {
+        const partition = `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`;
+        await simpleTable.addRowNumber(tempRowCol);
+        const cols = stringToArray(columns);
+        const excludeList = [`"${tempRowCol}"`, ...cols].join(", ");
+        const selectList = cols
+            .map((col) => `COALESCE(${col}, LAG(${col} IGNORE NULLS) OVER(${partition} ORDER BY "${tempRowCol}")) as ${col}`)
+            .join(", ");
+        await queryDB(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM "${simpleTable.name}" ORDER BY "${tempRowCol}";`, mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            method: "fill()",
+            parameters: { columns, ...options },
+        }));
+    }
+    else {
+        await queryDB(simpleTable, stringToArray(columns)
+            .map((col) => `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${col}), COALESCE(${col}, LAG(${col} IGNORE NULLS) OVER()) as ${col} FROM "${simpleTable.name}";`)
+            .join("\n"), mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            method: "fill()",
+            parameters: { columns, ...options },
+        }));
+    }
+}

package/esm/methods/fuzzyClean.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fuzzyClean(table: SimpleTable, column: string, newColumn: string, options?: {
+    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
+    threshold?: number;
+    keep?: "mostCommon" | "longestString" | "shortestString" | "mostCentral" | "maxScore";
+}): Promise<void>;
+//# sourceMappingURL=fuzzyClean.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyClean.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyClean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,UAAU,CACtC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EACD,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,UAAU,CAAC;CACX,GACL,OAAO,CAAC,IAAI,CAAC,CAyNf"}

package/esm/methods/fuzzyClean.js

@@ -0,0 +1,194 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function fuzzyClean(table, column, newColumn, options = {}) {
+    const method = options.method ?? "ratio";
+    const threshold = options.threshold ?? 80;
+    const keep = options.keep ?? "mostCommon";
+    // Single round trip: compute fuzzy pairs and embed counts for both sides.
+    // Only values that appear in at least one pair above the threshold can be
+    // normalized — singletons need no processing at all.
+    const pairsData = await queryDB(table, `INSTALL rapidfuzz FROM community; LOAD rapidfuzz;
+     WITH uniques AS (
+       SELECT "${column}" AS value, COUNT(*) AS cnt
+       FROM "${table.name}"
+       WHERE "${column}" IS NOT NULL
+       GROUP BY "${column}"
+     )
+     SELECT
+       a.value AS left_value,
+       b.value AS right_value,
+       a.cnt   AS left_cnt,
+       b.cnt   AS right_cnt,
+       rapidfuzz_${method}(a.value, b.value) AS score
+     FROM uniques a
+     JOIN uniques b
+       ON rapidfuzz_${method}(a.value, b.value) >= ${threshold}
+       AND a.value < b.value`, mergeOptions(table, {
+        table: table.name,
+        method: "fuzzyClean()",
+        parameters: { column, newColumn, options },
+        returnDataFrom: "query",
+    }));
+    const pairs = pairsData ?? [];
+    if (pairs.length === 0)
+        return; // Nothing to normalize.
+    // Build count map from the pairs — no separate query needed.
+    const countMap = new Map();
+    for (const { left_value, left_cnt, right_value, right_cnt } of pairs) {
+        countMap.set(left_value, Number(left_cnt));
+        countMap.set(right_value, Number(right_cnt));
+    }
+    // Union-Find — only over values that actually participate in a pair.
+    const parent = new Map();
+    const find = (x) => {
+        if (!parent.has(x))
+            parent.set(x, x);
+        if (parent.get(x) !== x)
+            parent.set(x, find(parent.get(x)));
+        return parent.get(x);
+    };
+    const union = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(ra, rb);
+    };
+    for (const v of countMap.keys())
+        find(v);
+    for (const { left_value, right_value } of pairs) {
+        union(left_value, right_value);
+    }
+    // Group values by their cluster root.
+    const clusters = new Map();
+    for (const v of countMap.keys()) {
+        const root = find(v);
+        if (!clusters.has(root))
+            clusters.set(root, []);
+        clusters.get(root).push(v);
+    }
+    // Pick the canonical value for each cluster.
+    const replacement = new Map();
+    for (const members of clusters.values()) {
+        if (members.length === 1)
+            continue; // All pairs are already canonical — skip.
+        // Score sums and per-member max scores are computed lazily — only when
+        // actually needed as a primary criterion or tie-breaker.
+        //
+        // scoreSum: total similarity to all other cluster members (used by
+        //   "mostCentral" as primary, and as tie-breaker for all strategies).
+        // scoreMax: highest single pairwise score (used by "maxScore" as primary).
+        let scoreSum = null;
+        const getScoreSum = () => {
+            if (scoreSum === null) {
+                scoreSum = new Map(members.map((m) => [m, 0]));
+                for (const { left_value, right_value, score } of pairs) {
+                    if (scoreSum.has(left_value) && scoreSum.has(right_value)) {
+                        scoreSum.set(left_value, (scoreSum.get(left_value) ?? 0) + score);
+                        scoreSum.set(right_value, (scoreSum.get(right_value) ?? 0) + score);
+                    }
+                }
+            }
+            return scoreSum;
+        };
+        let scoreMax = null;
+        const getScoreMax = () => {
+            if (scoreMax === null) {
+                scoreMax = new Map(members.map((m) => [m, 0]));
+                for (const { left_value, right_value, score } of pairs) {
+                    if (scoreMax.has(left_value) && scoreMax.has(right_value)) {
+                        scoreMax.set(left_value, Math.max(scoreMax.get(left_value) ?? 0, score));
+                        scoreMax.set(right_value, Math.max(scoreMax.get(right_value) ?? 0, score));
+                    }
+                }
+            }
+            return scoreMax;
+        };
+        // Sum-based comparator: highest total similarity, then alphabetical.
+        const byScore = (a, b) => {
+            const sum = getScoreSum();
+            const sa = sum.get(a) ?? 0;
+            const sb = sum.get(b) ?? 0;
+            if (sa !== sb)
+                return sa > sb ? a : b;
+            return a <= b ? a : b; // alphabetical tie-break
+        };
+        // Max-based comparator: highest single-pair score, then sum, then alphabetical.
+        const byMaxScore = (a, b) => {
+            const mx = getScoreMax();
+            const ma = mx.get(a) ?? 0;
+            const mb = mx.get(b) ?? 0;
+            if (ma !== mb)
+                return ma > mb ? a : b;
+            return byScore(a, b); // sum then alphabetical tie-break
+        };
+        let canonical;
+        if (keep === "longestString") {
+            canonical = members.reduce((a, b) => {
+                if (a.length !== b.length)
+                    return a.length > b.length ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (keep === "shortestString") {
+            canonical = members.reduce((a, b) => {
+                if (a.length !== b.length)
+                    return a.length < b.length ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (keep === "mostCommon") {
+            canonical = members.reduce((a, b) => {
+                const ca = countMap.get(a) ?? 0;
+                const cb = countMap.get(b) ?? 0;
+                if (ca !== cb)
+                    return ca > cb ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (keep === "mostCentral") {
+            // Most central string — highest total similarity to all other cluster members.
+            canonical = members.reduce((a, b) => byScore(a, b));
+        }
+        else {
+            // "maxScore": the string participating in the single highest-scoring pair.
+            canonical = members.reduce((a, b) => byMaxScore(a, b));
+        }
+        for (const m of members) {
+            if (m !== canonical)
+                replacement.set(m, canonical);
+        }
+    }
+    if (replacement.size === 0)
+        return;
+    // Use a VALUES-based CTE for the UPDATE so DuckDB can use a hash join
+    // instead of evaluating a potentially huge CASE WHEN expression.
+    const escape = (s) => s.replace(/'/g, "''");
+    const valuesList = [...replacement.entries()]
+        .map(([from, to]) => `('${escape(from)}', '${escape(to)}')`)
+        .join(",\n     ");
+    if (newColumn !== column) {
+        await queryDB(table, `ALTER TABLE "${table.name}" ADD "${newColumn}" VARCHAR;
+       UPDATE "${table.name}"
+         SET "${newColumn}" = "${column}";
+       WITH mapping(original, canonical) AS (VALUES ${valuesList})
+       UPDATE "${table.name}"
+         SET "${newColumn}" = m.canonical
+         FROM mapping m
+         WHERE "${table.name}"."${newColumn}" = m.original`, mergeOptions(table, {
+            table: table.name,
+            method: "fuzzyClean()",
+            parameters: { column, newColumn, options },
+        }));
+    }
+    else {
+        await queryDB(table, `WITH mapping(original, canonical) AS (VALUES ${valuesList})
+       UPDATE "${table.name}"
+         SET "${column}" = m.canonical
+         FROM mapping m
+         WHERE "${table.name}"."${column}" = m.original`, mergeOptions(table, {
+            table: table.name,
+            method: "fuzzyClean()",
+            parameters: { column, newColumn, options },
+        }));
+    }
+}

package/esm/methods/fuzzyJoin.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fuzzyJoin(leftTable: SimpleTable, rightTable: SimpleTable, leftColumn: string, rightColumn: string, options?: {
+    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
+    threshold?: number;
+    similarityColumn?: string;
+    outputTable?: string | boolean;
+}): Promise<SimpleTable>;
+//# sourceMappingURL=fuzzyJoin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyJoin.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyJoin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,wBAA8B,SAAS,CACrC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,wBAuFP"}

package/esm/methods/fuzzyJoin.js

@@ -0,0 +1,57 @@
+import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import fuzzyJoinQuery from "./fuzzyJoinQuery.js";
+export default async function fuzzyJoin(leftTable, rightTable, leftColumn, rightColumn, options = {}) {
+    if (leftColumn === rightColumn) {
+        throw new Error(`The leftColumn and rightColumn have the same name "${leftColumn}". Rename one of them before doing the fuzzy join.`);
+    }
+    const leftCols = await leftTable.getColumns();
+    const rightCols = await rightTable.getColumns();
+    const identicalColumns = getIdenticalColumns(leftCols, rightCols);
+    // Any column shared between both tables — other than rightColumn (whose
+    // potential _1 duplicate we clean up) — would produce ambiguous output.
+    const identicalColumnsForError = identicalColumns.filter((d) => d !== rightColumn);
+    if (identicalColumnsForError.length > 0) {
+        if (identicalColumnsForError.length === 1) {
+            throw new Error(`The tables have columns with identical names. Rename or remove "${identicalColumnsForError[0]}" in one of the two tables before doing the fuzzy join.`);
+        }
+        else {
+            throw new Error(`The tables have columns with identical names. Rename or remove ${identicalColumnsForError.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the fuzzy join.`);
+        }
+    }
+    const method = options.method ?? "ratio";
+    const threshold = options.threshold ?? 80;
+    const similarityColumn = options.similarityColumn;
+    const outputTableName = typeof options.outputTable === "string"
+        ? options.outputTable
+        : leftTable.name;
+    const sql = `INSTALL rapidfuzz FROM community; LOAD rapidfuzz;\n` +
+        fuzzyJoinQuery(leftTable.name, leftColumn, rightTable.name, rightColumn, method, threshold, outputTableName, similarityColumn);
+    await queryDB(leftTable, sql, mergeOptions(leftTable, {
+        table: outputTableName,
+        method: "fuzzyJoin()",
+        parameters: {
+            leftColumn,
+            rightColumn,
+            rightTable: rightTable.name,
+            options,
+        },
+    }));
+    const allProjections = {
+        ...leftTable.projections,
+        ...rightTable.projections,
+    };
+    const outputTable = typeof options.outputTable === "string"
+        ? leftTable.sdb.newTable(options.outputTable, allProjections)
+        : leftTable;
+    outputTable.projections = allProjections;
+    // Remove the duplicate right-column produced when leftColumn === rightColumn
+    // (DuckDB suffixes it with _1 in SELECT *)
+    const outputCols = await outputTable.getColumns();
+    const duplicateCol = `${rightColumn}_1`;
+    if (outputCols.includes(duplicateCol)) {
+        await outputTable.removeColumns([duplicateCol]);
+    }
+    return outputTable;
+}

package/esm/methods/fuzzyJoinQuery.d.ts

@@ -0,0 +1,2 @@
+export default function fuzzyJoinQuery(leftTable: string, leftColumn: string, rightTable: string, rightColumn: string, method: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio", threshold: number, outputTable: string, similarityColumn: string | undefined): string;
+//# sourceMappingURL=fuzzyJoinQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyJoinQuery.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyJoinQuery.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,MAAM,EACF,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,EACrB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GAAG,SAAS,UAsBrC"}

package/esm/methods/fuzzyJoinQuery.js

@@ -0,0 +1,19 @@
+export default function fuzzyJoinQuery(leftTable, leftColumn, rightTable, rightColumn, method, threshold, outputTable, similarityColumn) {
+    const fn = `ROUND(rapidfuzz_${method}("${leftTable}"."${leftColumn}", "${rightTable}"."${rightColumn}"), 2)`;
+    if (similarityColumn) {
+        return `CREATE OR REPLACE TABLE "${outputTable}" AS
+SELECT * EXCLUDE ("_sda_score"), "_sda_score" AS "${similarityColumn}"
+FROM (
+  SELECT "${leftTable}".*, "${rightTable}".*, ${fn} AS "_sda_score"
+  FROM "${leftTable}" LEFT JOIN "${rightTable}" ON ${fn} >= ${threshold}
+) _sda
+ORDER BY "${leftColumn}", "_sda_score" DESC;\n`;
+    }
+    return `CREATE OR REPLACE TABLE "${outputTable}" AS
+SELECT *
+FROM (
+  SELECT "${leftTable}".*, "${rightTable}".*
+  FROM "${leftTable}" LEFT JOIN "${rightTable}" ON ${fn} >= ${threshold}
+) _sda
+ORDER BY "${leftColumn}", "${rightColumn}";\n`;
+}

package/esm/methods/getBottom.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getBottom(simpleTable: SimpleTable, count: number, options?: {
+    originalOrder?: boolean;
+    conditions?: string;
+}): Promise<{
+    [key: string]: string | number | boolean | Date | null;
+}[]>;
+//# sourceMappingURL=getBottom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getBottom.d.ts","sourceRoot":"","sources":["../../src/methods/getBottom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB;;KA6BP"}

package/esm/methods/getBottom.js

@@ -0,0 +1,22 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getBottom(simpleTable, count, options = {}) {
+    const queryResult = await queryDB(simpleTable, `WITH "numberedRowsForGetBottom" AS (
+                SELECT *, row_number() OVER () as "rowNumberForGetBottom" FROM "${simpleTable.name}"${options.conditions ? ` WHERE ${options.conditions}` : ""}
+            )
+            SELECT * FROM "numberedRowsForGetBottom" ORDER BY "rowNumberForGetBottom" DESC LIMIT ${count};`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnDataFrom: "query",
+        method: "getBottom()",
+        parameters: { count, options },
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResult");
+    }
+    const rowsRaw = queryResult.map((d) => {
+        delete d.rowNumberForGetBottom;
+        return d;
+    });
+    const rows = options.originalOrder ? rowsRaw.reverse() : rowsRaw;
+    return rows;
+}

package/esm/methods/getColumns.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getColumns(simpleTable: SimpleTable): Promise<string[]>;
+//# sourceMappingURL=getColumns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getColumns.d.ts","sourceRoot":"","sources":["../../src/methods/getColumns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,UAAU,CAAC,WAAW,EAAE,WAAW,qBAmBhE"}

package/esm/methods/getColumns.js

@@ -0,0 +1,15 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getColumns(simpleTable) {
+    const queryResult = await queryDB(simpleTable, `DESCRIBE ${simpleTable.name}`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnDataFrom: "query",
+        method: "getColumns()",
+        parameters: {},
+    }));
+    if (!queryResult) {
+        throw new Error("No result");
+    }
+    const columns = queryResult.map((d) => d.column_name);
+    return columns;
+}

package/esm/methods/getDescription.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getDescription(simpleTable: SimpleTable): Promise<{
+    column: string;
+    type: string;
+    count: number;
+    unique: number;
+    null: number;
+}[]>;
+//# sourceMappingURL=getDescription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDescription.d.ts","sourceRoot":"","sources":["../../src/methods/getDescription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,cAAc,CAAC,WAAW,EAAE,WAAW;YAc3C,MAAM;;WAEP,MAAM;YACC,MAAM;UACV,MAAM;KAIjC"}

package/esm/methods/getDescription.js

@@ -0,0 +1,20 @@
+export default async function getDescription(simpleTable) {
+    const types = await simpleTable.getTypes();
+    const columns = await simpleTable.getColumns();
+    const summaryForGetDescription = await simpleTable.summarize({
+        values: columns,
+        summaries: ["count", "countUnique", "countNull"],
+        toMs: true,
+        outputTable: "summaryForGetDescription",
+    });
+    const summaryData = await summaryForGetDescription.getData();
+    await summaryForGetDescription.removeTable();
+    const description = summaryData.map((d) => ({
+        column: d["value"],
+        type: types[d["value"]],
+        count: d["count"],
+        unique: d["countUnique"],
+        null: d["countNull"],
+    }));
+    return description;
+}

package/esm/methods/getFirstRow.d.ts

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

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

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

package/esm/methods/getFirstRow.js

@@ -0,0 +1,15 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getFirstRow(simpleTable, options = {}) {
+    const queryResult = await queryDB(simpleTable, `SELECT * FROM "${simpleTable.name}"${options.conditions ? ` WHERE ${options.conditions}` : ""} LIMIT 1`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnDataFrom: "query",
+        method: "getFirstRow()",
+        parameters: { options },
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResult");
+    }
+    const result = queryResult[0];
+    return result;
+}

package/esm/methods/getGeoData.d.ts

@@ -0,0 +1,17 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getGeoData(SimpleTable: SimpleTable, column: string, options?: {
+    rewind?: boolean;
+}): Promise<{
+    type: string;
+    features: {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: unknown[];
+        };
+        properties: {
+            [key: string]: string | number | boolean | Date | null;
+        };
+    }[];
+}>;
+//# sourceMappingURL=getGeoData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getGeoData.d.ts","sourceRoot":"","sources":["../../src/methods/getGeoData.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,wBAA8B,UAAU,CACtC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO;;;;;kBA4BtB,MAAM;yBACC,OAAO,EAAE;;;;;;GAgC7B"}

package/esm/methods/getGeoData.js

@@ -0,0 +1,41 @@
+import rewind from "../helpers/rewind.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import shouldFlipBeforeExport from "../helpers/shouldFlipBeforeExport.js";
+export default async function getGeoData(SimpleTable, column, options = {}) {
+    let query = "";
+    if (shouldFlipBeforeExport(SimpleTable.projections[column])) {
+        query =
+            `SELECT * EXCLUDE ${column}, ST_AsGeoJSON(ST_FlipCoordinates(${column})) as geoJsonFragment from "${SimpleTable.name}";`;
+    }
+    else {
+        query =
+            `SELECT * EXCLUDE ${column}, ST_AsGeoJSON(${column}) as geoJsonFragment from "${SimpleTable.name}";`;
+    }
+    const queryResult = await queryDB(SimpleTable, query, mergeOptions(SimpleTable, {
+        table: null,
+        method: "getGeoData()",
+        parameters: { column },
+        returnDataFrom: "query",
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResults");
+    }
+    const features = queryResult.map((d) => {
+        const { geoJsonFragment, ...properties } = d;
+        const geometry = JSON.parse(geoJsonFragment);
+        const feature = {
+            type: "Feature",
+            geometry,
+            properties,
+        };
+        return feature;
+    });
+    const geoJSON = {
+        type: "FeatureCollection",
+        features,
+    };
+    return options.rewind
+        ? rewind(geoJSON)
+        : geoJSON;
+}

package/esm/methods/getLastRow.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLastRow.d.ts","sourceRoot":"","sources":["../../src/methods/getLastRow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,UAAU,CACtC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB;;GAwBP"}

package/esm/methods/getLastRow.js

@@ -0,0 +1,19 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getLastRow(simpleTable, options = {}) {
+    const queryResult = await queryDB(simpleTable, `WITH "numberedRowsForGetLastRow" AS (
+                SELECT *, row_number() OVER () as "rowNumberForGetLastRow" FROM "${simpleTable.name}"${options.conditions ? ` WHERE ${options.conditions}` : ""}
+            )
+            SELECT * FROM "numberedRowsForGetLastRow" ORDER BY "rowNumberForGetLastRow" DESC LIMIT 1;`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnDataFrom: "query",
+        method: "getLastRow()",
+        parameters: { options },
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResult");
+    }
+    const result = queryResult[0];
+    delete result.rowNumberForGetLastRow;
+    return result;
+}

package/esm/methods/getMax.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getMax(simpleTable: SimpleTable, column: string): Promise<string | number | boolean | Date | null>;
+//# sourceMappingURL=getMax.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMax.d.ts","sourceRoot":"","sources":["../../src/methods/getMax.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,MAAM,CAClC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,oDAuBf"}

package/esm/methods/getMax.js

@@ -0,0 +1,18 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getMax(simpleTable, column) {
+    const queryResult = await queryDB(simpleTable, `SELECT MAX("${column}") AS "${column}" FROM "${simpleTable.name}"`, {
+        ...mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            returnDataFrom: "query",
+            method: "getMax()",
+            parameters: { column },
+        }),
+        types: await simpleTable.getTypes(),
+    });
+    if (!queryResult) {
+        throw new Error("No queryResults");
+    }
+    const result = queryResult[0][column];
+    return result;
+}

package/esm/methods/getMean.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMean.d.ts","sourceRoot":"","sources":["../../src/methods/getMean.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,OAAO,CACnC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,mBAsBP"}

package/esm/methods/getMean.js

@@ -0,0 +1,17 @@
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getMean(simpleTable, column, options = {}) {
+    const queryResult = await queryDB(simpleTable, typeof options.decimals === "number"
+        ? `SELECT ROUND(AVG("${column}"), ${options.decimals}) AS "${column}" FROM "${simpleTable.name}"`
+        : `SELECT AVG("${column}") AS "${column}" FROM "${simpleTable.name}"`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnDataFrom: "query",
+        method: "getMean()",
+        parameters: { column, options },
+    }));
+    if (!queryResult) {
+        throw new Error("No queryResults");
+    }
+    const result = queryResult[0][column];
+    return result;
+}