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

package/script/class/SimpleTable.js

@@ -67,7 +67,6 @@ const summarize_js_1 = __importDefault(require("../methods/summarize.js"));
 const correlations_js_1 = __importDefault(require("../methods/correlations.js"));
 const linearRegressions_js_1 = __importDefault(require("../methods/linearRegressions.js"));
 const joinGeo_js_1 = __importDefault(require("../methods/joinGeo.js"));
-const getProjection_js_1 = __importDefault(require("../helpers/getProjection.js"));
 const cache_js_1 = __importDefault(require("../methods/cache.js"));
 const camelCase_js_1 = __importDefault(require("../helpers/camelCase.js"));
 const formatNumber_js_1 = __importDefault(require("../helpers/formatNumber.js"));
@@ -90,7 +89,6 @@ const getIdenticalColumns_js_1 = __importDefault(require("../helpers/getIdentica
 const capitalizeQuery_js_1 = __importDefault(require("../methods/capitalizeQuery.js"));
 const truncateQuery_js_1 = __importDefault(require("../methods/truncateQuery.js"));
 const padQuery_js_1 = __importDefault(require("../methods/padQuery.js"));
-const getProjectionParquet_js_1 = __importDefault(require("../helpers/getProjectionParquet.js"));
 const hasGeometryColumn_js_1 = __importDefault(require("../helpers/hasGeometryColumn.js"));
 const unifyColumns_js_1 = __importDefault(require("../helpers/unifyColumns.js"));
 const accumulateQuery_js_1 = __importDefault(require("../helpers/accumulateQuery.js"));
@@ -152,7 +150,6 @@ class SimpleTable extends Simple_js_1.default {
      * 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.
@@ -161,7 +158,7 @@ class SimpleTable extends Simple_js_1.default {
      * @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.
@@ -175,19 +172,7 @@ class SimpleTable extends Simple_js_1.default {
             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
@@ -199,7 +184,6 @@ class SimpleTable extends Simple_js_1.default {
             value: void 0
         });
         this.name = name;
-        this.projections = projections;
         this.sdb = simpleDB;
         this.runQuery = runQuery_js_1.default;
         this.indexes = [];
@@ -247,8 +231,9 @@ class SimpleTable extends Simple_js_1.default {
         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 (0, queryDB_js_1.default)(this, `${spatial}CREATE OR REPLACE TABLE "${this.name}" (${Object.keys(types)
             .map((d) => `"${d}" ${(0, parseTypes_js_1.default)(types[d])}`)
@@ -403,12 +388,10 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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
      *
@@ -439,7 +422,7 @@ class SimpleTable extends Simple_js_1.default {
     async loadGeoData(file, options = {}) {
         const fileExtension = (0, getExtension_js_1.default)(file);
         if (fileExtension === "geoparquet" || fileExtension === "parquet") {
-            await (0, queryDB_js_1.default)(this, `INSTALL spatial; LOAD spatial;${file.toLowerCase().includes("http")
+            await (0, queryDB_js_1.default)(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('${(0, cleanPath_js_1.default)(file)}');`, (0, mergeOptions_js_1.default)(this, {
@@ -447,32 +430,21 @@ class SimpleTable extends Simple_js_1.default {
                 method: "loadGeoData()",
                 parameters: { file, options },
             }));
-            this.projections = await (0, getProjectionParquet_js_1.default)(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 (0, queryDB_js_1.default)(this, `INSTALL spatial; LOAD spatial;${file.toLowerCase().includes("http")
+            await (0, queryDB_js_1.default)(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}');`, (0, mergeOptions_js_1.default)(this, {
+              CREATE OR REPLACE TABLE "${this.name}" AS SELECT * EXCLUDE OGC_FID FROM ST_Read('${file}');`, (0, mergeOptions_js_1.default)(this, {
                 table: this.name,
                 method: "loadGeoData()",
                 parameters: { file, options },
             }));
-            // column storing geometries is geom by default
-            this.projections["geom"] = await (0, getProjection_js_1.default)(this.sdb, file);
-            const extension = (0, getExtension_js_1.default)(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;
@@ -764,9 +736,8 @@ class SimpleTable extends Simple_js_1.default {
             : [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) {
@@ -778,27 +749,22 @@ class SimpleTable extends Simple_js_1.default {
         }
         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 (0, unifyColumns_js_1.default)(allTables, allTypes, allProjections);
+            columnsAdded = await (0, unifyColumns_js_1.default)(allTables, allTypes);
         }
         await (0, queryDB_js_1.default)(this, array
             .map((tableToInsert) => `INSERT INTO "${this.name}" BY NAME SELECT * FROM "${tableToInsert.name}";`)
@@ -897,29 +863,16 @@ class SimpleTable extends Simple_js_1.default {
         const columns = typeof nameOrOptions === "object" && nameOrOptions.columns
             ? (0, stringToArray_js_1.default)(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 (0, queryDB_js_1.default)(this, (0, cloneQuery_js_1.default)(this.name, clonedTable.name, columns, options), (0, mergeOptions_js_1.default)(this, {
             table: clonedTable.name,
@@ -950,9 +903,6 @@ class SimpleTable extends Simple_js_1.default {
             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.
@@ -1017,9 +967,6 @@ class SimpleTable extends Simple_js_1.default {
             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`.
@@ -1265,7 +1212,7 @@ class SimpleTable extends Simple_js_1.default {
             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;
@@ -1538,15 +1485,6 @@ class SimpleTable extends Simple_js_1.default {
             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.
@@ -1763,12 +1701,6 @@ class SimpleTable extends Simple_js_1.default {
             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.
@@ -1777,7 +1709,6 @@ class SimpleTable extends Simple_js_1.default {
      * @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
      *
@@ -1790,33 +1721,28 @@ class SimpleTable extends Simple_js_1.default {
      * @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 = (0, parseTypes_js_1.default)(type);
+        // let spatial = "";
+        // if (newType.toLowerCase().includes("geometry")) {
+        //   spatial = "INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;";
+        // }
         await (0, queryDB_js_1.default)(this, `ALTER TABLE "${this.name}" ADD "${newColumn}" ${newType};
         UPDATE "${this.name}" SET "${newColumn}" = ${definition}`, (0, mergeOptions_js_1.default)(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
      *
@@ -1825,12 +1751,24 @@ class SimpleTable extends Simple_js_1.default {
      * // 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 (0, queryDB_js_1.default)(this, `CREATE OR REPLACE TABLE "${this.name}" AS SELECT *, ROW_NUMBER() OVER() AS ${newColumn} FROM "${this.name}"`, (0, mergeOptions_js_1.default)(this, {
+    async addRowNumber(newColumn, options = {}) {
+        const categories = options.categories
+            ? (0, stringToArray_js_1.default)(options.categories)
+            : [];
+        const partition = categories.length > 0
+            ? `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`
+            : "";
+        await (0, queryDB_js_1.default)(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`, (0, mergeOptions_js_1.default)(this, {
             table: this.name,
             method: "addRowNumber()",
-            parameters: { newColumn },
+            parameters: { newColumn, options },
         }));
     }
     /**
@@ -1877,15 +1815,10 @@ class SimpleTable extends Simple_js_1.default {
             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;
         }
     }
@@ -3020,7 +2953,7 @@ class SimpleTable extends Simple_js_1.default {
         }
         await (0, summarize_js_1.default)(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3162,7 +3095,7 @@ class SimpleTable extends Simple_js_1.default {
         }
         await (0, correlations_js_1.default)(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3219,7 +3152,7 @@ class SimpleTable extends Simple_js_1.default {
         }
         await (0, linearRegressions_js_1.default)(this, options);
         if (typeof options.outputTable === "string") {
-            return this.sdb.newTable(options.outputTable, this.projections);
+            return this.sdb.newTable(options.outputTable);
         }
         else {
             return this;
@@ -3517,6 +3450,8 @@ class SimpleTable extends Simple_js_1.default {
     /**
      * 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
      *
@@ -3526,9 +3461,16 @@ class SimpleTable extends Simple_js_1.default {
      * 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 (0, getNbRows_js_1.default)(this);
+    async getNbRows(options = {}) {
+        return await (0, getNbRows_js_1.default)(this, options);
     }
     /**
      * Returns the total number of values in the table (number of columns multiplied by the number of rows).
@@ -4065,7 +4007,7 @@ class SimpleTable extends Simple_js_1.default {
     }
     // 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.
@@ -4081,13 +4023,12 @@ class SimpleTable extends Simple_js_1.default {
      */
     async points(columnLat, columnLon, newColumn) {
         await (0, queryDB_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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.
@@ -4244,7 +4185,7 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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.
@@ -4303,11 +4244,9 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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
@@ -4320,43 +4259,24 @@ class SimpleTable extends Simple_js_1.default {
      *
      * @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 (0, findGeoColumn_js_1.default)(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 (0, queryDB_js_1.default)(this, `UPDATE "${this.name}" SET "${column}" = ST_Transform("${column}", '${from}', '${to}')`, (0, mergeOptions_js_1.default)(this, {
+        await (0, queryDB_js_1.default)(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}";`, (0, mergeOptions_js_1.default)(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:
@@ -4395,7 +4315,7 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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:
@@ -4434,7 +4354,7 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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:
@@ -4498,14 +4418,14 @@ class SimpleTable extends Simple_js_1.default {
         const column = typeof options.column === "string"
             ? options.column
             : await (0, findGeoColumn_js_1.default)(this);
+        const proj = await this.getProjection(column);
         await (0, queryDB_js_1.default)(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})`, (0, mergeOptions_js_1.default)(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})`, (0, mergeOptions_js_1.default)(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.
@@ -4583,17 +4503,13 @@ class SimpleTable extends Simple_js_1.default {
      * ```
      */
     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 (0, queryDB_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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.
@@ -4611,9 +4527,6 @@ class SimpleTable extends Simple_js_1.default {
      * ```
      */
     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 (0, queryDB_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(this, {
@@ -4621,7 +4534,6 @@ class SimpleTable extends Simple_js_1.default {
             method: "removeIntersection()",
             parameters: { column1, column2, newColumn },
         }));
-        this.projections[newColumn] = this.projections[column1];
     }
     /**
      * Fills holes in polygon geometries.
@@ -4710,21 +4622,17 @@ class SimpleTable extends Simple_js_1.default {
      * ```
      */
     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 (0, queryDB_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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.
@@ -4739,8 +4647,8 @@ class SimpleTable extends Simple_js_1.default {
      * ```
      */
     async latLon(column, columnLat, columnLon) {
-        await (0, queryDB_js_1.default)(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}");`, (0, mergeOptions_js_1.default)(this, {
+        await (0, queryDB_js_1.default)(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}");`, (0, mergeOptions_js_1.default)(this, {
             table: this.name,
             method: "latLon()",
             parameters: { column, columnLon, columnLat },
@@ -4807,13 +4715,12 @@ class SimpleTable extends Simple_js_1.default {
             ? options.column
             : await (0, findGeoColumn_js_1.default)(this);
         await (0, queryDB_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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}")`, (0, mergeOptions_js_1.default)(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.
@@ -4822,6 +4729,7 @@ class SimpleTable extends Simple_js_1.default {
      * @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
@@ -4834,10 +4742,16 @@ class SimpleTable extends Simple_js_1.default {
      * // 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
@@ -4845,15 +4759,20 @@ class SimpleTable extends Simple_js_1.default {
         await (0, queryDB_js_1.default)(this, (0, randomPointQuery_js_1.default)(this.name, column, newColumn, nbPointsToTry), (0, mergeOptions_js_1.default)(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.
@@ -4969,7 +4888,7 @@ class SimpleTable extends Simple_js_1.default {
             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;
@@ -5004,7 +4923,7 @@ class SimpleTable extends Simple_js_1.default {
     }
     /**
      * 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.
@@ -5027,10 +4946,10 @@ class SimpleTable extends Simple_js_1.default {
     async getBoundingBox(column) {
         const col = column ?? (await (0, findGeoColumn_js_1.default)(this));
         const result = (await (0, queryDB_js_1.default)(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}";`, (0, mergeOptions_js_1.default)(this, {
             table: this.name,
             method: "getBoundingBox()",
@@ -5042,7 +4961,6 @@ class SimpleTable extends Simple_js_1.default {
     /**
      * 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:
@@ -5147,8 +5065,6 @@ class SimpleTable extends Simple_js_1.default {
      * 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).
@@ -5402,6 +5318,22 @@ class SimpleTable extends Simple_js_1.default {
             console.table(await (0, getDescription_js_1.default)(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.
      *
@@ -5416,7 +5348,19 @@ class SimpleTable extends Simple_js_1.default {
      */
     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;
     }
     /**