ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/greenplum/index.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Greenplum dialect implementation for the TypeScript ORM.
+ *
+ * Greenplum Database is a massively-parallel-processing (MPP) analytics
+ * database built by forking PostgreSQL (historically the 8.2/8.3 line, with
+ * later releases rebased onto PostgreSQL 9.x and 12). Because it speaks the
+ * PostgreSQL wire protocol and is largely SQL-compatible with it, this dialect
+ * extends {@link PostgresDialect} and reuses the same `pg` driver (default port
+ * 5432, exactly like Postgres — the coordinator/master segment listens on the
+ * standard Postgres port).
+ *
+ * Notable Greenplum-specific differences vs. plain PostgreSQL that this dialect
+ * models on top of the inherited Postgres behavior:
+ *
+ * - Distribution policy: every Greenplum table is physically distributed across
+ *   segments. `CREATE TABLE` accepts a trailing `DISTRIBUTED BY (cols)` /
+ *   `DISTRIBUTED RANDOMLY` / `DISTRIBUTED REPLICATED` clause. This dialect emits
+ *   that clause when a distribution option is supplied (see
+ *   {@link GreenplumDialect.buildDistributionClause}). To stay safe against
+ *   plain-Postgres targets it only emits the clause when explicitly asked; when
+ *   asked but under-specified it defaults to `DISTRIBUTED RANDOMLY`.
+ * - Append-optimized / column-oriented storage: Greenplum supports
+ *   append-optimized (AO) tables and column orientation with compression via a
+ *   table `WITH (appendoptimized=true, orientation=column, compresstype=zstd)`
+ *   storage clause (see {@link GreenplumDialect.buildStorageClause}).
+ * - Legacy partitioning: in addition to Postgres 10+ declarative partitioning
+ *   (inherited from the base dialect), Greenplum has its own older
+ *   `PARTITION BY RANGE(col) (START (...) END (...) EVERY (...))` syntax
+ *   (see {@link GreenplumDialect.buildRangePartitionClause}).
+ * - External tables: `CREATE EXTERNAL TABLE ... LOCATION ('gpfdist://...')
+ *   FORMAT '...'` exposes external data (e.g. served by the `gpfdist` file
+ *   distribution daemon) as a readable/writable table
+ *   (see {@link GreenplumDialect.buildExternalTableSQL}).
+ *
+ * Greenplum does NOT support some PostgreSQL features (e.g. `SERIAL` maps to a
+ * distributed sequence, no global secondary UNIQUE guarantees unless the
+ * distribution key is a subset of the constraint, no savepoints inside some
+ * plans). Those caveats are inherited-as-is from the Postgres behavior here and
+ * are out of scope for this dialect wrapper.
+ */
+import { PostgresDialect, PostgresDialectOptions } from '../postgres/index';
+import { ColumnDefinition, TableOptions } from '../dialect';
+/**
+ * Greenplum connection options. Identical to {@link PostgresDialectOptions}
+ * (the `pg` driver is reused unchanged); declared as its own alias so callers
+ * can name the Greenplum-specific type.
+ */
+export interface GreenplumDialectOptions extends PostgresDialectOptions {
+}
+/**
+ * A Greenplum range-partition specification for the legacy
+ * `PARTITION BY RANGE(col) (START (...) END (...) EVERY (...))` syntax.
+ *
+ * `start`, `end` and `every` are inlined as SQL literals: numbers verbatim,
+ * strings single-quoted (so a date string like `'2020-01-01'` works), and
+ * anything already wrapped in the caller's own SQL expression (detected by a
+ * leading keyword such as `INTERVAL` or a `func(...)` call) is emitted raw.
+ */
+export interface GreenplumRangePartitionSpec {
+    /** Inclusive lower bound of the first partition range. */
+    start: string | number;
+    /** Exclusive upper bound of the last partition range. */
+    end: string | number;
+    /** Step size between consecutive partitions (e.g. `1`, `"INTERVAL '1 month'"`). */
+    every?: string | number;
+    /** When true, emits `INCLUSIVE`/`EXCLUSIVE` — appended to END as EXCLUSIVE by default. */
+    inclusiveStart?: boolean;
+}
+/**
+ * Greenplum-specific `CREATE TABLE` options layered on top of the shared
+ * {@link TableOptions}. Distribution and append-optimized storage settings are
+ * Greenplum extensions with no PostgreSQL equivalent.
+ */
+export interface GreenplumTableOptions extends TableOptions {
+    /** `DISTRIBUTED BY (col, ...)` — hash-distribute rows on these columns. */
+    distributedBy?: string[];
+    /** `DISTRIBUTED RANDOMLY` — round-robin distribution across segments. */
+    distributedRandomly?: boolean;
+    /** `DISTRIBUTED REPLICATED` — full copy of the table on every segment. */
+    distributedReplicated?: boolean;
+    /** `WITH (appendoptimized=true)` — create an append-optimized (AO) table. */
+    appendOptimized?: boolean;
+    /** `orientation=row|column` storage parameter (implies append-optimized). */
+    orientation?: 'row' | 'column';
+    /** `compresstype=` storage parameter, e.g. `'zstd'`, `'zlib'`, `'rle_type'`, `'none'`. */
+    compressType?: 'zlib' | 'zstd' | 'rle_type' | 'quicklz' | 'none';
+    /** `compresslevel=` storage parameter (compression level, e.g. 1). */
+    compressLevel?: number;
+    /** `blocksize=` storage parameter for AO tables (bytes). */
+    blocksize?: number;
+    /** Table-level constraints emitted inside the column list (PRIMARY KEY / UNIQUE / FOREIGN KEY / CHECK). */
+    constraints?: GreenplumTableConstraint[];
+    /** `TABLESPACE name` — placed after storage/partitioning and before the DISTRIBUTED clause. */
+    tablespace?: string;
+}
+/** A table-level constraint for a Greenplum `CREATE TABLE` column list. */
+export interface GreenplumTableConstraint {
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+    /** Columns the constraint covers (not used for CHECK). */
+    fields?: string[];
+    /** Optional explicit constraint name (`CONSTRAINT "name" ...`). */
+    name?: string;
+    /** Referenced table/column for FOREIGN KEY constraints. */
+    references?: {
+        table: string;
+        field: string;
+    };
+    /** Raw boolean expression for CHECK constraints. */
+    expression?: string;
+}
+/**
+ * Options for {@link GreenplumDialect.buildExternalTableSQL}.
+ */
+export interface GreenplumExternalTableOptions {
+    /**
+     * One or more external `LOCATION` URIs, e.g.
+     * `['gpfdist://etl-host:8081/data/*.csv']`. Required — an external table has
+     * no local storage, only these locations.
+     */
+    locations: string[];
+    /** External data format. Defaults to `'TEXT'`. */
+    format?: 'TEXT' | 'CSV' | 'CUSTOM' | 'AVRO' | 'PARQUET';
+    /** Emit `WRITABLE EXTERNAL TABLE` instead of the default readable one. */
+    writable?: boolean;
+    /** Emit `EXTERNAL WEB TABLE` (`http://` / `EXECUTE` sourced). */
+    web?: boolean;
+    /** `FORMAT '...' (DELIMITER '...')` — column delimiter for TEXT/CSV. */
+    delimiter?: string;
+    /** Whether the CSV/TEXT source's first row is a header to skip. */
+    header?: boolean;
+    /** Encoding name for the external data, e.g. `'UTF8'`. */
+    encoding?: string;
+    /** `LOG ERRORS` clause: route malformed rows to the error log. */
+    logErrors?: boolean;
+    /** `SEGMENT REJECT LIMIT n [ROWS|PERCENT]` reject threshold. */
+    rejectLimit?: number;
+    /** Unit for `SEGMENT REJECT LIMIT`. Defaults to `'ROWS'`. */
+    rejectLimitType?: 'ROWS' | 'PERCENT';
+    /** If true, uses `CREATE EXTERNAL TABLE IF NOT EXISTS` (not valid in all GP versions). */
+    ifNotExists?: boolean;
+}
+/**
+ * Greenplum dialect class. Extends {@link PostgresDialect}, overriding the
+ * `CREATE TABLE` builder to append Greenplum distribution/storage clauses and
+ * adding helpers for legacy range partitioning and external tables.
+ */
+export declare class GreenplumDialect extends PostgresDialect {
+    readonly name: string;
+    readonly library: string;
+    constructor(config: GreenplumDialectOptions);
+    /**
+     * Build the trailing `DISTRIBUTED ...` clause for a Greenplum `CREATE TABLE`.
+     *
+     * Returns an empty string when no distribution option is supplied, so callers
+     * that never set one produce plain-Postgres-compatible DDL. When a
+     * distribution intent is expressed but under-specified (e.g. an empty
+     * `distributedBy` array), it falls back to `DISTRIBUTED RANDOMLY`.
+     *
+     * @returns e.g. `DISTRIBUTED BY ("id")`, `DISTRIBUTED RANDOMLY`,
+     *   `DISTRIBUTED REPLICATED`, or `''`.
+     */
+    buildDistributionClause(options?: GreenplumTableOptions): string;
+    /**
+     * Build the `WITH (...)` storage clause for append-optimized / column-
+     * oriented Greenplum tables. Returns `''` unless append-optimized storage is
+     * requested (via `appendOptimized`, a non-`row` `orientation`, or any of the
+     * compression parameters).
+     *
+     * @returns e.g. `WITH (appendoptimized=true, orientation=column, compresstype=zstd)`.
+     */
+    buildStorageClause(options?: GreenplumTableOptions): string;
+    /**
+     * Synchronously build the full Greenplum `CREATE TABLE` statement, including
+     * the append-optimized storage `WITH (...)` clause and the trailing
+     * `DISTRIBUTED ...` clause. Exposed as a sync builder so callers (and tests)
+     * can inspect the emitted SQL without a live connection.
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options?: GreenplumTableOptions): string;
+    /**
+     * Build a single table-level constraint clause for the CREATE TABLE column
+     * list, e.g. `CONSTRAINT "pk_orders" PRIMARY KEY ("id")` or
+     * `FOREIGN KEY ("customer_id") REFERENCES "customers"("id")`.
+     */
+    buildTableConstraintSql(c: GreenplumTableConstraint): string;
+    /**
+     * Greenplum (Postgres 8/9-derived) does not implement `INSERT ... ON
+     * CONFLICT`. Refuse an upsert INSERT with a clear error pointing callers at
+     * {@link GreenplumDialect.buildUpsertQuery}'s staging-table strategy. Plain
+     * (non-upsert) inserts delegate to the inherited PostgreSQL builder.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: Parameters<PostgresDialect['buildInsertQuery']>[2]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a Greenplum-compatible upsert as a staging-table batch (no
+     * `ON CONFLICT`):
+     *
+     *   CREATE TEMP TABLE "<t>_gp_upsert_stg" (LIKE "<t>") ON COMMIT DROP;
+     *   INSERT INTO "<t>_gp_upsert_stg" (cols) VALUES (...);
+     *   DELETE FROM "<t>" USING stg WHERE "<t>".k = stg.k [AND ...];
+     *   INSERT INTO "<t>" (writeCols) SELECT writeCols FROM stg [RETURNING ...];
+     *   [DROP TABLE stg]   -- only when no RETURNING (RETURNING must be the last statement)
+     *
+     * `writeCols` is the conflict keys plus `updateOnDuplicate` when given,
+     * otherwise every provided column.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: Parameters<PostgresDialect['buildUpsertQuery']>[2]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Create a new table, emitting Greenplum distribution and append-optimized
+     * storage clauses. Overrides {@link PostgresDialect.createTable}.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: GreenplumTableOptions): Promise<void>;
+    /**
+     * Build a single column definition for a Greenplum `CREATE TABLE`. Mirrors
+     * the common subset of the Postgres column builder (which is private on the
+     * base class): type, NOT NULL, DEFAULT, PRIMARY KEY, UNIQUE, and references.
+     */
+    private buildGreenplumColumnSql;
+    /**
+     * Build Greenplum's legacy `PARTITION BY RANGE(col) (START (...) END (...)
+     * EVERY (...))` clause (distinct from Postgres 10+ declarative partitioning,
+     * which the base dialect handles via `PARTITION BY RANGE (col)`).
+     *
+     * @param column - The range-partition key column.
+     * @param spec - Start/end bounds and optional `EVERY` step.
+     * @returns e.g.
+     *   `PARTITION BY RANGE(sale_date) (START ('2020-01-01') END ('2021-01-01') EVERY (INTERVAL '1 month'))`.
+     */
+    buildRangePartitionClause(column: string, spec: GreenplumRangePartitionSpec): string;
+    /**
+     * Format a range-partition bound value as a SQL literal: numbers verbatim,
+     * already-expression strings (INTERVAL / DATE / TIMESTAMP keyword or a
+     * `func(...)` call) raw, and any other string single-quoted.
+     */
+    private formatPartitionBound;
+    /**
+     * Build a Greenplum `CREATE EXTERNAL TABLE` statement. External tables expose
+     * data served over `gpfdist://`, `http://`, `s3://`, etc. as a queryable
+     * (and optionally writable) table with no local segment storage.
+     *
+     * @param tableName - Name of the external table to create.
+     * @param columns - Column definitions (types only; no distribution/constraints).
+     * @param options - External-table options (locations, format, writable, ...).
+     * @returns e.g.
+     *   `CREATE EXTERNAL TABLE "ext_sales" (...) LOCATION ('gpfdist://host:8081/sales/*.csv') FORMAT 'CSV' (DELIMITER ',' HEADER)`.
+     */
+    buildExternalTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options: GreenplumExternalTableOptions): string;
+    /**
+     * Create an external table by executing the statement built by
+     * {@link GreenplumDialect.buildExternalTableSQL}.
+     */
+    createExternalTable(tableName: string, columns: Record<string, ColumnDefinition>, options: GreenplumExternalTableOptions): Promise<void>;
+    /**
+     * Build an `ALTER TABLE ... SET [WITH (REORGANIZE=true)] DISTRIBUTED ...`
+     * statement to change a table's distribution policy. Redistributing existing
+     * data requires `reorganize: true` (the default here) — without it Greenplum
+     * only records the new policy for *future* data, leaving already-stored rows
+     * on their original segments.
+     *
+     * @returns e.g. `ALTER TABLE "t" SET WITH (REORGANIZE=true) DISTRIBUTED BY ("id")`.
+     */
+    buildSetDistributionSQL(tableName: string, options: Pick<GreenplumTableOptions, 'distributedBy' | 'distributedRandomly' | 'distributedReplicated'> & {
+        reorganize?: boolean;
+    }): string;
+    /**
+     * Change a table's distribution policy (see
+     * {@link GreenplumDialect.buildSetDistributionSQL}).
+     */
+    setDistribution(tableName: string, options: Pick<GreenplumTableOptions, 'distributedBy' | 'distributedRandomly' | 'distributedReplicated'> & {
+        reorganize?: boolean;
+    }): Promise<void>;
+    /**
+     * Build a Greenplum `CREATE TABLE <name> [WITH (...)] AS <query>
+     * [DISTRIBUTED ...]` statement. The append-optimized/columnar storage
+     * `WITH (...)` clause and the trailing `DISTRIBUTED ...` clause are emitted
+     * from the same options as {@link GreenplumDialect.buildCreateTableSQL}.
+     */
+    buildCreateTableAsSQL(tableName: string, query: string, options?: GreenplumTableOptions): string;
+    /**
+     * Materialize a query result into a new table via `CREATE TABLE ... AS`
+     * (see {@link GreenplumDialect.buildCreateTableAsSQL}).
+     */
+    createTableAs(tableName: string, query: string, options?: GreenplumTableOptions): Promise<void>;
+    /**
+     * Build an `ALTER TABLE ... ADD PARTITION name START (...) END (...)
+     * [EVERY (...)]` statement for Greenplum's legacy partitioning.
+     */
+    buildAddRangePartitionSQL(tableName: string, partitionName: string, spec: GreenplumRangePartitionSpec): string;
+    /**
+     * Add a range partition to a legacy-partitioned Greenplum table.
+     */
+    addRangePartition(tableName: string, partitionName: string, spec: GreenplumRangePartitionSpec): Promise<void>;
+    /**
+     * Drop a named partition of a legacy-partitioned table via
+     * `ALTER TABLE ... DROP PARTITION [IF EXISTS] name`.
+     */
+    dropRangePartition(tableName: string, partitionName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Fast-empty a single partition via `ALTER TABLE ... TRUNCATE PARTITION name`
+     * (keeps the partition, drops its data).
+     */
+    truncateRangePartition(tableName: string, partitionName: string): Promise<void>;
+    /**
+     * Run `VACUUM [FULL] [ANALYZE] [table]`. `full: true` rewrites the table to
+     * reclaim maximum space (holds an exclusive lock); the default lightweight
+     * vacuum only reclaims what it can in place.
+     */
+    vacuumTable(tableName?: string, options?: {
+        full?: boolean;
+        analyze?: boolean;
+    }): Promise<void>;
+    /**
+     * Run `ANALYZE [table [(columns)]]` to refresh planner statistics for a
+     * table (or the whole database when `tableName` is omitted).
+     */
+    analyzeTable(tableName?: string, columns?: string[]): Promise<void>;
+    /**
+     * Fast-empty a table via `TRUNCATE [ONLY] table [CASCADE] [RESTART IDENTITY]`.
+     */
+    truncateTable(tableName: string, options?: {
+        cascade?: boolean;
+        restartIdentity?: boolean;
+        only?: boolean;
+    }): Promise<void>;
+}
+/**
+ * Create a new Greenplum dialect instance.
+ */
+export declare function createGreenplumDialect(options?: GreenplumDialectOptions): GreenplumDialect;
+export default GreenplumDialect;

package/dist/dialects/greenplum/index.js

@@ -446,6 +446,174 @@ class GreenplumDialect extends index_1.PostgresDialect {
     async createExternalTable(tableName, columns, options) {
         await this.query(this.buildExternalTableSQL(tableName, columns, options));
     }
+    // ==========================================================================
+    // Distribution policy changes
+    // ==========================================================================
+    /**
+     * Build an `ALTER TABLE ... SET [WITH (REORGANIZE=true)] DISTRIBUTED ...`
+     * statement to change a table's distribution policy. Redistributing existing
+     * data requires `reorganize: true` (the default here) — without it Greenplum
+     * only records the new policy for *future* data, leaving already-stored rows
+     * on their original segments.
+     *
+     * @returns e.g. `ALTER TABLE "t" SET WITH (REORGANIZE=true) DISTRIBUTED BY ("id")`.
+     */
+    buildSetDistributionSQL(tableName, options) {
+        const distribution = this.buildDistributionClause(options);
+        if (!distribution) {
+            throw new Error('buildSetDistributionSQL: a distribution target is required ' +
+                '(distributedBy, distributedRandomly, or distributedReplicated).');
+        }
+        const reorganize = options.reorganize !== false;
+        const withClause = reorganize ? ' SET WITH (REORGANIZE=true)' : ' SET';
+        return `ALTER TABLE ${this.escapeId(tableName)}${withClause} ${distribution}`;
+    }
+    /**
+     * Change a table's distribution policy (see
+     * {@link GreenplumDialect.buildSetDistributionSQL}).
+     */
+    async setDistribution(tableName, options) {
+        await this.query(this.buildSetDistributionSQL(tableName, options));
+    }
+    // ==========================================================================
+    // CREATE TABLE AS (CTAS) — analytics-common materialization of a query
+    // result into a new distributed/append-optimized table.
+    // ==========================================================================
+    /**
+     * Build a Greenplum `CREATE TABLE <name> [WITH (...)] AS <query>
+     * [DISTRIBUTED ...]` statement. The append-optimized/columnar storage
+     * `WITH (...)` clause and the trailing `DISTRIBUTED ...` clause are emitted
+     * from the same options as {@link GreenplumDialect.buildCreateTableSQL}.
+     */
+    buildCreateTableAsSQL(tableName, query, options) {
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        const storage = this.buildStorageClause(options);
+        if (storage) {
+            sql += ` ${storage}`;
+        }
+        if (options?.tablespace) {
+            sql += ` TABLESPACE ${options.tablespace}`;
+        }
+        sql += ` AS ${query}`;
+        const distribution = this.buildDistributionClause(options);
+        if (distribution) {
+            sql += ` ${distribution}`;
+        }
+        return sql;
+    }
+    /**
+     * Materialize a query result into a new table via `CREATE TABLE ... AS`
+     * (see {@link GreenplumDialect.buildCreateTableAsSQL}).
+     */
+    async createTableAs(tableName, query, options) {
+        await this.query(this.buildCreateTableAsSQL(tableName, query, options));
+    }
+    // ==========================================================================
+    // Legacy range-partition maintenance (ALTER TABLE ... {ADD|DROP|TRUNCATE|
+    // SPLIT} PARTITION), distinct from Postgres 10+ declarative partitioning the
+    // base dialect exposes via createPartition/attachPartition/etc.
+    // ==========================================================================
+    /**
+     * Build an `ALTER TABLE ... ADD PARTITION name START (...) END (...)
+     * [EVERY (...)]` statement for Greenplum's legacy partitioning.
+     */
+    buildAddRangePartitionSQL(tableName, partitionName, spec) {
+        const startBound = this.formatPartitionBound(spec.start);
+        const endBound = this.formatPartitionBound(spec.end);
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD PARTITION ${this.escapeId(partitionName)}`;
+        sql += ` START (${startBound})${spec.inclusiveStart ? ' INCLUSIVE' : ''}`;
+        sql += ` END (${endBound}) EXCLUSIVE`;
+        if (spec.every !== undefined) {
+            sql += ` EVERY (${this.formatPartitionBound(spec.every)})`;
+        }
+        return sql;
+    }
+    /**
+     * Add a range partition to a legacy-partitioned Greenplum table.
+     */
+    async addRangePartition(tableName, partitionName, spec) {
+        await this.query(this.buildAddRangePartitionSQL(tableName, partitionName, spec));
+    }
+    /**
+     * Drop a named partition of a legacy-partitioned table via
+     * `ALTER TABLE ... DROP PARTITION [IF EXISTS] name`.
+     */
+    async dropRangePartition(tableName, partitionName, options) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} DROP PARTITION`;
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(partitionName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Fast-empty a single partition via `ALTER TABLE ... TRUNCATE PARTITION name`
+     * (keeps the partition, drops its data).
+     */
+    async truncateRangePartition(tableName, partitionName) {
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} TRUNCATE PARTITION ${this.escapeId(partitionName)}`);
+    }
+    // ==========================================================================
+    // Maintenance — VACUUM / ANALYZE / TRUNCATE.
+    //
+    // Greenplum inherits Postgres autovacuum for catalog tables, but bulk
+    // append-optimized/analytics tables commonly need explicit VACUUM (to
+    // recover space from the AO visibility map after DELETE/UPDATE) and ANALYZE
+    // (the planner has no auto-analyze on user data at scale).
+    // ==========================================================================
+    /**
+     * Run `VACUUM [FULL] [ANALYZE] [table]`. `full: true` rewrites the table to
+     * reclaim maximum space (holds an exclusive lock); the default lightweight
+     * vacuum only reclaims what it can in place.
+     */
+    async vacuumTable(tableName, options) {
+        let sql = 'VACUUM';
+        if (options?.full) {
+            sql += ' FULL';
+        }
+        if (options?.analyze) {
+            sql += ' ANALYZE';
+        }
+        if (tableName) {
+            sql += ` ${this.escapeId(tableName)}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Run `ANALYZE [table [(columns)]]` to refresh planner statistics for a
+     * table (or the whole database when `tableName` is omitted).
+     */
+    async analyzeTable(tableName, columns) {
+        let sql = 'ANALYZE';
+        if (tableName) {
+            sql += ` ${this.escapeId(tableName)}`;
+            if (columns && columns.length > 0) {
+                sql += ` (${columns.map((c) => this.escapeId(c)).join(', ')})`;
+            }
+        }
+        await this.query(sql);
+    }
+    /**
+     * Fast-empty a table via `TRUNCATE [ONLY] table [CASCADE] [RESTART IDENTITY]`.
+     */
+    async truncateTable(tableName, options) {
+        let sql = 'TRUNCATE';
+        if (options?.only) {
+            sql += ' ONLY';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        if (options?.restartIdentity) {
+            sql += ' RESTART IDENTITY';
+        }
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+    }
 }
 exports.GreenplumDialect = GreenplumDialect;
 /**