@nshiab/simple-data-analysis-core 0.0.26 → 0.1.0

package/esm/class/SimpleTable.js

@@ -62,7 +62,6 @@ import summarize from "../methods/summarize.js";
 import correlations from "../methods/correlations.js";
 import linearRegressions from "../methods/linearRegressions.js";
 import joinGeo from "../methods/joinGeo.js";
-import getProjection from "../helpers/getProjection.js";
 import cache from "../methods/cache.js";
 import camelCase from "../helpers/camelCase.js";
 import formatNumber from "../helpers/formatNumber.js";
@@ -85,7 +84,6 @@ import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
 import capitalizeQuery from "../methods/capitalizeQuery.js";
 import truncateQuery from "../methods/truncateQuery.js";
 import padQuery from "../methods/padQuery.js";
-import getProjectionParquet from "../helpers/getProjectionParquet.js";
 import hasGeometryColumn from "../helpers/hasGeometryColumn.js";
 import unifyColumns from "../helpers/unifyColumns.js";
 import accumulateQuery from "../helpers/accumulateQuery.js";
@@ -147,7 +145,6 @@ export default class SimpleTable extends Simple {
      * Creates an instance of SimpleTable.
      *
      * @param name - The name of the table.
-     * @param projections - An object mapping column names to their geospatial projections.
      * @param simpleDB - The SimpleDB instance that this table belongs to.
      * @param options - An optional object with configuration options:
      * @param options.debug - A boolean indicating whether to enable debug mode.
@@ -156,7 +153,7 @@ export default class SimpleTable extends Simple {
      * @param options.types - A boolean indicating whether to include data types when logging a table.
      * @category Constructor
      */
-    constructor(name, projections, simpleDB, options = {}) {
+    constructor(name, simpleDB, options = {}) {
         super(options);
         /**
          * Name of the table in the database.
@@ -170,19 +167,7 @@ export default class SimpleTable extends Simple {
             value: void 0
         });
         /**
-         * The projections of the geospatial data, if any.
-         *
-         * @defaultValue `{}`
-         * @category Properties
-         */
-        Object.defineProperty(this, "projections", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * The indexes of the table.
+         * The indexes of the table, if any.
          *
          * @defaultValue `[]`
          * @category Properties
@@ -194,7 +179,6 @@ export default class SimpleTable extends Simple {
             value: void 0
         });
         this.name = name;
-        this.projections = projections;
         this.sdb = simpleDB;
         this.runQuery = runQuery;
         this.indexes = [];
@@ -242,8 +226,9 @@ export default class SimpleTable extends Simple {
         let spatial = "";
         if (Object.values(types)
             .map((d) => d.toLowerCase())
-            .includes("geometry")) {
-            spatial = "INSTALL spatial; LOAD spatial;\n";
+            .some((d) => d.startsWith("geometry"))) {
+            spatial =
+                "INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;\n";
         }
         await queryDB(this, `${spatial}CREATE OR REPLACE TABLE "${this.name}" (${Object.keys(types)
             .map((d) => `"${d}" ${parseType(types[d])}`)
@@ -398,12 +383,10 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Loads geospatial data from an external file or URL into the table.
-     * The coordinates of files or URLs ending with `.json` or `.geojson` are automatically flipped to `[latitude, longitude]` axis order.
      *
      * @param file - The URL or absolute path to the external file containing the geospatial data.
      * @param options - An optional object with configuration options:
-     * @param options.toWGS84 - If `true`, the method will attempt to reproject the data to WGS84 with `[latitude, longitude]` axis order. If the file is `.json` or `.geojson`, coordinates are automatically flipped, and this option has no additional effect. Defaults to `false`.
-     * @param options.from - An optional string specifying the original projection of the data, if the method is unable to detect it automatically.
+     * @param options.toWGS84 - If `true`, the method will attempt to reproject the data to WGS84.
      * @returns A promise that resolves to the SimpleTable instance after the geospatial data has been loaded.
      * @category Geospatial
      *
@@ -434,7 +417,7 @@ export default class SimpleTable extends Simple {
     async loadGeoData(file, options = {}) {
         const fileExtension = getExtension(file);
         if (fileExtension === "geoparquet" || fileExtension === "parquet") {
-            await queryDB(this, `INSTALL spatial; LOAD spatial;${file.toLowerCase().includes("http")
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;${file.toLowerCase().includes("http")
                 ? " INSTALL https; LOAD https;"
                 : ""}
               CREATE OR REPLACE TABLE "${this.name}" AS SELECT * FROM read_parquet('${cleanPath(file)}');`, mergeOptions(this, {
@@ -442,32 +425,21 @@ export default class SimpleTable extends Simple {
                 method: "loadGeoData()",
                 parameters: { file, options },
             }));
-            this.projections = await getProjectionParquet(this, file);
-            if (options.toWGS84) {
-                console.log("\nThis file is a parquet. Option toWGS84 has no effect. Use the .reproject() method instead.\n");
-            }
         }
         else {
-            await queryDB(this, `INSTALL spatial; LOAD spatial;${file.toLowerCase().includes("http")
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;${file.toLowerCase().includes("http")
                 ? " INSTALL https; LOAD https;"
                 : ""}
-              CREATE OR REPLACE TABLE "${this.name}" AS SELECT * FROM ST_Read('${file}');`, mergeOptions(this, {
+              CREATE OR REPLACE TABLE "${this.name}" AS SELECT * EXCLUDE OGC_FID FROM ST_Read('${file}');`, mergeOptions(this, {
                 table: this.name,
                 method: "loadGeoData()",
                 parameters: { file, options },
             }));
-            // column storing geometries is geom by default
-            this.projections["geom"] = await getProjection(this.sdb, file);
-            const extension = getExtension(file);
-            if (extension === "json" || extension === "geojson") {
-                await this.flipCoordinates("geom"); // column storing geometries
-                this.projections["geom"] = "+proj=latlong +datum=WGS84 +no_defs";
-                if (options.toWGS84) {
-                    console.log("This file is a json or geojson. Option toWGS84 has no effect.");
-                }
-            }
-            else if (options.toWGS84) {
-                await this.reproject("WGS84", { ...options, column: "geom" }); // column storing geometries is geom by default
+        }
+        if (options.toWGS84) {
+            const proj = await this.getProjection("geom");
+            if (proj !== "EPSG:4326") {
+                await this.reproject("EPSG:4326");
             }
         }
         return this;
@@ -759,9 +731,8 @@ export default class SimpleTable extends Simple {
             : [tablesToInsert];
         if (!await this.sdb.hasTable(this.name)) {
             await this.setTypes((await array[0].getTypes()));
-            this.projections = structuredClone(array[0].projections);
         }
-        // Checking columns, types and projections
+        // Checking columns, types
         if (!options.unifyColumns) {
             const thisColumns = (await this.getColumns()).sort().join(",");
             for (const table of array) {
@@ -773,27 +744,22 @@ export default class SimpleTable extends Simple {
         }
         const allTables = [this, ...array];
         const allTypes = {};
-        const allProjections = {};
         for (const table of allTables) {
             const types = await table.getTypes();
             for (const key in types) {
                 if (!allTypes[key]) {
                     allTypes[key] = types[key];
-                    allProjections[key] = table.projections[key];
                 }
                 else {
                     if (allTypes[key] !== types[key]) {
                         throw new Error(`The column ${key} has different types in the tables.`);
                     }
-                    else if (allProjections[key] !== table.projections[key]) {
-                        throw new Error(`The column ${key} has different projections in the tables.`);
-                    }
                 }
             }
         }
         let columnsAdded = {};
         if (options.unifyColumns) {
-            columnsAdded = await unifyColumns(allTables, allTypes, allProjections);
+            columnsAdded = await unifyColumns(allTables, allTypes);
         }
         await queryDB(this, array
             .map((tableToInsert) => `INSERT INTO "${this.name}" BY NAME SELECT * FROM "${tableToInsert.name}";`)
@@ -892,29 +858,16 @@ export default class SimpleTable extends Simple {
         const columns = typeof nameOrOptions === "object" && nameOrOptions.columns
             ? stringToArray(nameOrOptions.columns)
             : [];
-        // Dealing with projections
-        const clonedProjections = structuredClone(this.projections);
-        let newProjections = {};
-        if (columns.length > 0) {
-            for (const col of columns) {
-                if (clonedProjections[col]) {
-                    newProjections[col] = clonedProjections[col];
-                }
-            }
-        }
-        else {
-            newProjections = clonedProjections;
-        }
         // Delegate to sdb.newTable() so subclasses using tableClass work correctly.
         let clonedTable;
         const options = typeof nameOrOptions === "string"
             ? { outputTable: nameOrOptions }
             : nameOrOptions;
         if (typeof options.outputTable === "string") {
-            clonedTable = this.sdb.newTable(options.outputTable, newProjections);
+            clonedTable = this.sdb.newTable(options.outputTable);
         }
         else {
-            clonedTable = this.sdb.newTable(undefined, newProjections);
+            clonedTable = this.sdb.newTable(undefined);
         }
         await queryDB(this, cloneQuery(this.name, clonedTable.name, columns, options), mergeOptions(this, {
             table: clonedTable.name,
@@ -945,9 +898,6 @@ export default class SimpleTable extends Simple {
             method: "cloneColumn()",
             parameters: { originalColumn, newColumn },
         }));
-        if (typeof this.projections[originalColumn] === "string") {
-            this.projections[newColumn] = this.projections[originalColumn];
-        }
     }
     /**
      * Clones a column in the table and offsets its values by a specified number of rows.
@@ -1012,9 +962,6 @@ export default class SimpleTable extends Simple {
             method: "cloneColumnWithOffset()",
             parameters: { originalColumn, newColumn },
         }));
-        if (typeof this.projections[originalColumn] === "string") {
-            this.projections[newColumn] = this.projections[originalColumn];
-        }
     }
     /**
      * Fills `NULL` values in specified columns. By default, each `NULL` is replaced with the last non-`NULL` value from the preceding row. When `interpolate` is `true`, `NULL` values are replaced using linear interpolation (or extrapolation at the ends). Pass `interpolateBy` with a real numeric or date column name to use it as the X-axis, so that interpolated values are proportional to the actual distances between X-axis values rather than treating every row as equidistant. When `interpolateBy` is set, `interpolate` is automatically assumed `true`.
@@ -1260,7 +1207,7 @@ export default class SimpleTable extends Simple {
             parameters: { count, options },
         }));
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -1533,15 +1480,6 @@ export default class SimpleTable extends Simple {
             method: "renameColumns()",
             parameters: { names },
         }));
-        // Taking care of projections
-        const types = await this.getTypes();
-        for (let i = 0; i < newNames.length; i++) {
-            if (types[newNames[i]] === "GEOMETRY") {
-                const projection = this.projections[oldNames[i]];
-                delete this.projections[oldNames[i]];
-                this.projections[newNames[i]] = projection;
-            }
-        }
     }
     /**
      * Cleans column names by removing non-alphanumeric characters and formatting them to camel case.
@@ -1758,12 +1696,6 @@ export default class SimpleTable extends Simple {
             method: "removeColumns()",
             parameters: { columns },
         }));
-        // Taking care of projections
-        for (const col of cols) {
-            if (Object.prototype.hasOwnProperty.call(this.projections, col)) {
-                delete this.projections[col];
-            }
-        }
     }
     /**
      * Adds a new column to the table based on a specified data type (JavaScript or SQL types) and a SQL definition.
@@ -1772,7 +1704,6 @@ export default class SimpleTable extends Simple {
      * @param type - The data type for the new column. Can be a JavaScript type (e.g., `"number"`, `"string"`) or a SQL type (e.g., `"integer"`, `"varchar"`).
      * @param definition - A SQL expression defining how the values for the new column should be computed (e.g., `"column1 + column2"`, `"ST_Centroid(geom_column)"`).
      * @param options - An optional object with configuration options:
-     * @param options.projection - Required if the new column stores geometries. Specifies the geospatial projection of the new geometry column. You can reuse the projection of an existing geometry column (available in `table.projections`).
      * @returns A promise that resolves when the new column has been added.
      * @category Column Operations
      *
@@ -1785,33 +1716,28 @@ export default class SimpleTable extends Simple {
      * @example
      * ```ts
      * // Add a new geometry column 'centroid' using the centroid of an existing 'country' geometry column
-     * // The projection of the new 'centroid' column is set to be the same as 'country'.
-     * await table.addColumn("centroid", "geometry", `ST_Centroid("country")`, {
-     *   projection: table.projections.country,
-     * });
+     * await table.addColumn("centroid", "geometry('EPSG:4326')", `ST_Centroid("country")`);
      * ```
      */
-    async addColumn(newColumn, type, definition, options = {}) {
+    async addColumn(newColumn, type, definition) {
         const newType = parseType(type);
+        // let spatial = "";
+        // if (newType.toLowerCase().includes("geometry")) {
+        //   spatial = "INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;";
+        // }
         await queryDB(this, `ALTER TABLE "${this.name}" ADD "${newColumn}" ${newType};
         UPDATE "${this.name}" SET "${newColumn}" = ${definition}`, mergeOptions(this, {
             table: this.name,
             method: "addColumn()",
             parameters: { newColumn, type, definition },
         }));
-        if (newType === "GEOMETRY") {
-            if (typeof options.projection === "string") {
-                this.projections[newColumn] = options.projection;
-            }
-            else {
-                throw new Error("You are creating a new column storing geometries. You must specify a projection. See examples in documentation.");
-            }
-        }
     }
     /**
-     * Adds a new column to the table containing the row number.
+     * Adds a new column to the table containing the row number, starting at 0 (like an index).
      *
      * @param newColumn - The name of the new column that will store the row number.
+     * @param options - An optional object with configuration options:
+     * @param options.categories - A string or an array of strings representing columns to partition the data by. The row number will restart at 0 for each unique combination of values in these columns.
      * @returns A promise that resolves when the row number column has been added.
      * @category Column Operations
      *
@@ -1820,12 +1746,24 @@ export default class SimpleTable extends Simple {
      * // Add a new column named 'rowNumber' with the row number for each row
      * await table.addRowNumber("rowNumber");
      * ```
+     *
+     * @example
+     * ```ts
+     * // Add a new column named 'rowNumber' with the row number for each 'category'
+     * await table.addRowNumber("rowNumber", { categories: "category" });
+     * ```
      */
-    async addRowNumber(newColumn) {
-        await queryDB(this, `CREATE OR REPLACE TABLE "${this.name}" AS SELECT *, ROW_NUMBER() OVER() AS ${newColumn} FROM "${this.name}"`, mergeOptions(this, {
+    async addRowNumber(newColumn, options = {}) {
+        const categories = options.categories
+            ? stringToArray(options.categories)
+            : [];
+        const partition = categories.length > 0
+            ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`
+            : "";
+        await queryDB(this, `CREATE OR REPLACE TABLE "${this.name}" AS SELECT *, (ROW_NUMBER() OVER(${partition} ORDER BY rowid) - 1) AS "${newColumn}" FROM "${this.name}" ORDER BY rowid`, mergeOptions(this, {
             table: this.name,
             method: "addRowNumber()",
-            parameters: { newColumn },
+            parameters: { newColumn, options },
         }));
     }
     /**
@@ -1872,15 +1810,10 @@ export default class SimpleTable extends Simple {
             method: "crossJoin()",
             parameters: { rightTable, options },
         }));
-        const allProjections = {
-            ...this.projections,
-            ...rightTable.projections,
-        };
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, allProjections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
-            this.projections = allProjections;
             return this;
         }
     }
@@ -3015,7 +2948,7 @@ export default class SimpleTable extends Simple {
         }
         await summarize(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3157,7 +3090,7 @@ export default class SimpleTable extends Simple {
         }
         await correlations(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3214,7 +3147,7 @@ export default class SimpleTable extends Simple {
         }
         await linearRegressions(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3512,6 +3445,8 @@ export default class SimpleTable extends Simple {
     /**
      * Returns the number of rows in the table.
      *
+     * @param options - An optional object with configuration options:
+     * @param options.conditions - The filtering conditions specified as a SQL `WHERE` clause (e.g., `"category = 'Book'"`).
      * @returns A promise that resolves to a number representing the total count of rows.
      * @category Getting Data
      *
@@ -3521,9 +3456,16 @@ export default class SimpleTable extends Simple {
      * const nbRows = await table.getNbRows();
      * console.log(nbRows); // e.g., 100
      * ```
+     *
+     * @example
+     * ```ts
+     * // Get the number of rows where 'category' is 'Book'
+     * const nbBooks = await table.getNbRows({ conditions: "category = 'Book'" });
+     * console.log(nbBooks);
+     * ```
      */
-    async getNbRows() {
-        return await getNbRows(this);
+    async getNbRows(options = {}) {
+        return await getNbRows(this, options);
     }
     /**
      * Returns the total number of values in the table (number of columns multiplied by the number of rows).
@@ -4060,7 +4002,7 @@ export default class SimpleTable extends Simple {
     }
     // GEOSPATIAL
     /**
-     * Creates point geometries from longitude and latitude columns. The geometries will have `[latitude, longitude]` axis order.
+     * Creates point geometries from latitude and longitude columns.
      *
      * @param columnLat - The name of the column storing the latitude values.
      * @param columnLon - The name of the column storing the longitude values.
@@ -4076,13 +4018,12 @@ export default class SimpleTable extends Simple {
      */
     async points(columnLat, columnLon, newColumn) {
         await queryDB(this, (await this.getColumns()).includes(newColumn)
-            ? `INSTALL spatial; LOAD spatial; UPDATE "${this.name}" SET "${newColumn}" = ST_Point2D("${columnLat}", "${columnLon}")`
-            : `INSTALL spatial; LOAD spatial; ALTER TABLE "${this.name}" ADD COLUMN "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Point2D("${columnLat}", "${columnLon}")`, mergeOptions(this, {
+            ? `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; UPDATE "${this.name}" SET "${newColumn}" = ST_Point2D("${columnLon}", "${columnLat}")`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD COLUMN "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Point2D("${columnLon}", "${columnLat}")`, mergeOptions(this, {
             table: this.name,
             method: "points()",
             parameters: { columnLat, columnLon, newColumn },
         }));
-        this.projections[newColumn] = "+proj=latlong +datum=WGS84 +no_defs";
     }
     /**
      * Adds a column with boolean values indicating the validity of geometries.
@@ -4239,7 +4180,7 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Flips the coordinate order of geometries in a specified column (e.g., from `[lon, lat]` to `[lat, lon]` or vice-versa).
-     * **Warning:** This method should be used with caution as it directly manipulates coordinate order and can affect the accuracy of geospatial operations if not used correctly. It also messes up with the projections stored in `table.projections`.
+     * **Warning:** This method should be used with caution as it directly manipulates coordinate order and can affect the accuracy of geospatial operations if not used correctly.
      *
      * @param column - The name of the column storing the geometries. If omitted, the method will automatically attempt to find a geometry column.
      * @returns A promise that resolves when the coordinates have been flipped.
@@ -4298,11 +4239,9 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Reprojects the geometries in a specified column to another Spatial Reference System (SRS).
-     * If reprojecting to WGS84 (`"WGS84"` or `"EPSG:4326"`), the resulting geometries will have `[latitude, longitude]` axis order.
      *
      * @param to - The target SRS (e.g., `"EPSG:3347"`, `"WGS84"`).
      * @param options - An optional object with configuration options:
-     * @param options.from - The original projection of the geometries. If omitted, the method attempts to automatically detect it. Provide this option if auto-detection fails.
      * @param options.column - The name of the column storing the geometries. If omitted, the method will automatically attempt to find a geometry column.
      * @returns A promise that resolves when the geometries have been reprojected.
      * @category Geospatial
@@ -4315,43 +4254,24 @@ export default class SimpleTable extends Simple {
      *
      * @example
      * ```ts
-     * // Reproject geometries from EPSG:4326 to EPSG:3347, specifying the original projection
-     * await table.reproject("EPSG:3347", { from: "EPSG:4326" });
-     * ```
-     *
-     * @example
-     * ```ts
      * // Reproject geometries in a specific column named 'myGeom' to EPSG:3347
-     * await table.reproject("EPSG:3347", { column: "myGeom", from: "EPSG:4326" });
+     * await table.reproject("EPSG:3347", { column: "myGeom" });
      * ```
      */
     async reproject(to, options = {}) {
+        const cleanedTo = to.replace("WGS84", "EPSG:4326");
         const column = typeof options.column === "string"
             ? options.column
             : await findGeoColumn(this);
-        const from = options.from ?? this.projections[column];
-        if (typeof from !== "string" || from === "") {
-            throw new Error("Method reproject can't determine the original projection. Use the option 'from' to provide one.");
-        }
-        if (from === "+proj=latlong +datum=WGS84 +no_defs") {
-            await this.flipCoordinates(column);
-        }
-        if (to.toUpperCase() === "WGS84" || to.toUpperCase() === "EPSG:4326") {
-            to = "+proj=latlong +datum=WGS84 +no_defs";
-        }
-        await queryDB(this, `UPDATE "${this.name}" SET "${column}" = ST_Transform("${column}", '${from}', '${to}')`, mergeOptions(this, {
+        await queryDB(this, `ALTER TABLE "${this.name}" ADD COLUMN "${column}_reprojected" GEOMETRY('${cleanedTo}'); UPDATE "${this.name}" SET "${column}_reprojected" = ST_Transform("${column}", '${cleanedTo}'); ALTER TABLE "${this.name}" DROP COLUMN "${column}"; ALTER TABLE "${this.name}" RENAME COLUMN "${column}_reprojected" TO "${column}";`, mergeOptions(this, {
             table: this.name,
             method: "reproject()",
             parameters: { column, to },
         }));
-        this.projections[column] = to;
-        if (this.projections[column] === "+proj=latlong +datum=WGS84 +no_defs") {
-            await this.flipCoordinates(column);
-        }
     }
     /**
      * Computes the area of geometries in square meters (`"m2"`) or optionally square kilometers (`"km2"`).
-     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param newColumn - The name of the new column where the computed areas will be stored.
      * @param options - An optional object with configuration options:
@@ -4390,7 +4310,7 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Computes the length of line geometries in meters (`"m"`) or optionally kilometers (`"km"`).
-     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param newColumn - The name of the new column where the computed lengths will be stored.
      * @param options - An optional object with configuration options:
@@ -4429,7 +4349,7 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Computes the perimeter of polygon geometries in meters (`"m"`) or optionally kilometers (`"km"`).
-     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param newColumn - The name of the new column where the computed perimeters will be stored.
      * @param options - An optional object with configuration options:
@@ -4493,14 +4413,14 @@ export default class SimpleTable extends Simple {
         const column = typeof options.column === "string"
             ? options.column
             : await findGeoColumn(this);
+        const proj = await this.getProjection(column);
         await queryDB(this, (await this.getColumns()).includes(newColumn)
-            ? `INSTALL spatial; LOAD spatial; UPDATE "${this.name}" SET "${newColumn}" = ST_Buffer("${column}", ${distance})`
-            : `INSTALL spatial; LOAD spatial; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Buffer("${column}", ${distance})`, mergeOptions(this, {
+            ? `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; UPDATE "${this.name}" SET "${newColumn}" = ST_Buffer("${column}", ${distance})`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY('${proj}'); UPDATE "${this.name}" SET "${newColumn}" = ST_Buffer("${column}", ${distance})`, mergeOptions(this, {
             table: this.name,
             method: "buffer()",
             parameters: { column, newColumn, distance },
         }));
-        this.projections[newColumn] = this.projections[column];
     }
     /**
      * Merges the data of this table (considered the left table) with another table (the right table) based on a spatial relationship.
@@ -4578,17 +4498,13 @@ export default class SimpleTable extends Simple {
      * ```
      */
     async intersection(column1, column2, newColumn) {
-        if (this.projections[column1] !== this.projections[column2]) {
-            throw new Error(`${column1} and ${column2} don't have the same projection.\n${column1}: ${this.projections[column1]}\n${column2}: ${this.projections[column2]}`);
-        }
         await queryDB(this, (await this.getColumns()).includes(newColumn)
-            ? `INSTALL spatial; LOAD spatial; UPDATE "${this.name}" SET "${newColumn}" = ST_Intersection("${column1}", "${column2}")`
-            : `INSTALL spatial; LOAD spatial; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Intersection("${column1}", "${column2}")`, mergeOptions(this, {
+            ? `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; UPDATE "${this.name}" SET "${newColumn}" = ST_Intersection("${column1}", "${column2}")`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Intersection("${column1}", "${column2}")`, mergeOptions(this, {
             table: this.name,
             method: "intersection()",
             parameters: { column1, column2, newColumn },
         }));
-        this.projections[newColumn] = this.projections[column1];
     }
     /**
      * Removes the intersection of two geometries from the first geometry, effectively computing the geometric difference.
@@ -4606,9 +4522,6 @@ export default class SimpleTable extends Simple {
      * ```
      */
     async removeIntersection(column1, column2, newColumn) {
-        if (this.projections[column1] !== this.projections[column2]) {
-            throw new Error(`${column1} and ${column2} don't have the same projection.\n${column1}: ${this.projections[column1]}\n${column2}: ${this.projections[column2]}`);
-        }
         await queryDB(this, (await this.getColumns()).includes(newColumn)
             ? `UPDATE "${this.name}" SET "${newColumn}" = ST_Difference("${column1}", "${column2}")`
             : `ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Difference("${column1}", "${column2}")`, mergeOptions(this, {
@@ -4616,7 +4529,6 @@ export default class SimpleTable extends Simple {
             method: "removeIntersection()",
             parameters: { column1, column2, newColumn },
         }));
-        this.projections[newColumn] = this.projections[column1];
     }
     /**
      * Fills holes in polygon geometries.
@@ -4705,21 +4617,17 @@ export default class SimpleTable extends Simple {
      * ```
      */
     async union(column1, column2, newColumn) {
-        if (this.projections[column1] !== this.projections[column2]) {
-            throw new Error(`${column1} and ${column2} don't have the same projection.\n${column1}: ${this.projections[column1]}\n${column2}: ${this.projections[column2]}`);
-        }
         await queryDB(this, (await this.getColumns()).includes(newColumn)
-            ? `INSTALL spatial; LOAD spatial; UPDATE "${this.name}" SET "${newColumn}" = ST_Union("${column1}", "${column2}")`
-            : `INSTALL spatial; LOAD spatial; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Union("${column1}", "${column2}")`, mergeOptions(this, {
+            ? `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; UPDATE "${this.name}" SET "${newColumn}" = ST_Union("${column1}", "${column2}")`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Union("${column1}", "${column2}")`, mergeOptions(this, {
             table: this.name,
             method: "union()",
             parameters: { column1, column2, newColumn },
         }));
-        this.projections[newColumn] = this.projections[column1];
     }
     /**
      * Extracts the latitude and longitude coordinates from point geometries.
-     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param column - The name of the column storing the point geometries.
      * @param columnLat - The name of the new column where the extracted latitude values will be stored.
@@ -4734,8 +4642,8 @@ export default class SimpleTable extends Simple {
      * ```
      */
     async latLon(column, columnLat, columnLon) {
-        await queryDB(this, `ALTER TABLE "${this.name}" ADD "${columnLat}" DOUBLE; UPDATE "${this.name}" SET "${columnLat}" = ST_X("${column}");
-             ALTER TABLE "${this.name}" ADD "${columnLon}" DOUBLE; UPDATE "${this.name}" SET "${columnLon}" = ST_Y("${column}");`, mergeOptions(this, {
+        await queryDB(this, `ALTER TABLE "${this.name}" ADD "${columnLat}" DOUBLE; UPDATE "${this.name}" SET "${columnLat}" = ST_Y("${column}");
+             ALTER TABLE "${this.name}" ADD "${columnLon}" DOUBLE; UPDATE "${this.name}" SET "${columnLon}" = ST_X("${column}");`, mergeOptions(this, {
             table: this.name,
             method: "latLon()",
             parameters: { column, columnLon, columnLat },
@@ -4802,13 +4710,12 @@ export default class SimpleTable extends Simple {
             ? options.column
             : await findGeoColumn(this);
         await queryDB(this, (await this.getColumns()).includes(newColumn)
-            ? `INSTALL spatial; LOAD spatial; UPDATE "${this.name}" SET "${newColumn}" = ST_Centroid("${column}")`
-            : `INSTALL spatial; LOAD spatial; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Centroid("${column}")`, mergeOptions(this, {
+            ? `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; UPDATE "${this.name}" SET "${newColumn}" = ST_Centroid("${column}")`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" GEOMETRY; UPDATE "${this.name}" SET "${newColumn}" = ST_Centroid("${column}")`, mergeOptions(this, {
             table: this.name,
             method: "centroid()",
             parameters: { column, newColumn },
         }));
-        this.projections[newColumn] = this.projections[column];
     }
     /**
      * Generates a random point within the geometries of a specified column.
@@ -4817,6 +4724,7 @@ export default class SimpleTable extends Simple {
      * @param nbPointsToTry - The number of points to generate within the bounding box of each geometry to find one that is within the geometry itself.
      * @param options - An optional object with configuration options:
      * @param options.column - The name of the column storing the geometries within which the random points will be generated. If omitted, the method will automatically attempt to find a geometry column.
+     * @param options.try - If `true`, the method will not throw an error if some points cannot be generated. Corresponding rows will have `NULL` in the new column.
      *
      * @example
      * ```ts
@@ -4829,10 +4737,16 @@ export default class SimpleTable extends Simple {
      * // Generate a random point for each geometry in a specific column named 'areaGeom', trying 50 points
      * await table.randomPoint("pointInArea", 50, { column: "areaGeom" });
      * ```
+     *
+     * @example
+     * ```ts
+     * // Generate a random point for each geometry, but don't throw if some points cannot be generated
+     * await table.randomPoint("pointInArea", 1, { try: true });
+     * ```
      */
     async randomPoint(newColumn, nbPointsToTry, options = {}) {
-        if (typeof nbPointsToTry !== "number" || nbPointsToTry < 1) {
-            throw new Error("nbPointsToTry must be a number greater than 0");
+        if (typeof nbPointsToTry !== "number" || nbPointsToTry < 0) {
+            throw new Error("nbPointsToTry must be a number greater than or equal to 0");
         }
         const column = typeof options.column === "string"
             ? options.column
@@ -4840,15 +4754,20 @@ export default class SimpleTable extends Simple {
         await queryDB(this, randomPointQuery(this.name, column, newColumn, nbPointsToTry), mergeOptions(this, {
             table: this.name,
             method: "randomPoint()",
-            parameters: { column, newColumn, nbPointsToTry },
+            parameters: { column, newColumn, nbPointsToTry, options },
         }));
-        this.projections[newColumn] = this.projections[column];
+        const nbNulls = await this.getNbRows({
+            conditions: `"${newColumn}" IS NULL`,
+        });
+        if (nbNulls > 0 && !options.try) {
+            throw new Error(`${nbNulls} points could not be generated. Consider increasing nbPointsToTry or set options.try to true.`);
+        }
     }
     /**
      * Computes the distance between geometries in two specified columns.
      * By default, the distance is calculated in the Spatial Reference System (SRS) unit of the input geometries.
      * You can optionally specify `"spheroid"` or `"haversine"` methods to get results in meters or kilometers.
-     * If using `"spheroid"` or `"haversine"`, the input geometries must be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * If using `"spheroid"` or `"haversine"`, the input geometries must be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param column1 - The name of the first column storing geometries.
      * @param column2 - The name of the second column storing geometries.
@@ -4964,7 +4883,7 @@ export default class SimpleTable extends Simple {
             parameters: { column, method, options },
         }));
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -4999,7 +4918,7 @@ export default class SimpleTable extends Simple {
     }
     /**
      * Returns the bounding box of geometries in `[minLat, minLon, maxLat, maxLon]` order.
-     * By default, the method will try to find the column with the geometries. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84), with `[latitude, longitude]` axis order.
+     * By default, the method will try to find the column with the geometries. The input geometry is assumed to be in the EPSG:4326 coordinate system (WGS84).
      *
      * @param column - The name of the column storing geometries. If omitted, the method will automatically attempt to find a geometry column.
      * @returns A promise that resolves to an array `[minLat, minLon, maxLat, maxLon]` representing the bounding box.
@@ -5022,10 +4941,10 @@ export default class SimpleTable extends Simple {
     async getBoundingBox(column) {
         const col = column ?? (await findGeoColumn(this));
         const result = (await queryDB(this, `SELECT
-                MIN(ST_XMin("${col}")) AS minX,
-                MIN(ST_YMin("${col}")) AS minY,
-                MAX(ST_XMax("${col}")) AS maxX,
-                MAX(ST_YMax("${col}")) AS maxY,
+                MIN(ST_YMin("${col}")) AS minX,
+                MIN(ST_XMin("${col}")) AS minY,
+                MAX(ST_YMax("${col}")) AS maxX,
+                MAX(ST_XMax("${col}")) AS maxY,
             from "${this.name}";`, mergeOptions(this, {
             table: this.name,
             method: "getBoundingBox()",
@@ -5037,7 +4956,6 @@ export default class SimpleTable extends Simple {
     /**
      * Returns the table's geospatial data as a GeoJSON object.
      * If the table has multiple geometry columns, you must specify which one to use.
-     * If the geometry column's projection is WGS84 or EPSG:4326 (`[latitude, longitude]` axis order), the coordinates will be flipped to follow the RFC7946 standard (`[longitude, latitude]` axis order) in the output GeoJSON.
      *
      * @param column - The name of the column storing the geometries. If omitted, the method will automatically attempt to find a geometry column.
      * @param options - An optional object with configuration options:
@@ -5142,8 +5060,6 @@ export default class SimpleTable extends Simple {
      * Writes the table's geospatial data to a file in GeoJSON, GeoParquet, or Shapefile format.
      * If the specified path does not exist, it will be created.
      *
-     * For GeoJSON files (`.geojson` or `.json`), if the projection is WGS84 or EPSG:4326 (`[latitude, longitude]` axis order), the coordinates will be flipped to follow the RFC7946 standard (`[longitude, latitude]` axis order) in the output.
-     *
      * @param file - The absolute path to the output file (e.g., `"./output.geojson"`, `"./output.geoparquet"`, `"./shapefile-folder/output.shp"`).
      * @param options - An optional object with configuration options:
      * @param options.precision - For GeoJSON, the maximum number of figures after the decimal separator to write in coordinates. Defaults to `undefined` (full precision).
@@ -5397,6 +5313,22 @@ export default class SimpleTable extends Simple {
             console.table(await getDescription(this));
         }
     }
+    /**
+     * Retrieves the projection of a specified geospatial column.
+     *
+     * @param column - The name of the geospatial column for which to retrieve the projection.
+     * @returns A promise that resolves to the projection of the specified column.
+     * @category Geospatial
+     *
+     * @example
+     * ```ts
+     * // Get the projection of the 'geom' column
+     * const projection = await table.getProjection("geom");
+     * ```
+     */
+    async getProjection(column) {
+        return (await this.sdb.customQuery(`SELECT ST_CRS("${column}") AS proj FROM "${this.name}" LIMIT 1;`, { returnDataFrom: "query" }))[0].proj;
+    }
     /**
      * Logs the projections of the geospatial data (if any) to the console.
      *
@@ -5411,7 +5343,19 @@ export default class SimpleTable extends Simple {
      */
     async logProjections() {
         console.log(`\nTable ${this.name} projections:`);
-        console.log(this.projections);
+        const types = await this.getTypes();
+        const geoColumns = Object.entries(types)
+            .filter(([_, type]) => type.toLowerCase().includes("geometry"))
+            .map(([column]) => column);
+        if (geoColumns.length === 0) {
+            console.log("No geometry columns found.");
+        }
+        else {
+            for (const column of geoColumns) {
+                const projection = types[column];
+                console.log(`- Column "${column}": ${projection}`);
+            }
+        }
         return await this;
     }
     /**