@nshiab/simple-data-analysis-core 0.0.27 → 0.1.1

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 geoType = await this.getProjection("geom");
+            if (geoType !== "GEOMETRY('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,28 +1716,21 @@ 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);
-        await queryDB(this, `ALTER TABLE "${this.name}" ADD "${newColumn}" ${newType};
+        let spatial = "";
+        if (newType.toLowerCase().includes("geometry")) {
+            spatial = "INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;";
+        }
+        await queryDB(this, `${spatial} 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, starting at 0 (like an index).
@@ -1886,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;
         }
     }
@@ -3029,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;
@@ -3171,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;
@@ -3228,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;
@@ -4083,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.
@@ -4099,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; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Point("${columnLon}", "${columnLat}")::GEOMETRY('EPSG:4326') AS "${newColumn}") FROM "${this.name}"`
+            : `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD COLUMN "${newColumn}" GEOMETRY('EPSG:4326'); UPDATE "${this.name}" SET "${newColumn}" = ST_Point("${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.
@@ -4192,7 +4110,8 @@ export default class SimpleTable extends Simple {
      */
     async fixGeo(column) {
         const col = column ?? (await findGeoColumn(this));
-        await queryDB(this, `UPDATE "${this.name}" SET "${col}" = ST_MakeValid("${col}")`, mergeOptions(this, {
+        const geoType = await this.getProjection(col);
+        await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_MakeValid("${col}")::${geoType} AS "${col}") FROM "${this.name}"`, mergeOptions(this, {
             table: this.name,
             method: "fixGeo()",
             parameters: { column },
@@ -4262,7 +4181,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.
@@ -4282,7 +4201,8 @@ export default class SimpleTable extends Simple {
      */
     async flipCoordinates(column) {
         const col = column ?? (await findGeoColumn(this));
-        await queryDB(this, `UPDATE "${this.name}" SET "${col}" = ST_FlipCoordinates("${col}")`, mergeOptions(this, {
+        const geoType = await this.getProjection(col);
+        await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_FlipCoordinates("${col}")::${geoType} AS "${col}") FROM "${this.name}"`, mergeOptions(this, {
             table: this.name,
             method: "flipCoordinates()",
             parameters: { column },
@@ -4313,7 +4233,8 @@ export default class SimpleTable extends Simple {
         const column = typeof options.column === "string"
             ? options.column
             : await findGeoColumn(this);
-        await queryDB(this, `UPDATE "${this.name}" SET "${column}" = ST_ReducePrecision("${column}", ${1 / Math.pow(10, decimals)})`, mergeOptions(this, {
+        const geoType = await this.getProjection(column);
+        await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_ReducePrecision("${column}", ${1 / Math.pow(10, decimals)})::${geoType} AS "${column}") FROM "${this.name}"`, mergeOptions(this, {
             table: this.name,
             method: "reducePrecision()",
             parameters: { column, decimals },
@@ -4321,11 +4242,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
@@ -4338,43 +4257,25 @@ 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 targetGeoType = `GEOMETRY${cleanedTo !== "null" ? `('${cleanedTo}')` : ""}`;
         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, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Transform("${column}", '${cleanedTo}')::${targetGeoType} AS "${column}") FROM "${this.name}"`, 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:
@@ -4413,7 +4314,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:
@@ -4452,7 +4353,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:
@@ -4516,14 +4417,22 @@ export default class SimpleTable extends Simple {
         const column = typeof options.column === "string"
             ? options.column
             : await findGeoColumn(this);
-        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, {
-            table: this.name,
-            method: "buffer()",
-            parameters: { column, newColumn, distance },
-        }));
-        this.projections[newColumn] = this.projections[column];
+        const geoType = await this.getProjection(column);
+        const columns = await this.getColumns();
+        if (columns.includes(newColumn)) {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Buffer("${column}", ${distance})::${geoType} AS "${newColumn}") FROM "${this.name}"`, mergeOptions(this, {
+                table: this.name,
+                method: "buffer()",
+                parameters: { column, newColumn, distance },
+            }));
+        }
+        else {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" ${geoType}; UPDATE "${this.name}" SET "${newColumn}" = ST_Buffer("${column}", ${distance})`, mergeOptions(this, {
+                table: this.name,
+                method: "buffer()",
+                parameters: { column, newColumn, distance },
+            }));
+        }
     }
     /**
      * Merges the data of this table (considered the left table) with another table (the right table) based on a spatial relationship.
@@ -4601,17 +4510,22 @@ 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]}`);
+        const geoType = await this.getProjection(column1);
+        const columns = await this.getColumns();
+        if (columns.includes(newColumn)) {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Intersection("${column1}", "${column2}")::${geoType} AS "${newColumn}") FROM "${this.name}"`, mergeOptions(this, {
+                table: this.name,
+                method: "intersection()",
+                parameters: { column1, column2, newColumn },
+            }));
+        }
+        else {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" ${geoType}; UPDATE "${this.name}" SET "${newColumn}" = ST_Intersection("${column1}", "${column2}")`, mergeOptions(this, {
+                table: this.name,
+                method: "intersection()",
+                parameters: { column1, column2, newColumn },
+            }));
         }
-        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, {
-            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.
@@ -4629,17 +4543,22 @@ 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]}`);
+        const geoType = await this.getProjection(column1);
+        const columns = await this.getColumns();
+        if (columns.includes(newColumn)) {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Difference("${column1}", "${column2}")::${geoType} AS "${newColumn}") FROM "${this.name}"`, mergeOptions(this, {
+                table: this.name,
+                method: "removeIntersection()",
+                parameters: { column1, column2, newColumn },
+            }));
+        }
+        else {
+            await queryDB(this, `ALTER TABLE "${this.name}" ADD "${newColumn}" ${geoType}; UPDATE "${this.name}" SET "${newColumn}" = ST_Difference("${column1}", "${column2}")`, mergeOptions(this, {
+                table: this.name,
+                method: "removeIntersection()",
+                parameters: { column1, column2, newColumn },
+            }));
         }
-        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, {
-            table: this.name,
-            method: "removeIntersection()",
-            parameters: { column1, column2, newColumn },
-        }));
-        this.projections[newColumn] = this.projections[column1];
     }
     /**
      * Fills holes in polygon geometries.
@@ -4728,21 +4647,26 @@ 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]}`);
+        const geoType = await this.getProjection(column1);
+        const columns = await this.getColumns();
+        if (columns.includes(newColumn)) {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Union("${column1}", "${column2}")::${geoType} AS "${newColumn}") FROM "${this.name}"`, mergeOptions(this, {
+                table: this.name,
+                method: "union()",
+                parameters: { column1, column2, newColumn },
+            }));
+        }
+        else {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" ${geoType}; UPDATE "${this.name}" SET "${newColumn}" = ST_Union("${column1}", "${column2}")`, mergeOptions(this, {
+                table: this.name,
+                method: "union()",
+                parameters: { column1, column2, newColumn },
+            }));
         }
-        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, {
-            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.
@@ -4757,8 +4681,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 },
@@ -4791,7 +4715,8 @@ export default class SimpleTable extends Simple {
             ? options.column
             : await findGeoColumn(this);
         await this.addRowNumber("rowNumberForSimplify");
-        await queryDB(this, `CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE(ST_CoverageSimplify(ARRAY_AGG("${column}"), ${tolerance}${options.simplifyBoundary === false ? ", FAlSE" : ""}) AS "${column}") FROM "${this.name}" GROUP BY ALL;`, mergeOptions(this, {
+        const geoType = await this.getProjection(column);
+        await queryDB(this, `CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE(ST_CoverageSimplify(ARRAY_AGG("${column}"), ${tolerance}${options.simplifyBoundary === false ? ", FAlSE" : ""})::${geoType} AS "${column}") FROM "${this.name}" GROUP BY ALL;`, mergeOptions(this, {
             table: this.name,
             method: "simplify()",
             parameters: { column, tolerance },
@@ -4824,14 +4749,22 @@ export default class SimpleTable extends Simple {
         const column = typeof options.column === "string"
             ? 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, {
-            table: this.name,
-            method: "centroid()",
-            parameters: { column, newColumn },
-        }));
-        this.projections[newColumn] = this.projections[column];
+        const geoType = await this.getProjection(column);
+        const columns = await this.getColumns();
+        if (columns.includes(newColumn)) {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; CREATE OR REPLACE TABLE "${this.name}" AS SELECT * REPLACE (ST_Centroid("${column}")::${geoType} AS "${newColumn}") FROM "${this.name}"`, mergeOptions(this, {
+                table: this.name,
+                method: "centroid()",
+                parameters: { column, newColumn },
+            }));
+        }
+        else {
+            await queryDB(this, `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; ALTER TABLE "${this.name}" ADD "${newColumn}" ${geoType}; UPDATE "${this.name}" SET "${newColumn}" = ST_Centroid("${column}")`, mergeOptions(this, {
+                table: this.name,
+                method: "centroid()",
+                parameters: { column, newColumn },
+            }));
+        }
     }
     /**
      * Generates a random point within the geometries of a specified column.
@@ -4867,10 +4800,11 @@ export default class SimpleTable extends Simple {
         const column = typeof options.column === "string"
             ? options.column
             : await findGeoColumn(this);
-        await queryDB(this, randomPointQuery(this.name, column, newColumn, nbPointsToTry), mergeOptions(this, {
+        const geoType = await this.getProjection(column);
+        await queryDB(this, randomPointQuery(this.name, column, newColumn, nbPointsToTry, geoType), mergeOptions(this, {
             table: this.name,
             method: "randomPoint()",
-            parameters: { column, newColumn, nbPointsToTry, options },
+            parameters: { column, newColumn, nbPointsToTry, options, geoType },
         }));
         const nbNulls = await this.getNbRows({
             conditions: `"${newColumn}" IS NULL`,
@@ -4878,13 +4812,12 @@ export default class SimpleTable extends Simple {
         if (nbNulls > 0 && !options.try) {
             throw new Error(`${nbNulls} points could not be generated. Consider increasing nbPointsToTry or set options.try to true.`);
         }
-        this.projections[newColumn] = this.projections[column];
     }
     /**
      * 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.
@@ -5000,7 +4933,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;
@@ -5035,7 +4968,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.
@@ -5058,10 +4991,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()",
@@ -5073,7 +5006,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:
@@ -5178,8 +5110,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).
@@ -5433,6 +5363,24 @@ 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) {
+        const res = (await this.sdb.customQuery(`SELECT ST_CRS("${column}") AS proj FROM "${this.name}" LIMIT 1;`, { returnDataFrom: "query" }))[0];
+        const proj = res && res.proj !== "null" ? res.proj : null;
+        return `GEOMETRY${proj ? `('${proj}')` : ""}`;
+    }
     /**
      * Logs the projections of the geospatial data (if any) to the console.
      *
@@ -5447,7 +5395,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;
     }
     /**