ts-prorm-orm 1.1.0 → 1.2.1

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

@@ -0,0 +1,512 @@
+/**
+ * SAP HANA dialect implementation for the TypeScript ORM.
+ * Uses the `hdb` driver - SAP's pure-JavaScript, callback-based HANA client
+ * (no native bindings, no bundled TypeScript types - see `src/dialects/hana/hdb.d.ts`
+ * for the minimal ambient shim written for it).
+ *
+ * Notable SAP HANA SQL characteristics implemented here:
+ *  - Double-quoted, case-sensitive delimited identifiers (unquoted
+ *    identifiers are folded to uppercase by HANA, like Oracle/Db2).
+ *  - `LIMIT n OFFSET m` for pagination (standard, unlike Oracle/Db2's
+ *    `OFFSET ... FETCH FIRST ...`) - HANA additionally requires a `LIMIT`
+ *    whenever `OFFSET` is used, so a sentinel max `LIMIT` is emitted when
+ *    only an offset is supplied.
+ *  - `CREATE COLUMN TABLE` / `CREATE ROW TABLE` - HANA's column-store
+ *    (default, controlled here via `TableOptions.columnStore`, default
+ *    `true`) vs row-store table creation.
+ *  - `GENERATED ALWAYS AS IDENTITY` for auto-increment columns.
+ *  - `CREATE SEQUENCE` / `<sequence>.NEXTVAL` (via the single-row `DUMMY`
+ *    pseudo-table, HANA's equivalent of Oracle's `DUAL`) for sequences.
+ *  - Native `UPSERT <table> (...) VALUES (...) WITH PRIMARY KEY` statement
+ *    (a genuine HANA-only construct, distinct from the `MERGE INTO` every
+ *    other enterprise dialect here uses for upserts) plus full `MERGE INTO
+ *    ... WHEN MATCHED / WHEN NOT MATCHED` support for more complex cases.
+ *  - Parenthesized, multi-column `ALTER TABLE ... ADD (...)` / `DROP (...)`
+ *    / `ALTER (...)` column DDL, and a dedicated `RENAME COLUMN t.old TO
+ *    new` statement - all distinct from the single-column-at-a-time ALTER
+ *    syntax used by most other dialects.
+ *  - Mature `WITH` CTE (including recursive) and window/OLAP function
+ *    support.
+ *  - HANA-specific types: `NVARCHAR`, `SHORTTEXT`, `ALPHANUM`, `SECONDDATE`,
+ *    `TINYINT`, `ST_GEOMETRY`/`ST_POINT` (spatial).
+ *
+ * Explicitly out of scope (not meaningful for a CRUD-oriented relational
+ * ORM layer):
+ *  - `CREATE CALCULATION SCENARIO` / graphical Calculation Views - these are
+ *    modeled objects normally authored in HANA's web-based modeler /
+ *    Business Application Studio, not plain SQL DDL a CRUD ORM would emit.
+ *  - Legacy `CE_` (Calculation Engine) functions - deprecated by SAP since
+ *    HANA SPS09 in favor of plain SQL, and never had a "create" step an ORM
+ *    would need to manage.
+ *  - Full Smart Data Access federation (`CREATE REMOTE SOURCE` / `CREATE
+ *    VIRTUAL TABLE`) - HANA's real analogue of a Postgres Foreign Data
+ *    Wrapper, but out of scope for the generic (Postgres-shaped) FDW
+ *    interface threaded through the shared `Dialect` type; the FDW methods
+ *    below throw with a pointer to the real HANA feature instead of forcing
+ *    a lossy 1:1 mapping.
+ */
+import type * as hdb from 'hdb';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, IndexDefinition, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, DropSchemaOptions, ViewOptions, DropViewOptions, ConstraintDefinition, DropConstraintOptions, BuildOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, ExtensionInfo, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions, DropIndexOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, StreamOptions } from '../../types';
+import { Readable } from 'stream';
+/**
+ * SAP HANA dialect options.
+ *
+ * `port` defaults to `30015` - by SAP convention this is `3<instance
+ * number>15`, the SQL port of the tenant database's index server on a
+ * multi-database container (MDC) system using the default instance number
+ * `00` (`30013` is the equivalent port for the *system* database on the same
+ * instance; `30115`/`30117` etc. follow the same pattern for instance `01`).
+ */
+export interface HanaDialectOptions extends DialectOptions {
+    /** Default schema for unqualified table/object references. */
+    schema?: string;
+    /** Enable TLS for the connection (passed through to hdb as `useTLS`). */
+    useTLS?: boolean;
+    /** Additional raw hdb.createClient() options passed through verbatim. */
+    extraOptions?: Record<string, unknown>;
+}
+/** Options describing a recursive common table expression (see Db2/Oracle dialects for the same shape). */
+export interface RecursiveCteOptions {
+    name: string;
+    columns?: string[];
+    baseQuery: string;
+    recursiveQuery: string;
+    unionAll?: boolean;
+}
+/** Options describing an OLAP window/analytic function call. */
+export interface WindowFunctionOptions {
+    fn: string;
+    args?: string[];
+    partitionBy?: string | string[];
+    orderBy?: (string | {
+        column: string;
+        direction?: 'ASC' | 'DESC';
+    })[];
+    frame?: string;
+}
+/**
+ * Result of parsing `SYS.M_DATABASE.VERSION` to distinguish HANA Cloud
+ * (continuously-delivered, `4.x`-prefixed versions, e.g.
+ * `4.00.000.00.1234567890`) from on-premise HANA 2.0 SPS releases (`2.x`,
+ * e.g. `2.00.059.00.1234567890`, where the third segment encodes the
+ * SPS/revision) or legacy HANA 1.0 (`1.x`). `edition` is `'unknown'` when
+ * the version string doesn't match the expected `major.minor.revision`
+ * shape at all (e.g. an empty/placeholder value).
+ */
+/**
+ * The object form of `TableOptions.systemVersioning` (the shared type also
+ * allows a plain `boolean`, matching dialects like MariaDB/SQL Server that
+ * only need an on/off switch). HANA always needs at least the period-column
+ * defaults, so `createTable`/`alterTableSystemVersioning` normalize a bare
+ * `true` down to `{}` via `normalizeSystemVersioningOptions()` below.
+ */
+export type HanaSystemVersioningOptions = Exclude<TableOptions['systemVersioning'], boolean | undefined>;
+export interface HanaEditionInfo {
+    edition: 'cloud' | 'on-premise' | 'unknown';
+    /** Raw, unparsed value returned by `SYS.M_DATABASE.VERSION`. */
+    version: string;
+    major?: number;
+    minor?: number;
+    revision?: number;
+}
+/** A `SELECT` attribute entry representing an aliased window-function expression. */
+export interface WindowAttribute {
+    window: WindowFunctionOptions;
+    as: string;
+}
+type HdbClient = hdb.HdbClient;
+/**
+ * SAP HANA dialect class implementing the shared Dialect interface.
+ */
+export declare class HanaDialect implements Dialect {
+    readonly name = "hana";
+    readonly library = "hdb";
+    private client;
+    private _isConnected;
+    private config;
+    constructor(config: HanaDialectOptions);
+    private createClient;
+    private connectClient;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getConnection(): HdbClient | null;
+    isConnected(): boolean;
+    /**
+     * Execute `sql` against a specific hdb client, normalizing hdb's
+     * three-shaped callback result (nothing for DDL, an affected-row count
+     * for DML, an array of rows for a query) into the shared `QueryResult`
+     * shape.
+     *
+     * `CALL` statements are a distinct fourth shape (see README "Calling
+     * Stored Procedures"): hdb always invokes the callback as
+     * `cb(err, parameters, ...resultSets)` - a scalar OUT/INOUT parameters
+     * object (`{}` if none are declared) followed by zero or more result-set
+     * row arrays. Since `parameters` is a plain object rather than an array,
+     * it must be handled separately from the DML/query branches above or it
+     * silently falls into the `{ rowCount: 0, rows: [] }` default and both the
+     * output parameters and any result sets are lost.
+     */
+    private executeOnClient;
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql: string, options?: StreamOptions): Readable;
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    escape(value: any): string;
+    private formatTimestamp;
+    /**
+     * HANA uses double-quoted, case-sensitive delimited identifiers.
+     * Unquoted identifiers are folded to uppercase by HANA, so identifiers
+     * created via quoteIdentifier()/escapeId() must always be quoted the same
+     * way on every reference.
+     */
+    escapeId(identifier: unknown): string;
+    quoteIdentifier(identifier: string): string;
+    quoteTable(tableName: string, schema?: string): string;
+    /**
+     * Build a `SCHEMA_NAME` predicate for `SYS.*` catalog-view introspection
+     * queries. Without this, queries filtered only by e.g. `TABLE_NAME` match
+     * every same-named table across every schema on a multi-schema HANA
+     * system, silently merging/corrupting metadata. Scopes to the configured
+     * default schema when set, otherwise to the session's `CURRENT_SCHEMA`
+     * (mirrors the fallback `quoteTable()` uses for unqualified references).
+     */
+    private schemaFilterSql;
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Parses `SYS.M_DATABASE.VERSION` to tell HANA Cloud apart from
+     * on-premise HANA. HANA Cloud is continuously delivered and reports a
+     * `4.x`-prefixed version (e.g. `4.00.000.00.1234567890`); on-premise HANA
+     * 2.0 SPS releases report `2.x` (e.g. `2.00.059.00.1234567890`, where the
+     * `059` third segment is the SPS/revision number) and legacy HANA 1.0
+     * reports `1.x`. This is purely additive metadata for callers that want
+     * to branch on edition-specific feature availability (e.g. Cloud-only
+     * features) - it doesn't change behavior of any existing method.
+     */
+    getEditionInfo(): Promise<HanaEditionInfo>;
+    /** Convenience wrapper over `getEditionInfo()` for the common case of a boolean check. */
+    isCloudEdition(): Promise<boolean>;
+    createSchema(schema: string): Promise<void>;
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    showAllSchemas(): Promise<string[]>;
+    listSchemas(): Promise<string[]>;
+    createDatabaseSQL(options: {
+        name: string;
+    }): string;
+    dropDatabaseSQL(name: string): string;
+    createSavepointSQL(name?: string): string;
+    releaseSavepointSQL(name: string): string;
+    rollbackToSavepointSQL(name: string): string;
+    createExtension(): Promise<void>;
+    dropExtension(): Promise<void>;
+    getExtensions(): Promise<ExtensionInfo[]>;
+    hasExtension(): Promise<boolean>;
+    private buildColumnDefinition;
+    private buildConstraintSql;
+    /**
+     * Normalizes `TableOptions.systemVersioning` - which may be a bare
+     * `boolean` (the shared shape also used by MariaDB/SQL Server-style
+     * dialects) or a HANA-specific `{ historyTable?, validFromColumn?,
+     * validToColumn? }` config object - down to `undefined` (versioning off)
+     * or a config object (versioning on, using period-column defaults when a
+     * bare `true` was passed).
+     */
+    private normalizeSystemVersioningOptions;
+    /**
+     * Builds the three DDL fragments HANA needs for a system-versioned
+     * (temporal) table: the `GENERATED ALWAYS AS ROW START`/`ROW END` period
+     * columns and the `PERIOD FOR SYSTEM_TIME (...)` clause. Shared between
+     * `createTable` (inline, inside the column list) and
+     * `alterTableSystemVersioning` (issued as separate `ALTER TABLE`
+     * statements against an existing table).
+     *
+     * Only `TIMESTAMP` is a valid period-column type in HANA, and the
+     * precision is fixed at `TIMESTAMP(6)` (microseconds) to match SAP's own
+     * examples for `PERIOD FOR SYSTEM_TIME`.
+     */
+    private buildSystemVersioningPeriodSql;
+    /**
+     * Create a table. HANA tables are column-store by default; pass
+     * `{ columnStore: false }` (an extra, HANA-specific option threaded
+     * through the shared `TableOptions` as an untyped property, the same
+     * pattern other dialect files use for their own extensions) to create a
+     * legacy row-store table instead via `CREATE ROW TABLE`.
+     *
+     * `options.systemVersioning` opts the table into HANA's system-versioned
+     * (temporal history) support: the row-start/row-end period columns and
+     * `PERIOD FOR SYSTEM_TIME (...)` clause are appended to the column list,
+     * and the statement is closed with `WITH SYSTEM VERSIONING [HISTORY TABLE
+     * ...]`, e.g.:
+     *   CREATE COLUMN TABLE "t" (..., "valid_from" TIMESTAMP(6) NOT NULL
+     *   GENERATED ALWAYS AS ROW START, "valid_to" TIMESTAMP(6) NOT NULL
+     *   GENERATED ALWAYS AS ROW END, PERIOD FOR SYSTEM_TIME ("valid_from",
+     *   "valid_to")) WITH SYSTEM VERSIONING HISTORY TABLE "t_history"
+     * When `historyTable` is omitted the `HISTORY TABLE` clause is left off
+     * entirely and HANA auto-generates (and manages) the history table itself.
+     * System-versioned tables are only supported on column-store tables, so
+     * this throws if combined with `{ columnStore: false }`.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Enables system-versioning (temporal history) on an *already-existing*
+     * table. Unlike `CREATE TABLE ... WITH SYSTEM VERSIONING`, HANA has no
+     * single-statement form for retrofitting an existing table - the
+     * row-start/row-end period columns, the `PERIOD FOR SYSTEM_TIME` clause,
+     * and the `SYSTEM VERSIONING` clause itself must each be added via their
+     * own `ALTER TABLE` statement, in this order:
+     *   ALTER TABLE "t" ADD ("valid_from" TIMESTAMP(6) NOT NULL GENERATED ALWAYS AS ROW START)
+     *   ALTER TABLE "t" ADD ("valid_to" TIMESTAMP(6) NOT NULL GENERATED ALWAYS AS ROW END)
+     *   ALTER TABLE "t" ADD PERIOD FOR SYSTEM_TIME ("valid_from", "valid_to")
+     *   ALTER TABLE "t" ADD SYSTEM VERSIONING [HISTORY TABLE "t_history"]
+     * As with `createTable`, an omitted `historyTable` leaves the `HISTORY
+     * TABLE` clause off and lets HANA auto-generate/manage the history table.
+     */
+    alterTableSystemVersioning(tableName: string, options?: HanaSystemVersioningOptions): Promise<void>;
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * HANA range/hash partitioning is expressed via a `PARTITION BY` clause on
+     * the `CREATE (COLUMN|ROW) TABLE` statement itself. HANA also supports
+     * `ROUNDROBIN` partitioning, which isn't modeled by the shared
+     * `partitionBy.type` union.
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        partitions?: {
+            name: string;
+            bound?: {
+                from: string | number | Date;
+                to?: string | number | Date;
+            };
+        }[];
+    }): Promise<void>;
+    private formatPartitionValue;
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    attachPartition(_options: AttachPartitionOptions): Promise<void>;
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    dropPartition(partitionName: string): Promise<void>;
+    /**
+     * Bulk insert records. HANA supports multi-row `VALUES (...), (...), ...`
+     * in a single `INSERT INTO` statement (as does most SQL-2003-compliant
+     * engines), so all rows are sent in one statement.
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], options?: {
+        schema?: string;
+    }): Promise<QueryResult>;
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    showViews(): Promise<string[]>;
+    createMaterializedView(_options: MaterializedViewOptions): Promise<void>;
+    refreshMaterializedView(_viewName: string, _options?: RefreshOptions): Promise<void>;
+    dropMaterializedView(_viewName: string, _options?: DropMaterializedViewOptions): Promise<void>;
+    hasMaterializedView(_viewName: string): Promise<boolean>;
+    showMaterializedViews(): Promise<string[]>;
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /** HANA's dedicated column-rename statement: `RENAME COLUMN t.old TO new`. */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: string;
+        onUpdate?: string;
+    }): Promise<void>;
+    describeTable(tableName: string): Promise<TableDescription>;
+    renameTable(oldName: string, newName: string): Promise<void>;
+    showTables(): Promise<string[]>;
+    showConstraints(tableName: string): Promise<any[]>;
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    showIndexes(tableName: string): Promise<any[]>;
+    private buildCreateIndexSql;
+    addIndex(tableName: string, indexName: string, fields: string[], options?: IndexOptions): Promise<void>;
+    removeIndex(_tableName: string, indexName: string): Promise<void>;
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    dropIndex(tableName: string, indexName: string, _options?: DropIndexOptions): Promise<void>;
+    createFulltextIndex(tableName: string, indexName: string, fields: string[], _options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    createPartialIndex(): Promise<void>;
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    dropConstraint(tableName: string, constraintName: string, _options?: DropConstraintOptions): Promise<void>;
+    changeOwner(): Promise<void>;
+    createForeignDataWrapper(): Promise<void>;
+    dropForeignDataWrapper(): Promise<void>;
+    createForeignServer(): Promise<void>;
+    dropForeignServer(): Promise<void>;
+    createForeignTable(): Promise<void>;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string): string;
+    createUserMapping(): Promise<void>;
+    dropUserMapping(): Promise<void>;
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    buildDropForeignTableQuery(_tableName: string): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    getServersQuery(): string;
+    createSecurityPolicy(): Promise<void>;
+    dropSecurityPolicy(): Promise<void>;
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    commitTransaction(transaction: Transaction): Promise<void>;
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    getDataTypeSql(dataType: DataType): string;
+    private mapDataType;
+    buildWhereClause(where: WhereOptions, _options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildOrderClause(order: Order, _options?: BuildOptions): string;
+    /**
+     * HANA pagination uses the standard `LIMIT n OFFSET m` clause (unlike
+     * Oracle/Db2's `OFFSET ... FETCH FIRST ...`). Unlike PostgreSQL/MySQL,
+     * HANA does not allow a bare `OFFSET` without a `LIMIT` - when only an
+     * offset is supplied, a sentinel maximum `LIMIT` is emitted alongside it.
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    buildInsertQuery(tableName: string, values: Record<string, any>, options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build a `WITH name(columns) AS (base UNION ALL recursive)` prefix for a
+     * recursive common table expression. HANA has full standard recursive CTE
+     * support since SPS09.
+     */
+    buildRecursiveCteClause(cte: RecursiveCteOptions): string;
+    buildRecursiveCteQuery(cte: RecursiveCteOptions, outer: Omit<SelectOptions, 'tableName'> & {
+        tableName?: string;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an OLAP window/analytic function expression, e.g.:
+     *   ROW_NUMBER() OVER (PARTITION BY "dept" ORDER BY "salary" DESC)
+     *
+     * HANA has mature, standard window-function support.
+     */
+    buildWindowFunction(options: WindowFunctionOptions): string;
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an UPSERT query using HANA's native `UPSERT ... WITH PRIMARY KEY`
+     * statement - a genuine HANA-only construct (distinct from the `MERGE
+     * INTO` syntax every other enterprise dialect in this codebase uses for
+     * upserts) that inserts a row or updates it in place when a row with a
+     * matching primary key already exists. When `conflictFields` names
+     * columns other than the primary key, a `MERGE INTO` statement is emitted
+     * instead, since `UPSERT ... WITH PRIMARY KEY` can only match on the
+     * table's actual primary key.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    buildCreateUserQuery(username: string, options?: {
+        password?: string;
+        forceFirstPasswordChange?: boolean;
+        noForcePasswordLifetime?: boolean;
+    }): string;
+    buildAlterUserQuery(username: string, options: {
+        password?: string;
+    }): string;
+    buildDropUserQuery(username: string): string;
+    getUsersQuery(): string;
+    buildGrantQuery(options: {
+        privileges: string[] | string;
+        on?: string;
+        to: string;
+    }): string;
+    buildRevokeQuery(options: {
+        privileges: string[] | string;
+        on?: string;
+        from: string;
+    }): string;
+    buildShowGrantsQuery(username: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(roleName: string): string;
+    buildDropRoleQuery(roleName: string): string;
+    buildGrantRoleQuery(role: string, to: string): string;
+    buildRevokeRoleQuery(role: string, from: string): string;
+    getRolesQuery(): string;
+    createSequence(options: SequenceOptions): Promise<void>;
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get the next value of a sequence via HANA's Oracle-style pseudo-column
+     * access (`<sequence>.NEXTVAL`), selected from the single-row `DUMMY`
+     * pseudo-table (HANA's equivalent of Oracle's `DUAL`).
+     */
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    currSequenceValue(sequenceName: string): Promise<number>;
+    hasSequence(sequenceName: string, schema?: string): Promise<boolean>;
+    listSequences(): Promise<string[]>;
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+    }): Promise<void>;
+    /** HANA calculated (computed) columns: `col type GENERATED ALWAYS AS (expr)`. */
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    createTrigger(options: TriggerOptions): Promise<void>;
+    dropTrigger(triggerName: string, _tableName: string, options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(triggerName: string, _tableName: string, schema?: string): Promise<boolean>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(): Promise<void>;
+    disableRLS(): Promise<void>;
+    hasPolicy(): Promise<boolean>;
+    commentTable(tableName: string, comment: string): Promise<void>;
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+}
+export {};

package/dist/dialects/hana/index.js

@@ -46,42 +46,24 @@
  *    below throw with a pointer to the real HANA feature instead of forcing
  *    a lossy 1:1 mapping.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HanaDialect = void 0;
-const hdb = __importStar(require("hdb"));
+// Lazily-loaded `hdb` driver. Required only when a connection is opened, so
+// importing this ORM never loads the hdb driver.
+let hdbModule = null;
+function loadHdb() {
+    if (!hdbModule) {
+        try {
+            hdbModule = require('hdb');
+        }
+        catch (err) {
+            throw new Error("The 'hdb' package is required to use the SAP HANA dialect but could not be loaded. " +
+                'Install it with `npm install hdb`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return hdbModule;
+}
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
 /** HANA requires a LIMIT whenever OFFSET is used; this sentinel stands in for "no limit". */
@@ -161,7 +143,7 @@ class HanaDialect {
             ...(this.config.useTLS ? { useTLS: true } : {}),
             ...(this.config.extraOptions || {}),
         };
-        return hdb.createClient(options);
+        return loadHdb().createClient(options);
     }
     connectClient(client) {
         return new Promise((resolve, reject) => {