ts-prorm-orm 1.1.0

package/dist/dialects/hana/index.js

@@ -0,0 +1,1741 @@
+"use strict";
+/**
+ * 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.
+ */
+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"));
+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". */
+const HANA_MAX_LIMIT = 2147483647;
+/**
+ * HANA-specific transaction class. Since `hdb` has no built-in connection
+ * pool, a transaction is backed by its own dedicated client connection
+ * (autocommit disabled) so its statements never interleave with unrelated
+ * queries running against the dialect's shared client.
+ */
+class HanaTransaction {
+    constructor(client, options) {
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.client = null;
+        this.id = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.options = options || {};
+        this.client = client;
+    }
+    /**
+     * Commit the transaction's own dedicated connection directly. This mirrors
+     * `HanaDialect.commitTransaction()` (the path used when committing via the
+     * dialect) so that calling `tx.commit()` directly also actually commits and
+     * closes the connection, rather than merely flipping `finished` and
+     * leaking an open, uncommitted connection.
+     */
+    async commit() {
+        if (this.finished)
+            return;
+        if (this.client) {
+            await new Promise((resolve, reject) => {
+                this.client.commit((err) => (err ? reject(err) : resolve()));
+            });
+            this.client.close();
+        }
+        this.finished = true;
+    }
+    /** See `commit()` - mirrors `HanaDialect.rollbackTransaction()`. */
+    async rollback() {
+        if (this.finished)
+            return;
+        if (this.client) {
+            await new Promise((resolve, reject) => {
+                this.client.rollback((err) => (err ? reject(err) : resolve()));
+            });
+            this.client.close();
+        }
+        this.finished = true;
+    }
+}
+/**
+ * SAP HANA dialect class implementing the shared Dialect interface.
+ */
+class HanaDialect {
+    constructor(config) {
+        this.name = 'hana';
+        this.library = 'hdb';
+        this.client = null;
+        this._isConnected = false;
+        this.config = {
+            host: 'localhost',
+            port: 30015,
+            database: undefined,
+            username: 'SYSTEM',
+            password: '',
+            ...config,
+        };
+    }
+    createClient() {
+        const options = {
+            host: this.config.host,
+            port: this.config.port,
+            user: this.config.username,
+            password: this.config.password,
+            ...(this.config.database ? { databaseName: this.config.database } : {}),
+            ...(this.config.useTLS ? { useTLS: true } : {}),
+            ...(this.config.extraOptions || {}),
+        };
+        return hdb.createClient(options);
+    }
+    connectClient(client) {
+        return new Promise((resolve, reject) => {
+            client.connect((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async connect() {
+        const client = this.createClient();
+        await this.connectClient(client);
+        this.client = client;
+        this._isConnected = true;
+    }
+    async disconnect() {
+        if (this.client) {
+            await new Promise((resolve, reject) => {
+                this.client.disconnect((err) => (err ? reject(err) : resolve()));
+            });
+            this.client = null;
+            this._isConnected = false;
+        }
+    }
+    getConnection() {
+        return this.client;
+    }
+    isConnected() {
+        return this._isConnected && this.client !== null && this.client.readyState === 'connected';
+    }
+    /**
+     * 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.
+     */
+    executeOnClient(client, sql, params) {
+        const isCall = /^\s*CALL\b/i.test(sql.trim());
+        return new Promise((resolve, reject) => {
+            const handle = (err, ...rest) => {
+                if (err)
+                    return reject(err);
+                if (isCall) {
+                    const [outputParams, ...resultSets] = rest;
+                    const [primaryResultSet, ...additionalResultSets] = resultSets;
+                    const primaryRows = Array.isArray(primaryResultSet) ? primaryResultSet : [];
+                    return resolve({
+                        rows: primaryRows,
+                        rowCount: primaryRows.length,
+                        fields: [],
+                        outputParams: outputParams && typeof outputParams === 'object' ? outputParams : {},
+                        ...(additionalResultSets.length > 0 ? { resultSets: additionalResultSets } : {}),
+                    });
+                }
+                const [result] = rest;
+                if (Array.isArray(result)) {
+                    return resolve({ rows: result, rowCount: result.length, fields: [] });
+                }
+                // DML statements resolve with an affected-row count (or `undefined`
+                // for DDL); a plain SELECT that happens to hit an empty result set
+                // still resolves with an array from hdb.
+                return resolve({
+                    rows: [],
+                    rowCount: typeof result === 'number' ? result : 0,
+                    fields: [],
+                });
+            };
+            if (params.length > 0) {
+                client.prepare(sql, (err, statement) => {
+                    if (err)
+                        return reject(err);
+                    statement.exec(params, handle);
+                });
+            }
+            else {
+                client.exec(sql, handle);
+            }
+        });
+    }
+    /**
+     * 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, options) {
+        return (0, query_stream_helper_1.createPaginatedQueryStream)(this, sql, options);
+    }
+    async query(sql, options) {
+        const bindValues = options?.replacements ?? options?.bindings ?? options?.bind ?? [];
+        const params = Array.isArray(bindValues) ? bindValues : Object.values(bindValues);
+        const tx = options?.transaction;
+        if (tx) {
+            if (tx.finished) {
+                throw new Error('Cannot execute query: the transaction has already been committed or rolled back.');
+            }
+            if (!tx.client) {
+                throw new Error('Cannot execute query: the transaction has no associated connection.');
+            }
+            return this.executeOnClient(tx.client, sql, params);
+        }
+        if (!this.client) {
+            throw new Error('Not connected to database. Call connect() first.');
+        }
+        return this.executeOnClient(this.client, sql, params);
+    }
+    escape(value) {
+        if (value instanceof prorm_1.Literal) {
+            return value.val;
+        }
+        if (value === null || value === undefined)
+            return 'NULL';
+        if (typeof value === 'boolean')
+            return value ? 'TRUE' : 'FALSE';
+        if (typeof value === 'number')
+            return String(value);
+        if (value instanceof Date)
+            return this.formatTimestamp(value);
+        if (Buffer.isBuffer(value))
+            return `X'${value.toString('hex')}'`;
+        if (Array.isArray(value) || typeof value === 'object') {
+            return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    formatTimestamp(date) {
+        const pad = (n, len = 2) => String(n).padStart(len, '0');
+        const year = date.getFullYear();
+        const month = pad(date.getMonth() + 1);
+        const day = pad(date.getDate());
+        const hours = pad(date.getHours());
+        const minutes = pad(date.getMinutes());
+        const seconds = pad(date.getSeconds());
+        const millis = pad(date.getMilliseconds(), 3);
+        return `TIMESTAMP '${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${millis}'`;
+    }
+    /**
+     * 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) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    quoteTable(tableName, schema) {
+        const schemaName = schema || this.config.schema;
+        if (schemaName) {
+            return `${this.escapeId(schemaName)}.${this.escapeId(tableName)}`;
+        }
+        return this.escapeId(tableName);
+    }
+    /**
+     * 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).
+     */
+    schemaFilterSql(schema) {
+        const schemaName = schema || this.config.schema;
+        return schemaName
+            ? `AND SCHEMA_NAME = '${schemaName.toUpperCase()}'`
+            : 'AND SCHEMA_NAME = CURRENT_SCHEMA';
+    }
+    async getDatabaseVersion() {
+        const result = await this.query('SELECT VERSION FROM SYS.M_DATABASE');
+        return result.rows[0]?.VERSION || result.rows[0]?.version || 'unknown';
+    }
+    /**
+     * 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.
+     */
+    async getEditionInfo() {
+        const version = await this.getDatabaseVersion();
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+        if (!match) {
+            return { edition: 'unknown', version };
+        }
+        const major = Number(match[1]);
+        const minor = Number(match[2]);
+        const revision = Number(match[3]);
+        const edition = major >= 4 ? 'cloud' : major >= 1 ? 'on-premise' : 'unknown';
+        return { edition, version, major, minor, revision };
+    }
+    /** Convenience wrapper over `getEditionInfo()` for the common case of a boolean check. */
+    async isCloudEdition() {
+        const { edition } = await this.getEditionInfo();
+        return edition === 'cloud';
+    }
+    // ==================== Schema Operations ====================
+    async createSchema(schema) {
+        await this.query(`CREATE SCHEMA ${this.escapeId(schema)}`);
+    }
+    async dropSchema(schema, options) {
+        if (options?.ifExists) {
+            const exists = await this.query(`SELECT SCHEMA_NAME FROM SYS.SCHEMAS WHERE SCHEMA_NAME = '${schema.toUpperCase()}'`);
+            if (!exists.rows || exists.rows.length === 0)
+                return;
+        }
+        let sql = `DROP SCHEMA ${this.escapeId(schema)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    async showAllSchemas() {
+        const result = await this.query('SELECT SCHEMA_NAME FROM SYS.SCHEMAS ORDER BY SCHEMA_NAME');
+        return result.rows.map((row) => row.SCHEMA_NAME || row.schema_name);
+    }
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    createDatabaseSQL(options) {
+        // Tenant databases in a HANA MDC landscape are created via
+        // `CREATE DATABASE <name> SYSTEM USER PASSWORD "..."` issued against the
+        // SYSTEMDB, not a per-tenant SQL session - this returns the DDL shape for
+        // completeness, but most deployments provision tenants operationally
+        // rather than through application code.
+        return `CREATE DATABASE ${this.escapeId(options.name)} SYSTEM USER PASSWORD "Change_Me1"`;
+    }
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE ${this.escapeId(name)}`;
+    }
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVEPOINT ${savepointName}`;
+    }
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+    // ==================== Extensions (PostgreSQL-only, not supported) ====================
+    async createExtension() {
+        throw new Error('Extensions are a PostgreSQL-specific feature. HANA has no CREATE EXTENSION equivalent.');
+    }
+    async dropExtension() {
+        throw new Error('Extensions are a PostgreSQL-specific feature. HANA has no CREATE EXTENSION equivalent.');
+    }
+    async getExtensions() {
+        throw new Error('Extensions are a PostgreSQL-specific feature. HANA has no CREATE EXTENSION equivalent.');
+    }
+    async hasExtension() {
+        throw new Error('Extensions are a PostgreSQL-specific feature. HANA has no CREATE EXTENSION equivalent.');
+    }
+    // ==================== Table Operations ====================
+    buildColumnDefinition(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.autoIncrement) {
+            sql += ' GENERATED ALWAYS AS IDENTITY (START WITH 1 INCREMENT BY 1)';
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined && !definition.autoIncrement) {
+            if (definition.defaultValue === null) {
+                sql += ' DEFAULT NULL';
+            }
+            else if (definition.defaultValue instanceof prorm_1.Literal) {
+                sql += ` DEFAULT ${definition.defaultValue.val}`;
+            }
+            else {
+                sql += ` DEFAULT ${this.escape(definition.defaultValue)}`;
+            }
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.unique) {
+            sql += ' UNIQUE';
+        }
+        if (definition.references) {
+            const refField = definition.references.field;
+            const refFieldSql = Array.isArray(refField)
+                ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                : `(${this.escapeId(refField)})`;
+            sql += ` REFERENCES ${this.quoteTable(definition.references.table)}${refFieldSql}`;
+            if (definition.references.onDelete) {
+                sql += ` ON DELETE ${definition.references.onDelete.toUpperCase()}`;
+            }
+            if (definition.references.onUpdate) {
+                sql += ` ON UPDATE ${definition.references.onUpdate.toUpperCase()}`;
+            }
+        }
+        return sql;
+    }
+    buildConstraintSql(constraint) {
+        const name = constraint.name ? `CONSTRAINT ${this.escapeId(constraint.name)} ` : '';
+        const fields = constraint.fields?.map((f) => this.escapeId(f)).join(', ') || '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${name}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name}UNIQUE (${fields})`;
+            case 'CHECK':
+                return `${name}CHECK (${constraint.check})`;
+            case 'FOREIGN KEY': {
+                if (!constraint.references)
+                    return null;
+                const refField = constraint.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : `(${this.escapeId(refField)})`;
+                let fkSql = `${name}FOREIGN KEY (${fields}) REFERENCES ${this.quoteTable(constraint.references.table)}${refFieldSql}`;
+                if (constraint.references.onDelete) {
+                    fkSql += ` ON DELETE ${constraint.references.onDelete.toUpperCase()}`;
+                }
+                if (constraint.references.onUpdate) {
+                    fkSql += ` ON UPDATE ${constraint.references.onUpdate.toUpperCase()}`;
+                }
+                return fkSql;
+            }
+            default:
+                return null;
+        }
+    }
+    /**
+     * 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).
+     */
+    normalizeSystemVersioningOptions(sv) {
+        if (!sv)
+            return undefined;
+        return sv === true ? {} : sv;
+    }
+    /**
+     * 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`.
+     */
+    buildSystemVersioningPeriodSql(sv) {
+        const validFrom = sv.validFromColumn || 'valid_from';
+        const validTo = sv.validToColumn || 'valid_to';
+        return {
+            validFrom,
+            validTo,
+            rowStartColumnSql: `${this.escapeId(validFrom)} TIMESTAMP(6) NOT NULL GENERATED ALWAYS AS ROW START`,
+            rowEndColumnSql: `${this.escapeId(validTo)} TIMESTAMP(6) NOT NULL GENERATED ALWAYS AS ROW END`,
+            periodClauseSql: `PERIOD FOR SYSTEM_TIME (${this.escapeId(validFrom)}, ${this.escapeId(validTo)})`,
+        };
+    }
+    /**
+     * 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 }`.
+     */
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.buildColumnDefinition(columnName, definition));
+        }
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql)
+                    columnDefs.push(constraintSql);
+            }
+        }
+        const columnStore = options?.columnStore !== false;
+        const tableKind = columnStore ? 'COLUMN' : 'ROW';
+        const systemVersioning = this.normalizeSystemVersioningOptions(options?.systemVersioning);
+        if (systemVersioning && !columnStore) {
+            throw new Error('HANA system-versioned tables require a column-store table (columnStore: false was set)');
+        }
+        if (systemVersioning) {
+            const { rowStartColumnSql, rowEndColumnSql, periodClauseSql } = this.buildSystemVersioningPeriodSql(systemVersioning);
+            columnDefs.push(rowStartColumnSql, rowEndColumnSql, periodClauseSql);
+        }
+        let sql = `CREATE ${tableKind} TABLE ${this.quoteTable(tableName)} (${columnDefs.join(', ')})`;
+        if (systemVersioning) {
+            sql += ' WITH SYSTEM VERSIONING';
+            if (systemVersioning.historyTable) {
+                sql += ` HISTORY TABLE ${this.quoteTable(systemVersioning.historyTable)}`;
+            }
+        }
+        await this.query(sql);
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                await this.createIndex(tableName, {
+                    name: index.name || `${tableName}_${index.fields.join('_')}_idx`,
+                    fields: index.fields,
+                    unique: index.unique,
+                    type: index.type,
+                });
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    async alterTableSystemVersioning(tableName, options) {
+        const sv = options || {};
+        const { rowStartColumnSql, rowEndColumnSql, periodClauseSql } = this.buildSystemVersioningPeriodSql(sv);
+        const table = this.quoteTable(tableName);
+        await this.query(`ALTER TABLE ${table} ADD (${rowStartColumnSql})`);
+        await this.query(`ALTER TABLE ${table} ADD (${rowEndColumnSql})`);
+        await this.query(`ALTER TABLE ${table} ADD ${periodClauseSql}`);
+        let sql = `ALTER TABLE ${table} ADD SYSTEM VERSIONING`;
+        if (sv.historyTable) {
+            sql += ` HISTORY TABLE ${this.quoteTable(sv.historyTable)}`;
+        }
+        await this.query(sql);
+    }
+    async dropTable(tableName, options) {
+        if (options?.ifExists) {
+            const exists = await this.query(`SELECT TABLE_NAME FROM SYS.TABLES WHERE TABLE_NAME = '${tableName.toUpperCase()}' ${this.schemaFilterSql()}`);
+            if (!exists.rows || exists.rows.length === 0)
+                return;
+        }
+        let sql = `DROP TABLE ${this.quoteTable(tableName)}`;
+        if (options?.cascade)
+            sql += ' CASCADE';
+        await this.query(sql);
+    }
+    /**
+     * 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.
+     */
+    async createPartitionedTable(tableName, columns, options) {
+        if (!options?.partitionBy || (options.partitionBy.type !== 'range' && options.partitionBy.type !== 'hash')) {
+            throw new Error('HANA supports RANGE, HASH and ROUNDROBIN partitioning; only "range" and "hash" are modeled by createPartitionedTable (use raw SQL via query() for ROUNDROBIN).');
+        }
+        const columnDefs = Object.entries(columns).map(([columnName, definition]) => this.buildColumnDefinition(columnName, definition));
+        const columnStore = options?.columnStore !== false;
+        const tableKind = columnStore ? 'COLUMN' : 'ROW';
+        const partitionColumns = Array.isArray(options.partitionBy.column)
+            ? options.partitionBy.column.map((c) => this.escapeId(c)).join(', ')
+            : this.escapeId(options.partitionBy.column);
+        let partitionClause;
+        if (options.partitionBy.type === 'hash') {
+            const count = (options.partitions || []).length || 4;
+            partitionClause = `PARTITION BY HASH (${partitionColumns}) PARTITIONS ${count}`;
+        }
+        else {
+            const parts = (options.partitions || []).map((part) => {
+                if (part.bound?.to !== undefined) {
+                    return `PARTITION ${this.formatPartitionValue(part.bound.to)}`;
+                }
+                return 'PARTITION OTHERS';
+            });
+            partitionClause = `PARTITION BY RANGE (${partitionColumns}) (${parts.join(', ')})`;
+        }
+        const sql = `CREATE ${tableKind} TABLE ${this.quoteTable(tableName)} (${columnDefs.join(', ')}) ${partitionClause}`;
+        await this.query(sql);
+    }
+    formatPartitionValue(value) {
+        if (value instanceof Date)
+            return `VALUE <= ${this.escape(value)}`;
+        if (typeof value === 'number')
+            return `VALUE <= ${value}`;
+        return `VALUE <= ${this.escape(value)}`;
+    }
+    async createPartition(options) {
+        const bound = options.bound && 'to' in options.bound ? this.formatPartitionValue(options.bound.to) : 'OTHERS';
+        await this.query(`ALTER TABLE ${this.quoteTable(options.parentTable)} ADD PARTITION ${bound}`);
+    }
+    async attachPartition(_options) {
+        throw new Error('HANA does not support attaching a standalone table as a partition; use ALTER TABLE ... ADD PARTITION instead.');
+    }
+    async detachPartition(_options) {
+        throw new Error('HANA does not support detaching a partition into a standalone table; use ALTER TABLE ... DROP PARTITION or MERGE PARTITION instead.');
+    }
+    async dropPartition(partitionName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(partitionName)} MERGE PARTITIONS`);
+    }
+    /**
+     * 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.
+     */
+    async bulkInsert(tableName, records, options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const columns = Object.keys(records[0]);
+        const values = [];
+        const rowPlaceholders = [];
+        for (const record of records) {
+            const placeholders = [];
+            for (const column of columns) {
+                placeholders.push('?');
+                values.push(record[column]);
+            }
+            rowPlaceholders.push(`(${placeholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${rowPlaceholders.join(', ')}`;
+        return this.query(sql, { replacements: values });
+    }
+    // ==================== View Operations ====================
+    async createView(viewName, query, options) {
+        if (options?.replace) {
+            await this.query(`DROP VIEW ${this.escapeId(viewName)}`).catch(() => undefined);
+        }
+        await this.query(`CREATE VIEW ${this.escapeId(viewName)} AS ${query}`);
+    }
+    async dropView(viewName, options) {
+        if (options?.ifExists) {
+            const exists = await this.query(`SELECT VIEW_NAME FROM SYS.VIEWS WHERE VIEW_NAME = '${viewName.toUpperCase()}' ${this.schemaFilterSql()}`);
+            if (!exists.rows || exists.rows.length === 0)
+                return;
+        }
+        await this.query(`DROP VIEW ${this.escapeId(viewName)}`);
+    }
+    async showViews() {
+        const result = await this.query('SELECT VIEW_NAME FROM SYS.VIEWS ORDER BY VIEW_NAME');
+        return result.rows.map((row) => row.VIEW_NAME || row.view_name);
+    }
+    // HANA has no `CREATE MATERIALIZED VIEW` SQL statement - the closest
+    // concepts are Calculation Views (modeled objects, out of scope for this
+    // ORM) or a manually-maintained "snapshot" table populated by a
+    // stored-procedure-driven refresh job. These throw rather than emit
+    // invalid SQL.
+    async createMaterializedView(_options) {
+        throw new Error('HANA has no CREATE MATERIALIZED VIEW statement. Use a Calculation View or a manually-refreshed snapshot table instead.');
+    }
+    async refreshMaterializedView(_viewName, _options) {
+        throw new Error('HANA has no materialized views to refresh.');
+    }
+    async dropMaterializedView(_viewName, _options) {
+        throw new Error('HANA has no materialized views to drop.');
+    }
+    async hasMaterializedView(_viewName) {
+        return false;
+    }
+    async showMaterializedViews() {
+        return [];
+    }
+    // ==================== Column Operations ====================
+    // HANA's ALTER TABLE column DDL is parenthesized and can batch multiple
+    // columns in one clause - distinct from the single-column-at-a-time ALTER
+    // COLUMN syntax used by most other dialects.
+    async addColumn(tableName, columnName, definition) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ADD (${this.buildColumnDefinition(columnName, definition)})`);
+    }
+    async removeColumn(tableName, columnName) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} DROP (${this.escapeId(columnName)})`);
+    }
+    async changeColumn(tableName, columnName, definition) {
+        let clause = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.defaultValue !== undefined) {
+            clause += ` DEFAULT ${definition.defaultValue === null ? 'NULL' : this.escape(definition.defaultValue)}`;
+        }
+        if (definition.allowNull === false) {
+            clause += ' NOT NULL';
+        }
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER (${clause})`);
+    }
+    /** HANA's dedicated column-rename statement: `RENAME COLUMN t.old TO new`. */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.query(`RENAME COLUMN ${this.quoteTable(tableName)}.${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`);
+    }
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name
+            ? this.escapeId(options.name)
+            : this.escapeId(`fk_${tableName}_${columnName}`);
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${constraintName} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)} (${this.escapeId(referencedColumnName)})`;
+        if (options?.onDelete)
+            sql += ` ON DELETE ${options.onDelete.toUpperCase()}`;
+        if (options?.onUpdate)
+            sql += ` ON UPDATE ${options.onUpdate.toUpperCase()}`;
+        await this.query(sql);
+    }
+    async describeTable(tableName) {
+        const result = await this.query(`SELECT COLUMN_NAME, DATA_TYPE_NAME, IS_NULLABLE, DEFAULT_VALUE, GENERATED_ALWAYS_AS_IDENTITY
+       FROM SYS.TABLE_COLUMNS
+       WHERE TABLE_NAME = '${tableName.toUpperCase()}' ${this.schemaFilterSql()}
+       ORDER BY POSITION`);
+        const pkResult = await this.query(`SELECT COLUMN_NAME FROM SYS.CONSTRAINTS WHERE TABLE_NAME = '${tableName.toUpperCase()}' AND IS_PRIMARY_KEY = 'TRUE' ${this.schemaFilterSql()}`);
+        const pkColumns = new Set(pkResult.rows.map((row) => (row.COLUMN_NAME || row.column_name || '').toUpperCase()));
+        const description = {};
+        for (const row of result.rows) {
+            const rawName = row.COLUMN_NAME || row.column_name || '';
+            const colName = rawName.toLowerCase();
+            description[colName] = {
+                type: row.DATA_TYPE_NAME || row.data_type_name,
+                allowNull: (row.IS_NULLABLE ?? row.is_nullable) === 'TRUE',
+                defaultValue: row.DEFAULT_VALUE ?? row.default_value ?? null,
+                primaryKey: pkColumns.has(rawName.toUpperCase()),
+                autoIncrement: (row.GENERATED_ALWAYS_AS_IDENTITY ?? row.generated_always_as_identity) === 'TRUE',
+            };
+        }
+        return description;
+    }
+    async renameTable(oldName, newName) {
+        await this.query(`RENAME TABLE ${this.quoteTable(oldName)} TO ${this.escapeId(newName)}`);
+    }
+    async showTables() {
+        const result = await this.query(`SELECT TABLE_NAME FROM SYS.TABLES WHERE 1 = 1 ${this.schemaFilterSql()} ORDER BY TABLE_NAME`);
+        return result.rows.map((row) => row.TABLE_NAME || row.table_name);
+    }
+    async showConstraints(tableName) {
+        const result = await this.query(`SELECT CONSTRAINT_NAME AS name, TABLE_NAME AS tableName, IS_PRIMARY_KEY AS isPrimaryKey, IS_UNIQUE_KEY AS isUniqueKey
+       FROM SYS.CONSTRAINTS
+       WHERE TABLE_NAME = '${tableName.toUpperCase()}' ${this.schemaFilterSql()}
+       ORDER BY CONSTRAINT_NAME`);
+        return result.rows;
+    }
+    async addConstraint(tableName, options) {
+        await this.createConstraint(tableName, {
+            name: options.name || `${tableName}_${options.type.toLowerCase().replace(/\s+/g, '_')}`,
+            type: options.type,
+            fields: options.fields,
+            references: options.references
+                ? { table: options.references.table, field: options.references.fields }
+                : undefined,
+            check: options.check,
+        });
+    }
+    async removeConstraint(tableName, constraintName) {
+        await this.dropConstraint(tableName, constraintName);
+    }
+    async showIndexes(tableName) {
+        const result = await this.query(`SELECT INDEX_NAME AS name, TABLE_NAME AS tableName, CONSTRAINT AS constraintType
+       FROM SYS.INDEXES
+       WHERE TABLE_NAME = '${tableName.toUpperCase()}' ${this.schemaFilterSql()}
+       ORDER BY INDEX_NAME`);
+        return result.rows;
+    }
+    // ==================== Index Operations ====================
+    buildCreateIndexSql(tableName, indexName, fields, options) {
+        const fieldsSql = (fields || []).map((f) => this.escapeId(f)).join(', ');
+        let sql = 'CREATE';
+        if (options?.unique)
+            sql += ' UNIQUE';
+        sql += ` INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql})`;
+        return sql;
+    }
+    async addIndex(tableName, indexName, fields, options) {
+        await this.query(this.buildCreateIndexSql(tableName, indexName, fields, options));
+    }
+    async removeIndex(_tableName, indexName) {
+        await this.query(`DROP INDEX ${this.escapeId(indexName)}`);
+    }
+    async createIndex(tableName, indexDef) {
+        await this.addIndex(tableName, indexDef.name, indexDef.fields, {
+            unique: indexDef.unique,
+            type: indexDef.type,
+            using: indexDef.using,
+        });
+    }
+    async dropIndex(tableName, indexName, _options) {
+        await this.removeIndex(tableName, indexName);
+    }
+    async createFulltextIndex(tableName, indexName, fields, _options) {
+        // HANA's full-text search is implemented via CREATE FULLTEXT INDEX,
+        // backed by the Full-Text Search Engine, and operates on a single
+        // NVARCHAR/NCLOB column at a time.
+        const field = fields[0];
+        await this.query(`CREATE FULLTEXT INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${this.escapeId(field)})`);
+    }
+    async createSpatialIndex(tableName, indexName, fields, _options) {
+        // HANA spatial indexes are created on an ST_GEOMETRY/ST_POINT column.
+        const field = fields[0];
+        await this.query(`CREATE SPATIAL INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${this.escapeId(field)})`);
+    }
+    async createPartialIndex() {
+        throw new Error('HANA does not support partial (filtered) indexes with a WHERE clause.');
+    }
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        let sql = 'CREATE';
+        if (options?.unique)
+            sql += ' UNIQUE';
+        sql += ` INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${expression})`;
+        await this.query(sql);
+    }
+    // ==================== Constraint Operations ====================
+    async createConstraint(tableName, constraintDef) {
+        const constraintSql = this.buildConstraintSql({
+            name: constraintDef.name,
+            type: constraintDef.type,
+            fields: constraintDef.fields,
+            references: constraintDef.references
+                ? {
+                    table: constraintDef.references.table,
+                    field: constraintDef.references.field,
+                    onDelete: constraintDef.references.onDelete,
+                    onUpdate: constraintDef.references.onUpdate,
+                }
+                : undefined,
+            check: constraintDef.check,
+        });
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ADD ${constraintSql}`);
+    }
+    async dropConstraint(tableName, constraintName, _options) {
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} DROP CONSTRAINT ${this.escapeId(constraintName)}`);
+    }
+    async changeOwner() {
+        throw new Error('HANA has no ALTER ... OWNER TO equivalent; ownership is managed via object privileges/roles instead.');
+    }
+    // ==================== Federation (Smart Data Access - out of scope) ====================
+    // HANA's real federation feature is Smart Data Access: `CREATE REMOTE
+    // SOURCE` registers a remote data source/adapter, and `CREATE VIRTUAL
+    // TABLE` maps a local object onto a remote table through it - conceptually
+    // similar to Postgres' FDW/foreign-server/foreign-table trio, but not a
+    // clean 1:1 mapping onto the generic (Postgres-shaped) FDW interface
+    // threaded through the shared Dialect type. These throw with a pointer to
+    // the real feature rather than emitting invalid SQL.
+    async createForeignDataWrapper() {
+        throw new Error('HANA has no FDW concept; use Smart Data Access (CREATE REMOTE SOURCE / CREATE VIRTUAL TABLE) instead.');
+    }
+    async dropForeignDataWrapper() {
+        throw new Error('HANA has no FDW concept; use Smart Data Access (CREATE REMOTE SOURCE / CREATE VIRTUAL TABLE) instead.');
+    }
+    async createForeignServer() {
+        throw new Error('HANA has no CREATE SERVER equivalent; use Smart Data Access (CREATE REMOTE SOURCE) instead.');
+    }
+    async dropForeignServer() {
+        throw new Error('HANA has no DROP SERVER equivalent; use Smart Data Access (DROP REMOTE SOURCE) instead.');
+    }
+    async createForeignTable() {
+        throw new Error('HANA has no CREATE FOREIGN TABLE equivalent; use Smart Data Access (CREATE VIRTUAL TABLE) instead.');
+    }
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('HANA has no FDW concept; use Smart Data Access (CREATE REMOTE SOURCE) instead.');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('HANA has no FDW concept; use Smart Data Access (ALTER REMOTE SOURCE) instead.');
+    }
+    buildDropServerQuery(_name) {
+        throw new Error('HANA has no FDW concept; use Smart Data Access (DROP REMOTE SOURCE) instead.');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('HANA has no user-mapping concept; Smart Data Access credentials are configured on the remote source itself.');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('HANA has no user-mapping concept; Smart Data Access credentials are configured on the remote source itself.');
+    }
+    buildDropUserMappingQuery(_serverName, _user) {
+        throw new Error('HANA has no user-mapping concept; Smart Data Access credentials are configured on the remote source itself.');
+    }
+    async createUserMapping() {
+        throw new Error('HANA has no user-mapping concept; Smart Data Access credentials are configured on the remote source itself.');
+    }
+    async dropUserMapping() {
+        throw new Error('HANA has no user-mapping concept; Smart Data Access credentials are configured on the remote source itself.');
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('HANA has no CREATE FOREIGN TABLE equivalent; use Smart Data Access (CREATE VIRTUAL TABLE) instead.');
+    }
+    buildDropForeignTableQuery(_tableName) {
+        throw new Error('HANA has no DROP FOREIGN TABLE equivalent; use Smart Data Access (DROP VIRTUAL TABLE) instead.');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('HANA has no IMPORT FOREIGN SCHEMA equivalent; virtual tables must be created individually.');
+    }
+    getServersQuery() {
+        // Smart Data Access remote sources, for reference/parity even though
+        // the FDW-shaped methods above throw.
+        return 'SELECT REMOTE_SOURCE_NAME, ADAPTER_NAME FROM SYS.REMOTE_SOURCES ORDER BY REMOTE_SOURCE_NAME';
+    }
+    // ==================== Security Policies (Row-level security) ====================
+    // HANA has no simple predicate-based row-level-security policy statement
+    // like MSSQL/Postgres RLS; row-level restrictions are implemented via
+    // Structured Privileges / Analytic Privileges, which are administrative
+    // objects rather than plain SQL DDL suitable for this generic interface.
+    async createSecurityPolicy() {
+        throw new Error('HANA has no CREATE SECURITY POLICY equivalent; use Structured/Analytic Privileges instead.');
+    }
+    async dropSecurityPolicy() {
+        throw new Error('HANA has no CREATE SECURITY POLICY equivalent; use Structured/Analytic Privileges instead.');
+    }
+    // ==================== Transaction Operations ====================
+    async startTransaction(options) {
+        const client = this.createClient();
+        await this.connectClient(client);
+        client.setAutoCommit(false);
+        if (options?.isolationLevel) {
+            // HANA sets the isolation level for the *next* transaction via
+            // `SET TRANSACTION ISOLATION LEVEL ...` on the session, executed here
+            // before any statements run on the dedicated transaction connection.
+            await this.executeOnClient(client, `SET TRANSACTION ISOLATION LEVEL ${options.isolationLevel}`, []);
+        }
+        return new HanaTransaction(client, options);
+    }
+    async commitTransaction(transaction) {
+        await transaction.commit();
+    }
+    async rollbackTransaction(transaction) {
+        await transaction.rollback();
+    }
+    // ==================== Data Type Mapping ====================
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            return this.mapDataType(dataType, undefined);
+        }
+        const dt = dataType;
+        return this.mapDataType(String(dt.key ?? dataType), dt);
+    }
+    mapDataType(typeKey, dt) {
+        switch (typeKey.toUpperCase()) {
+            case 'STRING':
+                if (dt?.length === 'max')
+                    return 'NCLOB';
+                return `NVARCHAR(${String(dt?.length || 255)})`;
+            case 'NVARCHAR':
+                return `NVARCHAR(${String(dt?.length || 255)})`;
+            case 'CHAR':
+                return `NCHAR(${String(dt?.length || 1)})`;
+            case 'SHORTTEXT':
+                return `SHORTTEXT(${String(dt?.length || 255)})`;
+            case 'ALPHANUM':
+                return `ALPHANUM(${String(dt?.length || 10)})`;
+            case 'TEXT':
+                return 'NCLOB';
+            case 'TINYTEXT':
+                return 'NVARCHAR(255)';
+            case 'MEDIUMTEXT':
+            case 'LONGTEXT':
+                return 'NCLOB';
+            case 'INTEGER': {
+                if (dt?.length === 1)
+                    return 'TINYINT';
+                if (dt?.length === 2)
+                    return 'SMALLINT';
+                if (dt?.length === 8)
+                    return 'BIGINT';
+                return 'INTEGER';
+            }
+            case 'TINYINT':
+                return 'TINYINT';
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+                return 'REAL';
+            case 'DOUBLE':
+                return 'DOUBLE';
+            case 'NUMBER':
+            case 'DECIMAL':
+            case 'NUMERIC':
+                return `DECIMAL(${String(dt?.precision || 10)}, ${String(dt?.scale || 0)})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+            case 'DATETIME':
+            case 'TIMESTAMP':
+                return 'TIMESTAMP';
+            case 'SECONDDATE':
+                return 'SECONDDATE';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return 'TIME';
+            case 'BLOB':
+                return 'BLOB';
+            case 'BINARY':
+            case 'VARBINARY':
+                return `VARBINARY(${String(dt?.length || 255)})`;
+            case 'BIT':
+                return 'BOOLEAN';
+            case 'JSON':
+                return 'NCLOB';
+            case 'JSONB':
+                return 'BLOB';
+            case 'UUID':
+                return 'NVARCHAR(36)';
+            case 'GEOMETRY':
+                return dt?.srid ? `ST_GEOMETRY(${String(dt.srid)})` : 'ST_GEOMETRY';
+            case 'ST_POINT':
+                return dt?.srid ? `ST_POINT(${String(dt.srid)})` : 'ST_POINT';
+            case 'ENUM':
+                return 'NVARCHAR(255)';
+            case 'VIRTUAL':
+                return '';
+            default:
+                // Pass through unrecognized (often HANA-native) type strings as-is
+                // rather than defaulting to a generic string type - e.g. callers may
+                // legitimately pass 'SECONDDATE', 'ALPHANUM(10)' etc directly.
+                return typeKey;
+        }
+    }
+    // ==================== Query Builders ====================
+    buildWhereClause(where, _options) {
+        const values = [];
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', values };
+        }
+        const buildCondition = (condition) => {
+            if (!condition || typeof condition !== 'object') {
+                values.push(condition);
+                return '?';
+            }
+            const cond = condition;
+            if (cond.$and || cond.$or || cond.$not) {
+                const conditions = [];
+                if (cond.$and) {
+                    conditions.push(`(${cond.$and.map((c) => buildCondition(c)).join(' AND ')})`);
+                }
+                if (cond.$or) {
+                    conditions.push(`(${cond.$or.map((c) => buildCondition(c)).join(' OR ')})`);
+                }
+                if (cond.$not) {
+                    conditions.push(`NOT (${buildCondition(cond.$not)})`);
+                }
+                return conditions.join(' AND ');
+            }
+            const fieldConditions = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                if (value && typeof value === 'object' && !(value instanceof Date) && !Array.isArray(value)) {
+                    const valueObj = value;
+                    if (valueObj.$eq !== undefined) {
+                        values.push(valueObj.$eq);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                    else if (valueObj.$ne !== undefined) {
+                        values.push(valueObj.$ne);
+                        fieldConditions.push(`${this.escapeId(key)} != ?`);
+                    }
+                    else if (valueObj.$gt !== undefined) {
+                        values.push(valueObj.$gt);
+                        fieldConditions.push(`${this.escapeId(key)} > ?`);
+                    }
+                    else if (valueObj.$gte !== undefined) {
+                        values.push(valueObj.$gte);
+                        fieldConditions.push(`${this.escapeId(key)} >= ?`);
+                    }
+                    else if (valueObj.$lt !== undefined) {
+                        values.push(valueObj.$lt);
+                        fieldConditions.push(`${this.escapeId(key)} < ?`);
+                    }
+                    else if (valueObj.$lte !== undefined) {
+                        values.push(valueObj.$lte);
+                        fieldConditions.push(`${this.escapeId(key)} <= ?`);
+                    }
+                    else if (valueObj.$like !== undefined) {
+                        values.push(valueObj.$like);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notLike !== undefined) {
+                        values.push(valueObj.$notLike);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$in) {
+                        const inValues = valueObj.$in;
+                        values.push(...inValues);
+                        fieldConditions.push(`${this.escapeId(key)} IN (${inValues.map(() => '?').join(', ')})`);
+                    }
+                    else if (valueObj.$notIn) {
+                        const notInValues = valueObj.$notIn;
+                        values.push(...notInValues);
+                        fieldConditions.push(`${this.escapeId(key)} NOT IN (${notInValues.map(() => '?').join(', ')})`);
+                    }
+                    else if (valueObj.$between) {
+                        const between = valueObj.$between;
+                        values.push(between[0], between[1]);
+                        fieldConditions.push(`${this.escapeId(key)} BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$notBetween) {
+                        const notBetween = valueObj.$notBetween;
+                        values.push(notBetween[0], notBetween[1]);
+                        fieldConditions.push(`${this.escapeId(key)} NOT BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$isNull !== undefined) {
+                        fieldConditions.push(valueObj.$isNull ? `${this.escapeId(key)} IS NULL` : `${this.escapeId(key)} IS NOT NULL`);
+                    }
+                    else {
+                        values.push(value);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                }
+                else if (value === null) {
+                    fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                }
+                else if (Array.isArray(value)) {
+                    values.push(...value);
+                    fieldConditions.push(`${this.escapeId(key)} IN (${value.map(() => '?').join(', ')})`);
+                }
+                else {
+                    values.push(value);
+                    fieldConditions.push(`${this.escapeId(key)} = ?`);
+                }
+            }
+            return fieldConditions.join(' AND ');
+        };
+        const sql = buildCondition(where);
+        return { sql, values };
+    }
+    buildOrderClause(order, _options) {
+        const orderArray = order;
+        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+            return '';
+        }
+        const orderParts = [];
+        for (const item of orderArray) {
+            if (Array.isArray(item)) {
+                const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
+                const direction = item[1] ? ` ${item[1]}` : '';
+                orderParts.push(`${field}${direction}`);
+            }
+            else if (typeof item === 'string') {
+                orderParts.push(this.escapeId(item));
+            }
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    /**
+     * 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, offset) {
+        if (limit === undefined && offset === undefined)
+            return '';
+        const limitValue = limit !== undefined ? Number(limit) : HANA_MAX_LIMIT;
+        let sql = ` LIMIT ${limitValue}`;
+        if (offset !== undefined) {
+            sql += ` OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    buildInsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                placeholders.push('?');
+                processedValues.push(value);
+            }
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        if (options?.returning) {
+            // HANA has no INSERT ... RETURNING clause; callers must re-select the
+            // row after the insert (e.g. by identity value or supplied key).
+            throw new Error('HANA does not support a RETURNING clause on INSERT. Re-fetch the row after the insert instead.');
+        }
+        return { sql, values: processedValues };
+    }
+    buildUpdateQuery(tableName, values, where, options) {
+        const processedValues = [];
+        const setClauses = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                setClauses.push(`${this.escapeId(key)} = ?`);
+                processedValues.push(value);
+            }
+        }
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.returning) {
+            throw new Error('HANA does not support a RETURNING clause on UPDATE. Re-fetch the row after the update instead.');
+        }
+        return { sql, values: processedValues };
+    }
+    buildDeleteQuery(tableName, where, options) {
+        if (options?.truncate) {
+            return { sql: `TRUNCATE TABLE ${this.quoteTable(tableName)}`, values: [] };
+        }
+        let sql = `DELETE FROM ${this.quoteTable(tableName)}`;
+        const processedValues = [];
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.returning) {
+            throw new Error('HANA does not support a RETURNING clause on DELETE. Re-fetch/capture the row before deleting instead.');
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * 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) {
+        const columnList = cte.columns && cte.columns.length > 0
+            ? `(${cte.columns.map((c) => this.escapeId(c)).join(', ')})`
+            : '';
+        const unionKeyword = cte.unionAll === false ? 'UNION' : 'UNION ALL';
+        return `WITH ${this.escapeId(cte.name)}${columnList} AS (${cte.baseQuery} ${unionKeyword} ${cte.recursiveQuery})`;
+    }
+    buildRecursiveCteQuery(cte, outer) {
+        return this.buildSelectQuery({
+            ...outer,
+            tableName: outer.tableName || cte.name,
+            cte,
+        });
+    }
+    /**
+     * 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) {
+        const args = (options.args || []).join(', ');
+        const overParts = [];
+        if (options.partitionBy) {
+            const cols = Array.isArray(options.partitionBy) ? options.partitionBy : [options.partitionBy];
+            overParts.push(`PARTITION BY ${cols.map((c) => this.escapeId(c)).join(', ')}`);
+        }
+        if (options.orderBy && options.orderBy.length > 0) {
+            const orderParts = options.orderBy.map((o) => typeof o === 'string' ? this.escapeId(o) : `${this.escapeId(o.column)}${o.direction ? ` ${o.direction}` : ''}`);
+            overParts.push(`ORDER BY ${orderParts.join(', ')}`);
+        }
+        if (options.frame) {
+            overParts.push(options.frame);
+        }
+        return `${options.fn.toUpperCase()}(${args}) OVER (${overParts.join(' ')})`;
+    }
+    buildSelectQuery(options) {
+        const values = [];
+        const cte = options.cte;
+        let sql = cte ? `${this.buildRecursiveCteClause(cte)} ` : '';
+        sql += 'SELECT ';
+        if (options.distinct) {
+            sql += 'DISTINCT ';
+        }
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                sql += options.attributes
+                    .map((a) => {
+                    if (a === '*')
+                        return a;
+                    if (typeof a === 'object' && a !== null && 'window' in a) {
+                        const windowAttr = a;
+                        return `${this.buildWindowFunction(windowAttr.window)} AS ${this.escapeId(windowAttr.as)}`;
+                    }
+                    return this.escapeId(a);
+                })
+                    .join(', ');
+            }
+            else {
+                const include = options.attributes.include?.map((a) => this.escapeId(a)).join(', ');
+                sql += include || '*';
+            }
+        }
+        else {
+            sql += '*';
+        }
+        sql += ` FROM ${this.quoteTable(options.tableName, options.schema)}`;
+        if (options.include && options.include.length > 0) {
+            for (const include of options.include) {
+                const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                const joinModel = include.model;
+                const joinTableName = joinModel.tableName || joinModel.name || '';
+                const joinAlias = include.as || joinTableName;
+                sql += ` ${joinType} ${this.quoteTable(joinTableName)} AS ${this.escapeId(joinAlias)}`;
+                if (include.on) {
+                    const onClause = this.buildWhereClause(include.on);
+                    sql += ` ON ${onClause.sql}`;
+                    values.push(...onClause.values);
+                }
+            }
+        }
+        if (options.where && Object.keys(options.where).length > 0) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                values.push(...whereClause.values);
+            }
+        }
+        if (options.group) {
+            const groupBy = Array.isArray(options.group) ? options.group : [options.group];
+            sql += ` GROUP BY ${groupBy.map((g) => this.escapeId(g)).join(', ')}`;
+            if (options.having && Object.keys(options.having).length > 0) {
+                const havingClause = this.buildWhereClause(options.having);
+                sql += ` HAVING ${havingClause.sql}`;
+                values.push(...havingClause.values);
+            }
+        }
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause)
+                sql += ` ${orderClause}`;
+        }
+        if (options.limit !== undefined || options.offset !== undefined) {
+            sql += this.buildLimitOffset(options.limit, options.offset);
+        }
+        if (options.lock) {
+            sql += ' FOR UPDATE';
+        }
+        return { sql, values };
+    }
+    /**
+     * 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, values, options) {
+        const columns = Object.keys(values);
+        const queryValues = Object.values(values);
+        if (!options?.conflictFields || options.conflictFields.length === 0) {
+            const sourceColumns = columns.map((c) => this.escapeId(c)).join(', ');
+            const placeholders = columns.map(() => '?').join(', ');
+            const sql = `UPSERT ${this.quoteTable(tableName, options?.schema)} (${sourceColumns}) VALUES (${placeholders}) WITH PRIMARY KEY`;
+            return { sql, values: queryValues };
+        }
+        // Explicit conflict target: fall back to MERGE INTO, which can match on
+        // any column set, not just the primary key.
+        const conflictFields = options.conflictFields;
+        const updateFields = options.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns.filter((c) => !conflictFields.includes(c));
+        const sourceColumns = columns.map((c) => this.escapeId(c)).join(', ');
+        const sourceValues = columns.map(() => '?').join(', ');
+        const onClauses = conflictFields
+            .map((c) => `target.${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(' AND ');
+        const updateSet = updateFields.length > 0
+            ? updateFields.map((c) => `${this.escapeId(c)} = source.${this.escapeId(c)}`).join(', ')
+            : columns.map((c) => `${this.escapeId(c)} = source.${this.escapeId(c)}`).join(', ');
+        const sql = `MERGE INTO ${this.quoteTable(tableName, options?.schema)} AS target ` +
+            `USING (SELECT ${columns.map((c, i) => `? AS ${this.escapeId(c)}`).join(', ')} FROM DUMMY) AS source ` +
+            `ON ${onClauses} ` +
+            `WHEN MATCHED THEN UPDATE SET ${updateSet} ` +
+            `WHEN NOT MATCHED THEN INSERT (${sourceColumns}) VALUES (${columns.map((c) => `source.${this.escapeId(c)}`).join(', ')})`;
+        void sourceValues;
+        return { sql, values: queryValues };
+    }
+    buildIncrementQuery(tableName, fields, where, options) {
+        const by = options?.by ?? 1;
+        const setClauses = [];
+        const queryValues = [];
+        if (typeof fields === 'string') {
+            setClauses.push(`${this.escapeId(fields)} = ${this.escapeId(fields)} + ?`);
+            queryValues.push(by);
+        }
+        else if (Array.isArray(fields)) {
+            for (const field of fields) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(by);
+            }
+        }
+        else {
+            for (const [field, value] of Object.entries(fields)) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(value);
+            }
+        }
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+            queryValues.push(...whereClause.values);
+        }
+        return { sql, values: queryValues };
+    }
+    replaceReplacements(sql, replacements) {
+        if (!replacements)
+            return sql;
+        if (Array.isArray(replacements)) {
+            let result = sql;
+            for (const value of replacements) {
+                result = result.replace('?', this.escape(value));
+            }
+            return result;
+        }
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            result = result.replace(new RegExp(`:${key}\\b`, 'g'), this.escape(value));
+        }
+        return result;
+    }
+    // ==================== User / Privilege Management ====================
+    // Unlike Db2 (OS/LDAP-authenticated only), HANA has real, native SQL user
+    // and role management.
+    buildCreateUserQuery(username, options) {
+        let sql = `CREATE USER ${this.escapeId(username)}`;
+        if (options?.password) {
+            sql += ` PASSWORD "${options.password.replace(/"/g, '""')}"`;
+        }
+        if (options?.forceFirstPasswordChange === false) {
+            sql += ' NO FORCE_FIRST_PASSWORD_CHANGE';
+        }
+        return sql;
+    }
+    buildAlterUserQuery(username, options) {
+        let sql = `ALTER USER ${this.escapeId(username)}`;
+        if (options?.password) {
+            sql += ` PASSWORD "${options.password.replace(/"/g, '""')}"`;
+        }
+        return sql;
+    }
+    buildDropUserQuery(username) {
+        return `DROP USER ${this.escapeId(username)}`;
+    }
+    getUsersQuery() {
+        return 'SELECT USER_NAME FROM SYS.USERS ORDER BY USER_NAME';
+    }
+    buildGrantQuery(options) {
+        const privileges = Array.isArray(options.privileges) ? options.privileges.join(', ') : options.privileges;
+        let sql = `GRANT ${privileges}`;
+        if (options.on)
+            sql += ` ON ${options.on}`;
+        sql += ` TO ${this.escapeId(options.to)}`;
+        return sql;
+    }
+    buildRevokeQuery(options) {
+        const privileges = Array.isArray(options.privileges) ? options.privileges.join(', ') : options.privileges;
+        let sql = `REVOKE ${privileges}`;
+        if (options.on)
+            sql += ` ON ${options.on}`;
+        sql += ` FROM ${this.escapeId(options.from)}`;
+        return sql;
+    }
+    buildShowGrantsQuery(username) {
+        return `SELECT * FROM SYS.GRANTED_PRIVILEGES WHERE GRANTEE = '${username.toUpperCase()}'`;
+    }
+    buildFlushPrivilegesQuery() {
+        throw new Error('HANA applies privilege changes immediately; there is no FLUSH PRIVILEGES equivalent.');
+    }
+    buildCreateRoleQuery(roleName) {
+        return `CREATE ROLE ${this.escapeId(roleName)}`;
+    }
+    buildDropRoleQuery(roleName) {
+        return `DROP ROLE ${this.escapeId(roleName)}`;
+    }
+    buildGrantRoleQuery(role, to) {
+        return `GRANT ${this.escapeId(role)} TO ${this.escapeId(to)}`;
+    }
+    buildRevokeRoleQuery(role, from) {
+        return `REVOKE ${this.escapeId(role)} FROM ${this.escapeId(from)}`;
+    }
+    getRolesQuery() {
+        return 'SELECT ROLE_NAME FROM SYS.ROLES ORDER BY ROLE_NAME';
+    }
+    // ==================== Sequences ====================
+    async createSequence(options) {
+        const seqName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.name)}`
+            : this.escapeId(options.name);
+        if (options.ifNotExists) {
+            const exists = await this.hasSequence(options.name, options.schema);
+            if (exists)
+                return;
+        }
+        let sql = `CREATE SEQUENCE ${seqName}`;
+        if (options.startWith !== undefined)
+            sql += ` START WITH ${options.startWith}`;
+        if (options.incrementBy !== undefined)
+            sql += ` INCREMENT BY ${options.incrementBy}`;
+        if (options.minvalue !== undefined)
+            sql += ` MINVALUE ${options.minvalue}`;
+        if (options.maxvalue !== undefined)
+            sql += ` MAXVALUE ${options.maxvalue}`;
+        sql += options.cycle ? ' CYCLE' : ' NO CYCLE';
+        await this.query(sql);
+    }
+    async dropSequence(sequenceName, options) {
+        const seqName = options?.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(sequenceName)}`
+            : this.escapeId(sequenceName);
+        if (options?.ifExists) {
+            const exists = await this.hasSequence(sequenceName, options.schema);
+            if (!exists)
+                return;
+        }
+        await this.query(`DROP SEQUENCE ${seqName}`);
+    }
+    /**
+     * 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`).
+     */
+    async nextSequenceValue(sequenceName) {
+        const result = await this.query(`SELECT ${this.escapeId(sequenceName)}.NEXTVAL AS NEXTVAL FROM DUMMY`);
+        const row = result.rows[0];
+        return Number(row?.NEXTVAL ?? row?.nextval);
+    }
+    async currSequenceValue(sequenceName) {
+        const result = await this.query(`SELECT ${this.escapeId(sequenceName)}.CURRVAL AS CURRVAL FROM DUMMY`);
+        const row = result.rows[0];
+        return Number(row?.CURRVAL ?? row?.currval);
+    }
+    async hasSequence(sequenceName, schema) {
+        let sql = `SELECT SEQUENCE_NAME FROM SYS.SEQUENCES WHERE SEQUENCE_NAME = '${sequenceName.toUpperCase()}'`;
+        if (schema)
+            sql += ` AND SCHEMA_NAME = '${schema.toUpperCase()}'`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    async listSequences() {
+        const result = await this.query('SELECT SCHEMA_NAME, SEQUENCE_NAME FROM SYS.SEQUENCES ORDER BY SCHEMA_NAME, SEQUENCE_NAME');
+        return result.rows.map((row) => `${row.SCHEMA_NAME || row.schema_name}.${row.SEQUENCE_NAME || row.sequence_name}`);
+    }
+    // ==================== Identity & Computed Columns ====================
+    async createIdentityColumn(tableName, columnName, options) {
+        const startWith = options?.startWith ?? 1;
+        const incrementBy = options?.incrementBy ?? 1;
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ALTER (${this.escapeId(columnName)} GENERATED ALWAYS AS IDENTITY (START WITH ${startWith} INCREMENT BY ${incrementBy}))`);
+    }
+    /** HANA calculated (computed) columns: `col type GENERATED ALWAYS AS (expr)`. */
+    async createComputedColumn(tableName, columnName, expression, options) {
+        const type = options?.type || 'NVARCHAR(255)';
+        const persisted = options?.persisted ? ' PERSISTED' : '';
+        await this.query(`ALTER TABLE ${this.quoteTable(tableName)} ADD (${this.escapeId(columnName)} ${type} GENERATED ALWAYS AS (${expression})${persisted})`);
+    }
+    // ==================== Stored Procedures ====================
+    // HANA supports both SQLScript stored procedures and functions; only
+    // procedures are modeled here per the shared StoredProcedureOptions shape.
+    async createStoredProcedure(options) {
+        const procName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.name)}`
+            : this.escapeId(options.name);
+        if (options.ifNotExists && !options.replace) {
+            const exists = await this.hasStoredProcedure(options.name, options.schema);
+            if (exists)
+                return;
+        }
+        const paramList = (options.params || [])
+            .map((param) => {
+            const dir = param.mode === 'OUT' ? 'OUT' : param.mode === 'INOUT' ? 'INOUT' : 'IN';
+            return `${dir} ${this.escapeId(param.name)} ${param.type}`;
+        })
+            .join(', ');
+        const replace = options.replace ? 'OR REPLACE ' : '';
+        const sql = `CREATE ${replace}PROCEDURE ${procName} (${paramList})\nLANGUAGE SQLSCRIPT\nSQL SECURITY INVOKER\nAS\nBEGIN\n${options.body}\nEND`;
+        await this.query(sql);
+    }
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    async dropStoredProcedure(procedureName, options) {
+        const procName = options?.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(procedureName)}`
+            : this.escapeId(procedureName);
+        if (options?.ifExists) {
+            const exists = await this.hasStoredProcedure(procedureName, options.schema);
+            if (!exists)
+                return;
+        }
+        await this.query(`DROP PROCEDURE ${procName}`);
+    }
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    async executeStoredProcedure(options) {
+        const procName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.procedureName)}`
+            : this.escapeId(options.procedureName);
+        const paramValues = options.params ? Object.values(options.params) : [];
+        const placeholders = paramValues.map(() => '?').join(', ');
+        const sql = `CALL ${procName}(${placeholders})`;
+        return this.query(sql, { replacements: paramValues });
+    }
+    async hasStoredProcedure(procedureName, schema) {
+        let sql = `SELECT PROCEDURE_NAME FROM SYS.PROCEDURES WHERE PROCEDURE_NAME = '${procedureName.toUpperCase()}'`;
+        if (schema)
+            sql += ` AND SCHEMA_NAME = '${schema.toUpperCase()}'`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    // ==================== Triggers ====================
+    async createTrigger(options) {
+        const triggerName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.name)}`
+            : this.escapeId(options.name);
+        const tableName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.tableName)}`
+            : this.quoteTable(options.tableName);
+        const events = (options.events || []).join(', ');
+        const level = options.level === 'STATEMENT' ? '' : ' FOR EACH ROW';
+        const sql = `CREATE TRIGGER ${triggerName}\n${options.timing} ${events} ON ${tableName}${level}\nBEGIN\n${options.body}\nEND`;
+        await this.query(sql);
+    }
+    async dropTrigger(triggerName, _tableName, options) {
+        const name = options?.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(triggerName)}`
+            : this.escapeId(triggerName);
+        if (options?.ifExists) {
+            const exists = await this.hasTrigger(triggerName, _tableName, options.schema);
+            if (!exists)
+                return;
+        }
+        await this.query(`DROP TRIGGER ${name}`);
+    }
+    async hasTrigger(triggerName, _tableName, schema) {
+        let sql = `SELECT TRIGGER_NAME FROM SYS.TRIGGERS WHERE TRIGGER_NAME = '${triggerName.toUpperCase()}'`;
+        if (schema)
+            sql += ` AND SCHEMA_NAME = '${schema.toUpperCase()}'`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    // ==================== Row-Level Security stubs (see createSecurityPolicy) ====================
+    async createPolicy(_options) {
+        throw new Error('HANA has no row-level-security policy statement; use Structured/Analytic Privileges instead.');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw new Error('HANA has no row-level-security policy statement; use Structured/Analytic Privileges instead.');
+    }
+    async enableRLS() {
+        throw new Error('HANA has no row-level-security toggle; use Structured/Analytic Privileges instead.');
+    }
+    async disableRLS() {
+        throw new Error('HANA has no row-level-security toggle; use Structured/Analytic Privileges instead.');
+    }
+    async hasPolicy() {
+        return false;
+    }
+    // ==================== Comments ====================
+    async commentTable(tableName, comment) {
+        await this.query(`COMMENT ON TABLE ${this.quoteTable(tableName)} IS '${comment.replace(/'/g, "''")}'`);
+    }
+    async commentColumn(tableName, columnName, comment) {
+        await this.query(`COMMENT ON COLUMN ${this.quoteTable(tableName)}.${this.escapeId(columnName)} IS '${comment.replace(/'/g, "''")}'`);
+    }
+}
+exports.HanaDialect = HanaDialect;