uql-orm 0.37.1 → 0.39.0

package/dist/dialect/indexSqlDialect.js

@@ -1,103 +0,0 @@
-import { INDEX_FEATURE_LABELS } from '../type/index.js';
-import { VectorSqlDialect } from './vectorSqlDialect.js';
-/**
- * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
- *
- * A layer of its own for the same reason as {@link VectorSqlDialect} below it - it needs only
- * `escapeId` and `features.indexIfNotExists` from the SQL dialect above, so keeping it here spares
- * that 2000-line class thirteen more members. What each engine can express at all is data
- * ({@link indexFeatures}), validated once, rather than a throw per feature per dialect.
- */
-export class IndexSqlDialect extends VectorSqlDialect {
-    /**
-     * The `CREATE INDEX` statement for this dialect. The form here is the portable one, which SQLite
-     * (and so libSQL, Turso and D1) takes verbatim: no access-method clause, no operator classes, no
-     * tuning parameters. Dialects that have those override the fragments below rather than this.
-     */
-    getCreateIndexStatement(tableName, index, opts = {}) {
-        this.assertIndexFeatures(index);
-        const unique = index.unique ? 'UNIQUE ' : '';
-        const ifNotExists = (opts.ifNotExists ?? this.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
-        const columns = index.entries.map((entry) => this.indexColumn(entry, index)).join(', ');
-        return (`CREATE ${unique}${this.indexKeyword(index)} ${ifNotExists}${this.escapeId(index.name)} ` +
-            `ON ${this.escapeId(tableName)}${this.indexAccessMethod(index)} (${columns})` +
-            `${this.indexInclude(index)}${this.indexTuning(index)}${this.indexPredicate(index)};`);
-    }
-    /**
-     * Index features this dialect can express. Everything here is supported by at least one engine and
-     * refused by at least one other, so an index asking for a missing one is rejected rather than
-     * emitted: each of them is a hard error at the server, not a slower plan.
-     */
-    indexFeatures = new Set(['expression', 'partial']);
-    assertIndexFeatures(index) {
-        const requested = [
-            ['expression', index.entries.some((entry) => entry.expression)],
-            ['partial', index.where !== undefined],
-            ['prefixLength', index.entries.some((entry) => entry.length !== undefined)],
-            ['nullsOrder', index.entries.some((entry) => entry.nulls !== undefined)],
-            ['opsClass', index.entries.some((entry) => entry.opsClass !== undefined)],
-            ['include', Boolean(index.include?.length)],
-        ];
-        for (const [feature, needed] of requested) {
-            if (needed && !this.indexFeatures.has(feature)) {
-                throw new TypeError(`${this.dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
-            }
-        }
-    }
-    /**
-     * The column-level declaration for a vector index that lives inside `CREATE TABLE` rather than in
-     * its own statement, which the `inlineVectorIndex` feature flags. Only MariaDB has one.
-     */
-    getInlineVectorIndexDeclaration(index) {
-        throw new TypeError(`${this.dialectName} has no inline vector index (index "${index.name}")`);
-    }
-    /** Only CockroachDB's native vector index replaces the `INDEX` keyword. */
-    indexKeyword(_index) {
-        return 'INDEX';
-    }
-    /** One index entry: what is indexed, its operator class if any, then its stored order. */
-    indexColumn(entry, index) {
-        return `${this.indexColumnTarget(entry)}${this.indexColumnOpsClass(entry, index)}${this.indexColumnOrder(entry)}`;
-    }
-    /**
-     * A quoted column, optionally prefix-limited, or an expression in its own parentheses - the form
-     * `((lower("email")))` that MySQL requires and Postgres, CockroachDB and SQLite all accept, so one
-     * rendering serves every engine that has expression indexes.
-     */
-    indexColumnTarget(entry) {
-        if (entry.expression) {
-            return `(${entry.column})`;
-        }
-        const column = this.escapeId(entry.column);
-        return entry.length === undefined ? column : `${column}(${entry.length})`;
-    }
-    /** Postgres-wire dialects put a vector or user-declared operator class here. */
-    indexColumnOpsClass(_entry, _index) {
-        return '';
-    }
-    /** `ASC` is every engine's default, so only `DESC` is worth emitting. */
-    indexColumnOrder(entry) {
-        const order = entry.order === 'desc' ? ' DESC' : '';
-        return entry.nulls ? `${order} NULLS ${entry.nulls.toUpperCase()}` : order;
-    }
-    /** ` INCLUDE (...)`: non-key columns stored for index-only scans. Postgres-wire only. */
-    indexInclude(_index) {
-        return '';
-    }
-    /** ` USING <method>`, which SQLite's grammar has no place for at all. */
-    indexAccessMethod(_index) {
-        return '';
-    }
-    /** pgvector's ` WITH (m = ..., ef_construction = ..., lists = ...)`. */
-    indexTuning(_index) {
-        return '';
-    }
-    /**
-     * The partial-index predicate. Engines without one reject the index in {@link assertIndexFeatures}
-     * rather than reaching here: silently widening a partial unique index changes which rows the
-     * database accepts.
-     */
-    indexPredicate(index) {
-        return index.where ? ` WHERE ${index.where}` : '';
-    }
-}