@deterministic-code/datasources-oracle 0.1.17 → 0.1.29

package/dist/DefaultValueConverter.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValueOptions } from "./DefaultValueOptions.js";
+export declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+export type SpecToken = {
+    spec: RegExp;
+    specText?: (arg: string) => string;
+};
+export type DefaultEntry = SpecToken & {
+    native: (arg: string) => string;
+    reverse: RegExp;
+};
+type DefaultToken = {
+    token: string;
+    arg?: string | boolean;
+};
+export declare const sqlStringLiteral: (value: string | number | boolean | null | undefined) => string;
+export declare class DefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(options: DefaultValueOptions);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert: (specType: string, text: string) => string | null;
+    reverseConvert: (specType: string, native: string) => string;
+    private static dictionaryOf;
+}
+export {};

package/dist/DefaultValueConverter.js

@@ -0,0 +1,172 @@
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const NUMERIC_TYPES = [
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+];
+const NUMERIC_LITERAL_TYPES = new Set([...NUMERIC_TYPES, "reference"]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const quotedReverse = /^'(.*)'$/;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = { spec: /^-?[0-9]+(\.[0-9]+)?$/, specText: identity };
+export const sqlStringLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exact = (text) => new RegExp(`^${escapeRe(text)}$`);
+const quoted = (arg) => sqlStringLiteral(arg);
+const callTokenName = (name) => (name === "uuid" ? "Uuid" : name);
+const token = (specToken, native, reverse) => ({
+    ...specToken,
+    native,
+    reverse,
+});
+export class DefaultValueConverter {
+    static spec = {
+        string: { String: { spec: /^.*$/, specText: identity } },
+        character: { String: { spec: /^.+$/, specText: identity } },
+        integer: { Numeric: intLit },
+        unsignedinteger: { Numeric: uintLit },
+        smallinteger: { Numeric: intLit },
+        unsignedsmallinteger: { Numeric: uintLit },
+        biginteger: { Numeric: intLit },
+        unsignedbiginteger: { Numeric: uintLit },
+        float: { Numeric: floatLit },
+        decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+        boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+        datetime: {
+            Now: { spec: /^Now$/ },
+            UtcNow: { spec: /^UtcNow$/ },
+            DateTime: {
+                spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+                specText: (arg) => `DateTime('${arg}')`,
+            },
+        },
+        binary: {
+            Hex: { spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/, specText: (arg) => `Hex('${arg}')` },
+        },
+        uuid: {
+            NewId: { spec: /^NewId$/ },
+            Empty: { spec: /^Empty$/ },
+            Uuid: {
+                spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+                specText: (arg) => `uuid('${arg}')`,
+            },
+        },
+        reference: {},
+    };
+    dictionary;
+    constructor(options) {
+        this.dictionary = DefaultValueConverter.dictionaryOf(options);
+    }
+    static parse(specType, value) {
+        if (value === undefined || value === null)
+            return { token: "None" };
+        const v = String(value);
+        const call = CALL_FORM.exec(v);
+        if (call !== null)
+            return { token: callTokenName(call[1]), arg: call[2] };
+        if (specType === "boolean") {
+            return { token: "Boolean", arg: typeof value === "boolean" ? value : v === "true" };
+        }
+        if (NUMERIC_LITERAL_TYPES.has(specType))
+            return { token: "Numeric", arg: v };
+        if (specType === "datetime") {
+            if (v === "Now")
+                return { token: "Now" };
+            if (v === "UtcNow")
+                return { token: "UtcNow" };
+            return { token: "DateTime", arg: v };
+        }
+        if (specType === "uuid") {
+            if (v === "NewId")
+                return { token: "NewId" };
+            if (v === "Empty")
+                return { token: "Empty" };
+            return { token: "Uuid", arg: v };
+        }
+        if (specType === "binary")
+            return { token: "Hex", arg: v };
+        return { token: "String", arg: v };
+    }
+    convert = (specType, text) => {
+        const parsed = DefaultValueConverter.parse(specType, text);
+        if (parsed.token === "None")
+            return null;
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        const entry = entries[parsed.token];
+        if (entry === undefined)
+            return null;
+        if (!entry.spec.test(text)) {
+            throw new Error(`default_value '${text}' is not a valid ${specType} ${parsed.token} default`);
+        }
+        const expr = entry.native(parsed.arg === undefined ? "" : String(parsed.arg));
+        return expr === "" ? null : expr;
+    };
+    reverseConvert = (specType, native) => {
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        for (const [name, entry] of Object.entries(entries)) {
+            const match = entry.reverse.exec(native);
+            if (match === null)
+                continue;
+            const arg = match.slice(1).find((group) => group !== undefined) ?? "";
+            return entry.specText === undefined ? name : entry.specText(arg);
+        }
+        throw new Error(`Native default '${native}' is not a valid ${specType} default`);
+    };
+    static dictionaryOf = (opts) => {
+        const spec = DefaultValueConverter.spec;
+        const newId = opts.newId();
+        const now = opts.now();
+        const utcNow = opts.utcNow();
+        const numericEntries = (type) => {
+            const numeric = spec[type].Numeric;
+            return {
+                Numeric: token(numeric, (arg) => arg, numeric.spec),
+                String: token(numeric, (arg) => arg, numeric.spec),
+            };
+        };
+        const quote = opts.quote ?? quoted;
+        const quoteReverse = opts.quoteReverse ?? quotedReverse;
+        const quotedString = {
+            String: token(spec.string.String, quote, quoteReverse),
+            Numeric: token(spec.string.String, quote, quoteReverse),
+        };
+        const dictionary = {
+            string: quotedString,
+            character: {
+                String: token(spec.character.String, quote, quoteReverse),
+                Numeric: token(spec.character.String, quote, quoteReverse),
+            },
+            boolean: {
+                Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),
+            },
+            datetime: {
+                Now: token(spec.datetime.Now, () => now, exact(now)),
+                UtcNow: token(spec.datetime.UtcNow, () => utcNow, exact(utcNow)),
+                DateTime: token(spec.datetime.DateTime, quoted, quotedReverse),
+            },
+            binary: {
+                Hex: token(spec.binary.Hex, opts.hex, opts.hexReverse),
+            },
+            uuid: {
+                NewId: token(spec.uuid.NewId, () => newId, exact(newId)),
+                Empty: token(spec.uuid.Empty, () => quoted(EMPTY_UUID), exact(quoted(EMPTY_UUID))),
+                Uuid: token(spec.uuid.Uuid, quoted, quotedReverse),
+            },
+            reference: {},
+        };
+        for (const type of NUMERIC_TYPES)
+            dictionary[type] = numericEntries(type);
+        return dictionary;
+    };
+}

package/dist/DefaultValueOptions.d.ts

@@ -0,0 +1,11 @@
+export type DefaultValueOptions = {
+    newId: () => string;
+    now: () => string;
+    utcNow: () => string;
+    booleanOn: string;
+    booleanOff: string;
+    hex: (arg: string) => string;
+    hexReverse: RegExp;
+    quote?: (arg: string) => string;
+    quoteReverse?: RegExp;
+};

package/dist/DefaultValueOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/OracleAlterTableStatementRenderer.d.ts

@@ -1,4 +1,7 @@
-import { AlterTableStatementTextRenderer, type AlterAction } from "@deterministic-code/datasources";
+import { AlterTableStatementTextRenderer, type AlterAction, type Column } from "@deterministic-code/datasources";
 export declare class OracleAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected quote(name: string): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
     protected actionSql(action: AlterAction): string;
 }

package/dist/OracleAlterTableStatementRenderer.js

@@ -1,5 +1,19 @@
 import { AlterTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    quote(name) {
+        return OracleDriver.quote(name);
+    }
+    typeName(column) {
+        return OracleDriver.nativeType(column);
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${OracleDriver.nativeDefault(column)}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${OracleDriver.nativeDefault(column)}`;
+    }
     actionSql(action) {
         return action.kind === "addColumn"
             ? `ADD (${this.column(action.column)})`

package/dist/OracleCreateTableStatementRenderer.d.ts

@@ -1,4 +1,7 @@
 import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
 export declare class OracleCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected quote(name: string): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
     protected identity(column: Column): string;
 }

package/dist/OracleCreateTableStatementRenderer.js

@@ -1,5 +1,19 @@
 import { CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    quote(name) {
+        return OracleDriver.quote(name);
+    }
+    typeName(column) {
+        return OracleDriver.nativeType(column);
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${OracleDriver.nativeDefault(column)}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${OracleDriver.nativeDefault(column)}`;
+    }
     identity(column) {
         return column.identity ? " GENERATED BY DEFAULT AS IDENTITY" : "";
     }

package/dist/OracleCreateTriggerStatementRenderer.js

@@ -1,11 +1,12 @@
 import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
     render(statement) {
-        return `CREATE OR REPLACE TRIGGER ${statement.name}
-BEFORE UPDATE ON ${statement.table}
+        return `CREATE OR REPLACE TRIGGER ${OracleDriver.quote(statement.name)}
+BEFORE UPDATE ON ${OracleDriver.quote(statement.table)}
 FOR EACH ROW
 BEGIN
-  :NEW.${statement.updatedColumn} := ${statement.utcNow};
+  :NEW.${OracleDriver.quote(statement.updatedColumn)} := ${OracleDriver.utcNow()};
 END;
 /`;
     }

package/dist/OracleDriver.d.ts

@@ -1,11 +1,24 @@
-import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+import { StatementTextRenderer, type Cell, type Column, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type RoutineParameter, type TypeConverter } from "@deterministic-code/datasources";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 export declare class OracleDriver implements IDriver {
+    static readonly procedurePayloadType = "CLOB";
+    static procedureSpecs: (entityName: string, byGroups: string[][], casing: {
+        routineName: (stem: string) => string;
+        pluralStem: (entity: string) => string;
+    }) => import("./procedureSpecs.js").ProcSpec[];
+    static applyKeywords: (sql: string, keyword: (word: string) => string) => string;
+    static quote: (name: string) => string;
+    static nativeType: (column: Column) => string;
+    static nativeDefault: (column: Column) => string;
+    static utcNow: () => string;
+    static nativeParam: (parameter: RoutineParameter) => string;
     readonly statementRenderer: StatementTextRenderer;
     readonly information: Information;
     rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
     readonly quoteLeft = "\"";
     readonly quoteRight = "\"";
-    readonly typeConverter: DeterministicTypeConverter;
+    readonly typeConverter: TypeMap;
     readonly defaultValueConverter: DefaultValueConverter;
     columnType: (name: string) => string;
     connection: (options?: DatasourceOptions) => IConnection;

package/dist/OracleDriver.js

@@ -1,8 +1,54 @@
-import { columnType as identityColumnType, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, StubTransaction, } from "@deterministic-code/datasources";
+import { columnType as identityColumnType, StatementTextRenderer, StubTransaction, } from "@deterministic-code/datasources";
 import { OracleConnection } from "./connection.js";
 import { OracleStatementRenderer } from "./OracleStatementRenderer.js";
+import { procedureSpecs } from "./procedureSpecs.js";
+import { applyKeywords } from "./applyKeywords.js";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 const statements = new StatementTextRenderer(t => new OracleStatementRenderer(t));
+const types = new TypeMap({
+    string: "CLOB",
+    character: "CHAR(1)",
+    integer: "NUMBER(10)",
+    unsignedinteger: "NUMBER(10)",
+    smallinteger: "NUMBER(5)",
+    unsignedsmallinteger: "NUMBER(5)",
+    biginteger: "NUMBER(19)",
+    unsignedbiginteger: "NUMBER(20)",
+    float: "BINARY_DOUBLE",
+    decimal: "NUMBER",
+    boolean: "NUMBER(1)",
+    datetime: "TIMESTAMP",
+    binary: "BLOB",
+    uuid: "VARCHAR2(36)",
+    reference: "NUMBER(10)",
+});
+const defaults = new DefaultValueConverter({
+    newId: () => "SYS_GUID()",
+    now: () => "LOCALTIMESTAMP",
+    utcNow: () => "SYS_EXTRACT_UTC(SYSTIMESTAMP)",
+    booleanOn: "1",
+    booleanOff: "0",
+    hex: (arg) => `HEXTORAW('${arg}')`,
+    hexReverse: /^HEXTORAW\('(.*)'\)$/,
+});
 export class OracleDriver {
+    static procedurePayloadType = "CLOB";
+    static procedureSpecs = procedureSpecs;
+    static applyKeywords = applyKeywords;
+    static quote = (name) => `"${name}"`;
+    static nativeType = (column) => column.field ? types.convertField(column.field) : column.type;
+    static nativeDefault = (column) => column.default == null
+        ? ""
+        : column.field === undefined
+            ? column.default.value
+            : defaults.convert(column.field.type, column.default.value) ?? column.default.value;
+    static utcNow = () => defaults.convert("datetime", "UtcNow") ?? "";
+    static nativeParam = (parameter) => parameter.type === "payload"
+        ? OracleDriver.procedurePayloadType
+        : parameter.field
+            ? types.convertField(parameter.field)
+            : types.dictionary[parameter.type] ?? parameter.type;
     statementRenderer = statements;
     information = {
         descriptions: ["Oracle driver."],
@@ -20,41 +66,8 @@ export class OracleDriver {
     rowTypeConverters = {};
     quoteLeft = '"';
     quoteRight = '"';
-    typeConverter = new DeterministicTypeConverter({
-        string: "CLOB",
-        character: "CHAR(1)",
-        number: "NUMBER(10)",
-        integer: "NUMBER(10)",
-        unsignedinteger: "NUMBER(10)",
-        smallinteger: "NUMBER(5)",
-        unsignedsmallinteger: "NUMBER(5)",
-        biginteger: "NUMBER(19)",
-        unsignedbiginteger: "NUMBER(20)",
-        float: "BINARY_DOUBLE",
-        decimal: "NUMBER",
-        boolean: "NUMBER(1)",
-        datetime: "TIMESTAMP",
-        binary: "BLOB",
-        uuid: "VARCHAR2(36)",
-        reference: "NUMBER(10)",
-    }, {
-        dialectName: "oracle",
-        stringUnlimited: "CLOB",
-        stringSized: (n) => `VARCHAR2(${n})`,
-        character: "CHAR",
-        decimal: { kind: "required", type: "NUMBER" },
-        binaryUnlimited: "BLOB",
-        binarySized: (n) => `RAW(${n})`,
-    });
-    defaultValueConverter = new DefaultValueConverter({
-        newId: () => "SYS_GUID()",
-        now: () => "LOCALTIMESTAMP",
-        utcNow: () => "SYS_EXTRACT_UTC(SYSTIMESTAMP)",
-        booleanOn: "1",
-        booleanOff: "0",
-        hex: (arg) => `HEXTORAW('${arg}')`,
-        hexReverse: /^HEXTORAW\('(.*)'\)$/,
-    });
+    typeConverter = types;
+    defaultValueConverter = defaults;
     columnType = identityColumnType;
     connection = (options) => OracleConnection.from(options);
     command = (connection) => connection.createCommand();

package/dist/OracleDropIndexStatementRenderer.js

@@ -1,6 +1,7 @@
 import { DropIndexStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
     render(statement) {
-        return `DROP INDEX ${statement.name}`;
+        return `DROP INDEX ${OracleDriver.quote(statement.name)}`;
     }
 }

package/dist/OracleDropTableStatementRenderer.js

@@ -1,7 +1,8 @@
 import { DropTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleDropTableStatementRenderer extends DropTableStatementTextRenderer {
     render(statement) {
-        return `BEGIN EXECUTE IMMEDIATE 'DROP TABLE ${statement.table} CASCADE CONSTRAINTS'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF; END;
+        return `BEGIN EXECUTE IMMEDIATE 'DROP TABLE ${OracleDriver.quote(statement.table)} CASCADE CONSTRAINTS'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF; END;
 /`;
     }
 }

package/dist/OracleDropTriggerStatementRenderer.js

@@ -1,6 +1,7 @@
 import { DropTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
 export class OracleDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
     render(statement) {
-        return `DROP TRIGGER ${statement.name}`;
+        return `DROP TRIGGER ${OracleDriver.quote(statement.name)}`;
     }
 }

package/dist/OracleQuotedRenderers.d.ts

@@ -0,0 +1,7 @@
+import { CreateIndexStatementTextRenderer, type ForeignKeyStatement } from "@deterministic-code/datasources";
+export declare class OracleCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class OracleForeignKeyStatementRenderer {
+    render(statement: ForeignKeyStatement): string;
+}

package/dist/OracleQuotedRenderers.js

@@ -0,0 +1,18 @@
+import { CreateIndexStatementTextRenderer, } from "@deterministic-code/datasources";
+import { OracleDriver } from "./OracleDriver.js";
+export class OracleCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    quote(name) {
+        return OracleDriver.quote(name);
+    }
+}
+export class OracleForeignKeyStatementRenderer {
+    render(statement) {
+        const table = OracleDriver.quote(statement.table);
+        const name = OracleDriver.quote(statement.name);
+        if (statement.kind === "drop")
+            return `ALTER TABLE ${table} DROP CONSTRAINT ${name}`;
+        const cols = statement.columns.map(OracleDriver.quote).join(", ");
+        const refs = statement.referencesColumns.map(OracleDriver.quote).join(", ");
+        return `ALTER TABLE ${table} ADD CONSTRAINT ${name} FOREIGN KEY (${cols}) REFERENCES ${OracleDriver.quote(statement.referencesTable)} (${refs})`;
+    }
+}

package/dist/OracleSqlSeedStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { SqlSeedStatement } from "@deterministic-code/datasources";
+export declare class OracleSqlSeedStatementRenderer {
+    render(statement: SqlSeedStatement): string;
+}

package/dist/OracleSqlSeedStatementRenderer.js

@@ -0,0 +1,49 @@
+const quote = (ident) => `"${ident}"`;
+const quoteString = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const truthy = (value) => value === true || value === "true" || value === "True" || value === 1;
+const numeric = new Set([
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "reference",
+    "float",
+    "decimal",
+]);
+const defaultSql = (type, def) => {
+    const text = String(def);
+    if (type === "datetime" && text === "UtcNow")
+        return "SYS_EXTRACT_UTC(SYSTIMESTAMP)";
+    if (type === "datetime" && text === "Now")
+        return "LOCALTIMESTAMP";
+    if (type === "uuid" && text === "NewId")
+        return "SYS_GUID()";
+    if (type === "boolean")
+        return text === "true" || text === "True" ? "1" : "0";
+    return quoteString(text);
+};
+const literal = (column) => {
+    if (column.value == null)
+        return column.field.defaultValue != null ? defaultSql(column.field.type, column.field.defaultValue) : "NULL";
+    if (column.field.type === "boolean")
+        return truthy(column.value) ? "1" : "0";
+    if (numeric.has(column.field.type))
+        return String(column.value);
+    if (column.field.type === "binary")
+        return `HEXTORAW('${column.value}')`;
+    return quoteString(column.value);
+};
+export class OracleSqlSeedStatementRenderer {
+    render(statement) {
+        const table = quote(statement.table);
+        if (statement.kind === "delete") {
+            const key = statement.columns[0];
+            return `DELETE FROM ${table} WHERE ${quote(key.column)} = ${literal(key)}`;
+        }
+        const cols = statement.columns.map((c) => quote(c.column)).join(", ");
+        const values = statement.columns.map(literal).join(", ");
+        return `INSERT INTO ${table} (${cols}) VALUES (${values})`;
+    }
+}

package/dist/OracleStatementRenderer.d.ts

@@ -1,4 +1,4 @@
-import { AlterTableStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropTableStatement, DropTriggerStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+import { AlterTableStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateIndexStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropTableStatement, DropTriggerStatement, ForeignKeyStatement, SqlSeedStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
 export declare class OracleStatementRenderer extends StatementRenderer {
     constructor(text: StatementTextRenderer);
     protected visitCreateTable(create: CreateTableStatement): string;
@@ -15,4 +15,7 @@ export declare class OracleStatementRenderer extends StatementRenderer {
     protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
     protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
     protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+    protected visitSqlSeed(seed: SqlSeedStatement): string;
+    protected visitCreateIndex(index: CreateIndexStatement): string;
+    protected visitForeignKey(key: ForeignKeyStatement): string;
 }

package/dist/OracleStatementRenderer.js

@@ -6,6 +6,8 @@ import { OracleDropIndexStatementRenderer } from "./OracleDropIndexStatementRend
 import { OracleDropTableStatementRenderer } from "./OracleDropTableStatementRenderer.js";
 import { OracleDropTriggerStatementRenderer } from "./OracleDropTriggerStatementRenderer.js";
 import { OracleStoredProcedureStatementRenderer } from "./OracleStoredProcedureStatementRenderer.js";
+import { OracleSqlSeedStatementRenderer } from "./OracleSqlSeedStatementRenderer.js";
+import { OracleCreateIndexStatementRenderer, OracleForeignKeyStatementRenderer } from "./OracleQuotedRenderers.js";
 export class OracleStatementRenderer extends StatementRenderer {
     constructor(text) {
         super(text);
@@ -52,4 +54,13 @@ export class OracleStatementRenderer extends StatementRenderer {
     visitCreateBulkDeleteStoredProcedureStatement(statement) {
         return new OracleStoredProcedureStatementRenderer().renderBulkDelete(statement);
     }
+    visitSqlSeed(seed) {
+        return new OracleSqlSeedStatementRenderer().render(seed);
+    }
+    visitCreateIndex(index) {
+        return new OracleCreateIndexStatementRenderer().render(index);
+    }
+    visitForeignKey(key) {
+        return new OracleForeignKeyStatementRenderer().render(key);
+    }
 }

package/dist/OracleStoredProcedureStatementRenderer.js

@@ -1,6 +1,8 @@
 import { DefaultStatementTextRenderer } from "@deterministic-code/datasources";
-const params = (list) => list.map((p) => `  ${p.name} IN ${p.type}`).join(",\n");
-const jsonColumns = (columns) => columns.map((c) => `${c.name} ${c.type} PATH '$.${c.name}'`).join(", ");
+import { OracleDriver } from "./OracleDriver.js";
+const typeOf = (parameter) => OracleDriver.nativeParam(parameter);
+const params = (list) => list.map((p) => `  ${p.name} IN ${typeOf(p)}`).join(",\n");
+const jsonColumns = (columns) => columns.map((c) => `${c.name} ${typeOf(c)} PATH '$.${c.name}'`).join(", ");
 export class OracleStoredProcedureStatementRenderer {
     renderCreate(statement) {
         return `CREATE OR REPLACE PROCEDURE ${statement.name}(
@@ -14,7 +16,7 @@ END;`;
     renderNestedRead(statement) {
         const select = DefaultStatementTextRenderer.instance.render(statement.select);
         const signature = statement.arguments
-            .map((argument) => `${argument.parameter.name} IN ${argument.parameter.type}`)
+            .map((argument) => `${argument.parameter.name} IN ${typeOf(argument.parameter)}`)
             .join(", ");
         return `CREATE OR REPLACE PROCEDURE ${statement.name}(${signature}) AS
 BEGIN
@@ -30,7 +32,7 @@ BEGIN
 END;`;
         }
         const signature = statement.byProperties
-            .map((c) => `${c} IN ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `${c} IN ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = statement.byProperties.map((c) => `t.${c} = ${c}`).join(" AND ");
         return `CREATE OR REPLACE PROCEDURE ${statement.name}(${signature}) AS
@@ -60,7 +62,7 @@ END;`;
     renderDelete(statement) {
         const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
         const signature = by
-            .map((c) => `${c} IN ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `${c} IN ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = by.map((c) => `t.${c} = ${c}`).join(" AND ");
         return `CREATE OR REPLACE PROCEDURE ${statement.name}(${signature}) AS
@@ -96,7 +98,7 @@ END;`;
 BEGIN
   DELETE FROM ${statement.table} t
   WHERE t.${statement.key} IN (
-    SELECT ${statement.key} FROM JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (${statement.key} ${statement.keyType} PATH '$.${statement.key}'))
+    SELECT ${statement.key} FROM JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (${statement.key} ${OracleDriver.nativeParam({ name: statement.key, type: statement.keyType })} PATH '$.${statement.key}'))
   );
 END;`;
     }

package/dist/TypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { IMapping, SpecField } from "@deterministic-code/datasources";
+export declare class TypeMap implements IMapping<string, string> {
+    readonly dictionary: Record<string, string>;
+    private readonly reverse;
+    constructor(dictionary: Record<string, string>);
+    convert: (from: string) => string;
+    convertField: (field: SpecField) => string;
+    reverseConvert: (native: string) => string;
+}

package/dist/TypeMap.js

@@ -0,0 +1,35 @@
+export class TypeMap {
+    dictionary;
+    reverse = new Map();
+    constructor(dictionary) {
+        this.dictionary = dictionary;
+        for (const [spec, native] of Object.entries(dictionary)) {
+            if (!this.reverse.has(native))
+                this.reverse.set(native, spec);
+        }
+    }
+    convert = (from) => this.dictionary[from] ??
+        (() => {
+            throw new Error(`Unknown spec field type: ${from}`);
+        })();
+    convertField = (field) => {
+        if (field.type === "string")
+            return field.size == null || field.size === "unlimited" ? "CLOB" : `VARCHAR2(${field.size})`;
+        if (field.type === "character")
+            return `CHAR(${field.size == null ? 1 : Number(field.size)})`;
+        if (field.type === "decimal") {
+            if (field.size == null)
+                return "NUMBER";
+            if (Array.isArray(field.size) && field.size.length === 2)
+                return `NUMBER(${field.size[0]}, ${field.size[1]})`;
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${field.size}`);
+        }
+        if (field.type === "binary")
+            return field.size == null || field.size === "unlimited" ? "BLOB" : `RAW(${field.size})`;
+        return this.convert(field.type);
+    };
+    reverseConvert = (native) => this.reverse.get(native) ??
+        (() => {
+            throw new Error(`Unknown native field type: ${native}`);
+        })();
+}

package/dist/applyKeywords.d.ts

@@ -0,0 +1 @@
+export declare const applyKeywords: (sql: string, keyword: (word: string) => string) => string;

package/dist/applyKeywords.js

@@ -0,0 +1,14 @@
+const KEYWORDS = new Set([
+    "AFTER", "ALTER", "AND", "AS", "AT", "BEFORE", "BEGIN", "BETWEEN", "BINARY_DOUBLE", "BLOB",
+    "BY", "CASCADE", "CAST", "CHAR", "CLOB", "CONSTRAINT", "CONSTRAINTS", "CREATE", "DECIMAL",
+    "DECLARE", "DEFAULT", "DELETE", "DROP", "EACH", "ELSE", "END", "EXCEPTION", "EXECUTE",
+    "EXISTS", "FALSE", "FLOAT", "FOR", "FOREIGN", "FROM", "FUNCTION", "IF", "IMMEDIATE", "IN",
+    "INDEX", "INNER", "INSERT", "INT", "INTEGER", "INTO", "JOIN", "KEY", "LANGUAGE",
+    "LOCALTIMESTAMP", "NCHAR", "NOT", "NULL", "NUMBER", "NUMERIC", "OLD", "ON", "OR", "ORDER",
+    "OTHERS", "PRECISION", "PRIMARY", "PROCEDURE", "RAISE", "RAW", "REFERENCES", "REPLACE",
+    "RETURN", "RETURNING", "ROW", "SELECT", "SET", "SMALLINT", "SQLCODE", "SYS_EXTRACT_UTC",
+    "SYS_GUID", "SYSTIMESTAMP", "TABLE", "THEN", "TIMESTAMP", "TRIGGER", "TRUE", "UNIQUE",
+    "UPDATE", "VALUES", "VARCHAR", "VARCHAR2", "WHEN", "WHERE", "ZONE",
+]);
+const TOKEN = /('(?:''|[^'])*')|("(?:""|[^"])*")|(--[^\n]*)|(\/\*[\s\S]*?\*\/)|(?<word>[A-Za-z_][A-Za-z0-9_]*)/g;
+export const applyKeywords = (sql, keyword) => sql.replace(TOKEN, (match, _s, _d, _lc, _bc, word) => word !== undefined && KEYWORDS.has(word.toUpperCase()) ? keyword(word) : match);

package/dist/procedureSpecs.d.ts

@@ -0,0 +1,10 @@
+export type ProcOp = "create" | "read" | "update" | "delete" | "bulkCreate" | "bulkUpdate" | "bulkDelete";
+export type ProcSpec = {
+    op: ProcOp;
+    name: string;
+    byProperties: string[];
+};
+export declare const procedureSpecs: (entityName: string, byGroups: string[][], casing: {
+    routineName: (stem: string) => string;
+    pluralStem: (entity: string) => string;
+}) => ProcSpec[];

package/dist/procedureSpecs.js

@@ -0,0 +1,17 @@
+export const procedureSpecs = (entityName, byGroups, casing) => {
+    const name = (stem) => casing.routineName(stem);
+    const plural = casing.pluralStem(entityName);
+    const bySuffix = (props) => props.length === 0 ? "" : `_by_${props.join("_")}`;
+    return [
+        { op: "create", name: name(`create_${plural}`), byProperties: [] },
+        { op: "read", name: name(`read_${plural}`), byProperties: [] },
+        ...byGroups.flatMap((props) => [
+            { op: "read", name: name(`read_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "update", name: name(`update_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "delete", name: name(`delete_${plural}${bySuffix(props)}`), byProperties: props },
+        ]),
+        { op: "bulkCreate", name: name(`bulk_create_${plural}`), byProperties: [] },
+        { op: "bulkUpdate", name: name(`bulk_update_${plural}`), byProperties: [] },
+        { op: "bulkDelete", name: name(`bulk_delete_${plural}`), byProperties: [] },
+    ];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-oracle",
-  "version": "0.1.17",
+  "version": "0.1.29",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -18,6 +18,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.17"
+    "@deterministic-code/datasources": "^0.1.29"
   }
 }