@nshiab/simple-data-analysis-core 2.1.12 → 2.1.14

package/src/helpers/writeGeoData.ts

@@ -0,0 +1,248 @@
+import quoteIdentifier from "./quoteIdentifier.ts";
+import { mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import createDirectory from "./createDirectory.ts";
+import getExtension from "./getExtension.ts";
+import hasGeometryColumn from "./hasGeometryColumn.ts";
+import queryDB from "./queryDB.ts";
+
+import mergeOptions from "./mergeOptions.ts";
+import rewind, { isGeoObject } from "./rewind.ts";
+import flushAllTables from "./flushAllTables.ts";
+import stringifyDates from "./stringifyDates.ts";
+import stringifyDatesInvert from "./stringifyDatesInvert.ts";
+import cleanPath from "./cleanPath.ts";
+import type SimpleTable from "../class/SimpleTable.ts";
+import writeZip from "./writeZip.ts";
+
+export default async function writeGeoData(
+  table: SimpleTable,
+  file: string,
+  options: {
+    precision?: number;
+    compression?: boolean;
+    rewind?: boolean;
+    metadata?: unknown;
+    formatDates?: boolean;
+  } = {},
+): Promise<void> {
+  const compressedShapefileExtension = file.toLowerCase().endsWith(".shp.zip");
+  const fileExtension = compressedShapefileExtension ? "shp" : getExtension(file);
+  assertWriteGeoDataOptions(fileExtension, options);
+
+  if (!(await hasGeometryColumn(table))) {
+    throw new Error("Table contains no geometry columns. Use writeData() instead.");
+  }
+  createDirectory(file);
+  if (fileExtension === "geojson" || fileExtension === "json") {
+    let types;
+    let datesConverted = false;
+    if (options.formatDates === true) {
+      types = await table.getTypes();
+      if (Object.values(types).includes("DATE") || Object.values(types).includes("TIMESTAMP")) {
+        await stringifyDates(table, types);
+        datesConverted = true;
+      }
+    }
+
+    try {
+      await queryDB(
+        table,
+        writeGeoDataQuery(table.name, file, fileExtension, options),
+        mergeOptions(table, {
+          table: table.name,
+          method: "writeGeoData()",
+          parameters: { file, options },
+        }),
+      );
+
+      if (options.metadata) {
+        const fileData: unknown = JSON.parse(readFileSync(file, "utf-8"));
+        if (!isGeoObject(fileData)) throw new Error("Invalid GeoJSON output from DuckDB.");
+        writeFileSync(file, JSON.stringify({ ...fileData, metadata: options.metadata }));
+      }
+      if (options.rewind) {
+        const fileData: unknown = JSON.parse(readFileSync(file, "utf-8"));
+        if (!isGeoObject(fileData)) throw new Error("Invalid GeoJSON output from DuckDB.");
+        const fileRewinded = rewind(fileData);
+        writeFileSync(file, JSON.stringify(fileRewinded));
+      }
+    } finally {
+      if (datesConverted && types) {
+        await stringifyDatesInvert(table, types);
+        // stringifyDatesInvert queues sync builder operations restoring the
+        // date columns. writeGeoData is an observer, so it must leave no
+        // queued work behind.
+        await flushAllTables(table.sdb);
+      }
+    }
+  } else if (fileExtension === "shp") {
+    if (compressedShapefileExtension) {
+      const shapefile = file.slice(0, -".zip".length);
+      await writeCompressedShapefile(table, shapefile, file, file, options);
+    } else {
+      await writeShapefile(table, file, file, options);
+    }
+  } else if (fileExtension === "geoparquet") {
+    await queryDB(
+      table,
+      `COPY ${quoteIdentifier(table.name)} TO '${cleanPath(file)}' WITH (FORMAT PARQUET${
+        options.compression === true ? ", COMPRESSION 'zstd'" : ""
+      });`,
+      mergeOptions(table, {
+        table: table.name,
+        method: "writeGeoData()",
+        parameters: { file, options },
+      }),
+    );
+  }
+}
+
+function assertWriteGeoDataOptions(
+  fileExtension: string,
+  options: {
+    precision?: number;
+    compression?: boolean;
+    rewind?: boolean;
+    metadata?: unknown;
+    formatDates?: boolean;
+  },
+): void {
+  if (!["geojson", "json", "shp", "geoparquet"].includes(fileExtension)) {
+    throw new Error(
+      `writeGeoData() does not support the extension ${JSON.stringify(
+        fileExtension,
+      )}. Use .geojson, .json, .shp, .shp.zip, or .geoparquet.`,
+    );
+  }
+  if (
+    (fileExtension === "geojson" || fileExtension === "json") &&
+    typeof options.compression === "boolean"
+  ) {
+    throw new Error("writeGeoData() compression is not supported for GeoJSON files.");
+  }
+  if (fileExtension === "shp" && typeof options.compression === "boolean") {
+    throw new Error(
+      "writeGeoData() compression is not supported for Shapefiles. Use a .shp.zip file extension instead.",
+    );
+  }
+  if (
+    fileExtension === "shp" &&
+    (typeof options.precision === "number" ||
+      typeof options.rewind === "boolean" ||
+      options.metadata !== undefined ||
+      options.formatDates === true)
+  ) {
+    throw new Error(
+      "writeGeoData() precision, rewind, metadata, and formatDates are not supported for Shapefiles.",
+    );
+  }
+  if (fileExtension === "geoparquet" && typeof options.precision === "number") {
+    throw new Error(
+      "writeGeoData() precision is not supported for GeoParquet files. Use reducePrecision() first.",
+    );
+  }
+  if (fileExtension === "geoparquet" && typeof options.rewind === "boolean") {
+    throw new Error("writeGeoData() rewind is not supported for GeoParquet files.");
+  }
+}
+
+async function writeCompressedShapefile(
+  table: SimpleTable,
+  shapefile: string,
+  archive: string,
+  requestedFile: string,
+  options: { compression?: boolean },
+): Promise<void> {
+  const temporaryDirectory = mkdtempSync(join(dirname(archive), `.${basename(shapefile)}-`));
+  const temporaryShapefile = join(temporaryDirectory, basename(shapefile));
+  const temporaryArchive = `${temporaryShapefile}.zip`;
+  let outcome: { success: true } | { success: false; error: unknown };
+
+  try {
+    await writeShapefile(table, temporaryShapefile, requestedFile, options);
+    const inputs = readdirSync(temporaryDirectory, { withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .sort((first, second) => first.name.localeCompare(second.name))
+      .map((entry) => ({
+        file: join(temporaryDirectory, entry.name),
+        name: entry.name,
+      }));
+    await writeZip(temporaryArchive, inputs);
+    renameSync(temporaryArchive, archive);
+    outcome = { success: true };
+  } catch (error) {
+    outcome = { success: false, error };
+  }
+
+  try {
+    rmSync(temporaryDirectory, { recursive: true, force: true });
+  } catch (cleanupError) {
+    if (!outcome.success) {
+      throw new AggregateError(
+        [outcome.error, cleanupError],
+        "Writing and cleaning up the compressed Shapefile both failed.",
+        { cause: outcome.error },
+      );
+    }
+    throw cleanupError;
+  }
+
+  if (!outcome.success) {
+    throw outcome.error;
+  }
+}
+
+async function writeShapefile(
+  table: SimpleTable,
+  outputFile: string,
+  requestedFile: string,
+  options: { compression?: boolean },
+): Promise<void> {
+  await queryDB(
+    table,
+    writeGeoDataQuery(table.name, outputFile, "shp"),
+    mergeOptions(table, {
+      table: table.name,
+      method: "writeGeoData()",
+      parameters: { file: requestedFile, options },
+    }),
+  );
+}
+
+function writeGeoDataQuery(
+  table: string,
+  file: string,
+  fileExtension: string,
+  options: { precision?: number } = {},
+) {
+  if (fileExtension === "geojson" || fileExtension === "json") {
+    const layerOptions = [];
+    if (typeof options.precision === "number") {
+      layerOptions.push(`COORDINATE_PRECISION=${options.precision}`);
+    }
+    layerOptions.push(`RFC7946=YES`);
+
+    return `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; COPY ${quoteIdentifier(
+      table,
+    )} to '${cleanPath(file)}' WITH (FORMAT GDAL, DRIVER 'GeoJSON'${
+      layerOptions.length > 0
+        ? `, LAYER_CREATION_OPTIONS ('WRITE_NAME=NO', ${layerOptions
+            .map((d) => `'${d}'`)
+            .join(", ")})`
+        : ""
+    })`;
+  } else if (fileExtension === "shp") {
+    // DuckDB only finalizes the main file when a GDAL driver creates a
+    // multi-file dataset, leaving Shapefile sidecars under the tmp_ prefix.
+    // Remove USE_TMP_FILE false once the upstream fix is released:
+    // https://github.com/duckdb/duckdb-spatial/issues/859
+    return `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; COPY ${quoteIdentifier(
+      table,
+    )} TO '${cleanPath(
+      file,
+    )}' WITH (FORMAT GDAL, DRIVER 'ESRI Shapefile', LAYER_CREATION_OPTIONS 'ENCODING=UTF-8', USE_TMP_FILE false)`;
+  } else {
+    throw new Error(`Unknown extension ${fileExtension}`);
+  }
+}

package/src/helpers/writeZip.ts

@@ -0,0 +1,311 @@
+import { createReadStream } from "node:fs";
+import { type FileHandle, open, rm, stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { Transform, type TransformCallback, Writable, type WritableOptions } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import * as zlib from "node:zlib";
+import { constants, createDeflateRaw } from "node:zlib";
+
+const maximumZip32Value = 0xffff_fffe;
+const maximumZip32Entries = 0xfffe;
+const utf8WithDataDescriptor = 0x0808;
+const crc32Table = createCrc32Table();
+
+type ZipInput = {
+  file: string;
+  name?: string;
+};
+
+type ZipEntry = {
+  name: Uint8Array;
+  crc32: number;
+  compressedSize: number;
+  uncompressedSize: number;
+  localHeaderOffset: number;
+  modificationTime: number;
+  modificationDate: number;
+};
+
+class ChecksumTransform extends Transform {
+  #crc32 = 0;
+  size = 0;
+
+  get crc32(): number {
+    return this.#crc32;
+  }
+
+  override _transform(
+    chunk: Uint8Array,
+    _encoding: BufferEncoding,
+    callback: TransformCallback,
+  ): void {
+    this.#crc32 = updateCrc32(chunk, this.#crc32);
+    this.size += chunk.byteLength;
+    callback(null, chunk);
+  }
+}
+
+class FileHandleWritable extends Writable {
+  bytesWritten = 0;
+  readonly #fileHandle: FileHandle;
+
+  constructor(fileHandle: FileHandle, options?: WritableOptions) {
+    super(options);
+    this.#fileHandle = fileHandle;
+  }
+
+  override _write(
+    chunk: Uint8Array,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null) => void,
+  ): void {
+    writeAll(this.#fileHandle, chunk)
+      .then(() => {
+        this.bytesWritten += chunk.byteLength;
+        callback();
+      })
+      .catch((error: unknown) => {
+        callback(error instanceof Error ? error : new Error(String(error)));
+      });
+  }
+}
+
+/**
+ * Writes files to a ZIP archive using streaming DEFLATE compression.
+ *
+ * The implementation intentionally supports ZIP32 archives only. Shapefile
+ * components are conventionally limited to 2 GB, but the combined archive can
+ * still exceed ZIP32 limits; those cases fail explicitly instead of producing
+ * a corrupt archive.
+ */
+export default async function writeZip(archive: string, inputs: ZipInput[]): Promise<void> {
+  if (inputs.length > maximumZip32Entries) {
+    throw new Error(`ZIP archives support at most ${maximumZip32Entries} files.`);
+  }
+
+  const fileHandle = await open(archive, "w");
+  const entries: ZipEntry[] = [];
+  let offset = 0;
+  let operationError: unknown;
+
+  try {
+    for (const input of inputs) {
+      const fileStats = await stat(input.file);
+      if (!fileStats.isFile()) {
+        throw new Error(`ZIP input is not a file: ${JSON.stringify(input.file)}`);
+      }
+      assertZip32Value(fileStats.size, "uncompressed file size");
+
+      const name = encodeZipName(input.name ?? basename(input.file));
+      const { modificationTime, modificationDate } = encodeDosDateTime(fileStats.mtime);
+      const localHeaderOffset = offset;
+      const localHeader = createLocalHeader(name, modificationTime, modificationDate);
+      await writeAll(fileHandle, localHeader);
+      offset += localHeader.byteLength;
+
+      const checksum = new ChecksumTransform();
+      const output = new FileHandleWritable(fileHandle);
+      await pipeline(
+        createReadStream(input.file),
+        checksum,
+        createDeflateRaw({ level: constants.Z_BEST_SPEED }),
+        output,
+      );
+
+      assertZip32Value(output.bytesWritten, "compressed file size");
+      const descriptor = createDataDescriptor(checksum.crc32, output.bytesWritten, checksum.size);
+      await writeAll(fileHandle, descriptor);
+      offset += output.bytesWritten + descriptor.byteLength;
+
+      entries.push({
+        name,
+        crc32: checksum.crc32,
+        compressedSize: output.bytesWritten,
+        uncompressedSize: checksum.size,
+        localHeaderOffset,
+        modificationTime,
+        modificationDate,
+      });
+    }
+
+    const centralDirectoryOffset = offset;
+    for (const entry of entries) {
+      assertZip32Value(entry.localHeaderOffset, "local header offset");
+      const centralHeader = createCentralDirectoryHeader(entry);
+      await writeAll(fileHandle, centralHeader);
+      offset += centralHeader.byteLength;
+    }
+
+    const centralDirectorySize = offset - centralDirectoryOffset;
+    assertZip32Value(centralDirectoryOffset, "central directory offset");
+    assertZip32Value(centralDirectorySize, "central directory size");
+    await writeAll(
+      fileHandle,
+      createEndOfCentralDirectory(entries.length, centralDirectorySize, centralDirectoryOffset),
+    );
+  } catch (error) {
+    operationError = error;
+  }
+
+  try {
+    await fileHandle.close();
+  } catch (closeError) {
+    if (operationError !== undefined) {
+      operationError = new AggregateError(
+        [operationError, closeError],
+        "Writing and closing the ZIP archive both failed.",
+        { cause: operationError },
+      );
+    } else {
+      operationError = closeError;
+    }
+  }
+
+  if (operationError !== undefined) {
+    try {
+      await rm(archive, { force: true });
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [operationError, cleanupError],
+        "Writing and cleaning up the ZIP archive both failed.",
+        { cause: operationError },
+      );
+    }
+    throw operationError;
+  }
+}
+
+function createCrc32Table(): Uint32Array {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < table.length; index++) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit++) {
+      value = (value & 1) === 1 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+}
+
+function updateCrc32(data: Uint8Array, previous: number): number {
+  if (typeof zlib.crc32 === "function") {
+    return zlib.crc32(data, previous);
+  }
+
+  let value = (previous ^ 0xffff_ffff) >>> 0;
+  for (const byte of data) {
+    value = crc32Table[(value ^ byte) & 0xff] ^ (value >>> 8);
+  }
+  return (value ^ 0xffff_ffff) >>> 0;
+}
+
+function encodeZipName(name: string): Uint8Array {
+  const normalizedName = name.replaceAll("\\", "/");
+  if (
+    normalizedName === "" ||
+    normalizedName.startsWith("/") ||
+    normalizedName.split("/").includes("..")
+  ) {
+    throw new Error(`Invalid ZIP entry name: ${JSON.stringify(name)}`);
+  }
+  const encoded = new TextEncoder().encode(normalizedName);
+  if (encoded.byteLength > 0xffff) {
+    throw new Error(`ZIP entry name is too long: ${JSON.stringify(name)}`);
+  }
+  return encoded;
+}
+
+function encodeDosDateTime(date: Date): {
+  modificationTime: number;
+  modificationDate: number;
+} {
+  const year = Math.min(2107, Math.max(1980, date.getFullYear()));
+  return {
+    modificationTime:
+      (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+    modificationDate: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+  };
+}
+
+function createLocalHeader(
+  name: Uint8Array,
+  modificationTime: number,
+  modificationDate: number,
+): Uint8Array {
+  const header = new Uint8Array(30 + name.byteLength);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, 0x0403_4b50, true);
+  view.setUint16(4, 20, true);
+  view.setUint16(6, utf8WithDataDescriptor, true);
+  view.setUint16(8, 8, true);
+  view.setUint16(10, modificationTime, true);
+  view.setUint16(12, modificationDate, true);
+  view.setUint16(26, name.byteLength, true);
+  header.set(name, 30);
+  return header;
+}
+
+function createDataDescriptor(
+  crc32: number,
+  compressedSize: number,
+  uncompressedSize: number,
+): Uint8Array {
+  const descriptor = new Uint8Array(16);
+  const view = new DataView(descriptor.buffer);
+  view.setUint32(0, 0x0807_4b50, true);
+  view.setUint32(4, crc32, true);
+  view.setUint32(8, compressedSize, true);
+  view.setUint32(12, uncompressedSize, true);
+  return descriptor;
+}
+
+function createCentralDirectoryHeader(entry: ZipEntry): Uint8Array {
+  const header = new Uint8Array(46 + entry.name.byteLength);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, 0x0201_4b50, true);
+  view.setUint16(4, 20, true);
+  view.setUint16(6, 20, true);
+  view.setUint16(8, utf8WithDataDescriptor, true);
+  view.setUint16(10, 8, true);
+  view.setUint16(12, entry.modificationTime, true);
+  view.setUint16(14, entry.modificationDate, true);
+  view.setUint32(16, entry.crc32, true);
+  view.setUint32(20, entry.compressedSize, true);
+  view.setUint32(24, entry.uncompressedSize, true);
+  view.setUint16(28, entry.name.byteLength, true);
+  view.setUint32(42, entry.localHeaderOffset, true);
+  header.set(entry.name, 46);
+  return header;
+}
+
+function createEndOfCentralDirectory(
+  entryCount: number,
+  centralDirectorySize: number,
+  centralDirectoryOffset: number,
+): Uint8Array {
+  const end = new Uint8Array(22);
+  const view = new DataView(end.buffer);
+  view.setUint32(0, 0x0605_4b50, true);
+  view.setUint16(8, entryCount, true);
+  view.setUint16(10, entryCount, true);
+  view.setUint32(12, centralDirectorySize, true);
+  view.setUint32(16, centralDirectoryOffset, true);
+  return end;
+}
+
+function assertZip32Value(value: number, label: string): void {
+  if (!Number.isSafeInteger(value) || value < 0 || value > maximumZip32Value) {
+    throw new Error(`Cannot create ZIP archive: ${label} exceeds the 4 GB ZIP32 limit.`);
+  }
+}
+
+async function writeAll(fileHandle: FileHandle, data: Uint8Array): Promise<void> {
+  let offset = 0;
+  while (offset < data.byteLength) {
+    const { bytesWritten } = await fileHandle.write(data.subarray(offset));
+    if (bytesWritten === 0) {
+      throw new Error("Could not write to ZIP archive.");
+    }
+    offset += bytesWritten;
+  }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+/**
+ * @module
+ *
+ * The Simple Data Analysis (Core) Library
+ *
+ * To install the library with Node.js, use:
+ * ```bash
+ * npm i @nshiab/simple-data-analysis-core
+ * ```
+ *
+ * To start, create a SimpleDB instance and then a SimpleTable from this instance:
+ * ```ts
+ * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
+ *
+ * const sdb = new SimpleDB();
+ * const table = await sdb
+ *   .newTable("myTable")
+ *   .loadData("path/to/your/data.csv")
+ *   .log();
+ *
+ * // You can now perform various data analysis operations on the table.
+ *
+ * await sdb.close(); // Ensure to close the database when you're finished.
+ * ```
+ */
+
+export { default as SimpleDB } from "./class/SimpleDB.ts";
+export { default as SimpleTable } from "./class/SimpleTable.ts";
+export { default as SDAError } from "./class/SDAError.ts";

package/src/methods/accumulate.ts

@@ -0,0 +1,64 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.ts";
+import assertNewColumns from "../helpers/assertNewColumns.ts";
+import stringToArray from "../helpers/stringToArray.ts";
+import mergeOptions from "../helpers/mergeOptions.ts";
+import queryDB from "../helpers/queryDB.ts";
+import queueOp from "../helpers/queueOp.ts";
+import type SimpleTable from "../class/SimpleTable.ts";
+
+export default function accumulate(
+  simpleTable: SimpleTable,
+  column: string,
+  newColumn: string,
+  options: {
+    by?: string | string[];
+  } = {},
+) {
+  // The accumulation order is based on rowid, which only exists on the
+  // materialized table, not on the output of a fused step: it executes as a
+  // barrier.
+  options = structuredClone(options);
+  queueOp(simpleTable, {
+    kind: "barrier",
+    method: "accumulate()",
+    parameters: { column, newColumn, options },
+    execute: async () => {
+      // A SELECT *, expr AS col colliding with an existing column would be
+      // silently renamed by DuckDB (col -> col_1) instead of erroring.
+      assertNewColumns(await simpleTable.getTypes(), [newColumn], "accumulate()");
+
+      await queryDB(
+        simpleTable,
+        accumulateQuery(simpleTable.name, column, newColumn, options),
+        mergeOptions(simpleTable, {
+          table: simpleTable.name,
+          method: "accumulate()",
+          parameters: { column, newColumn, options },
+        }),
+      );
+    },
+  });
+}
+
+function accumulateQuery(
+  table: string,
+  column: string,
+  newColumn: string,
+  options: {
+    by?: string | string[];
+  } = {},
+) {
+  const by = options.by ? stringToArray(options.by) : [];
+  const partition =
+    by.length > 0 ? `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")} ` : "";
+
+  const query = `CREATE OR REPLACE TABLE ${quoteIdentifier(
+    table,
+  )} AS SELECT *, SUM(${quoteIdentifier(
+    column,
+  )}) OVER (${partition}ORDER BY rowid) AS ${quoteIdentifier(newColumn)}
+    FROM ${quoteIdentifier(table)}
+    ORDER BY rowid;`;
+
+  return query;
+}

package/src/methods/addBoundingBox.ts

@@ -0,0 +1,35 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.ts";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.ts";
+import queueOp from "../helpers/queueOp.ts";
+import type SimpleTable from "../class/SimpleTable.ts";
+
+export default function addBoundingBox(
+  simpleTable: SimpleTable,
+  options: {
+    column?: string;
+    decimals?: number;
+  } = {},
+) {
+  options = structuredClone(options);
+  queueOp(simpleTable, {
+    kind: "fusable",
+    method: "addBoundingBox()",
+    parameters: { options },
+    needsSchema: true,
+    needsSpatial: true,
+    buildSelect: (input, types) => {
+      const column =
+        options.column ?? findGeoColumnFromSchema(types, "addBoundingBox()", simpleTable.name);
+      const round = (expression: string) =>
+        typeof options.decimals === "number"
+          ? `ROUND(${expression}, ${options.decimals})`
+          : expression;
+      return `SELECT *,
+    ${round(`ST_XMin(${quoteIdentifier(column)})`)} AS minLon,
+    ${round(`ST_YMin(${quoteIdentifier(column)})`)} AS minLat,
+    ${round(`ST_XMax(${quoteIdentifier(column)})`)} AS maxLon,
+    ${round(`ST_YMax(${quoteIdentifier(column)})`)} AS maxLat
+    FROM ${input}`;
+    },
+  });
+}