Class BaseDialectAbstract

constructor

• new BaseDialect(): BaseDialect

  Returns BaseDialect

Abstract Readonlyname

Abstract Readonlylibrary

Abstractconnect

• connect(): Promise<void>

  Connect to the database

  Returns Promise<void>

Abstractdisconnect

• disconnect(): Promise<void>

  Disconnect from the database

  Returns Promise<void>

AbstractgetConnection

• getConnection(): any

  Get the current connection

  Returns any

AbstractisConnected

• isConnected(): boolean

  Check if connected

  Returns boolean

Abstractquery

• query(sql: string, options?: QueryOptions): Promise<QueryResult>

  Execute a raw query

  Parameters

  • sql: string

    The SQL query string

  • Optionaloptions: QueryOptions

    Query options

  Returns Promise<QueryResult>

AbstractqueryStream

• queryStream(sql: string, options?: StreamOptions): Readable

  Execute a query and stream the results back as a Node.js Readable (object mode — one row, or one model instance when options.mapToModel is set, per chunk) instead of buffering the whole result set in memory. Used by Model.findAllStream()/findAllIterate() for processing large tables without loading them all into memory at once.

  Native server-side cursor support (postgres/mysql/cockroachdb) is used where the driver has it; other dialects fall back to LIMIT/OFFSET-paged queries — correct and dialect-agnostic, though it does more round trips than a real cursor for very large result sets.

  Parameters

  • sql: string

    The SQL query string to stream results for

  • Optionaloptions: StreamOptions

    Streaming options (batch size, backpressure watermark, model mapping)

  Returns Readable

  Example

  const stream = dialect.queryStream('SELECT * FROM users', { batchSize: 500 });
  for await (const row of stream) { console.log(row); }
  Copy

Abstractescape

• escape(value: any): string

  Escape a value for use in a query

  Parameters

  • value: any

    The value to escape

  Returns string

AbstractescapeId

• escapeId(identifier: string): string

  Escape an identifier (table name, column name, etc.)

  Parameters

  • identifier: string

    The identifier to escape

  Returns string

AbstractquoteIdentifier

• quoteIdentifier(identifier: string): string

  Quote an identifier (column name, table name)

  Parameters

  • identifier: string

    The identifier to quote

  Returns string

AbstractquoteTable

• quoteTable(tableName: string, schema?: string): string

  Quote a table name

  Parameters

  • tableName: string

    The table name to quote

  • Optionalschema: string

    Optional schema to prefix the table with

  Returns string

AbstractgetDatabaseVersion

• getDatabaseVersion(): Promise<string>

  Get database version

  Returns Promise<string>

AbstractcreateTable

• createTable(
      tableName: string,
      columns: Record<string, ColumnDefinition>,
      options?: TableOptions,
  ): Promise<void>

  Create a new table

  Parameters

  • tableName: string

    Name of the table

  • columns: Record<string, ColumnDefinition>

    Column definitions

  • Optionaloptions: TableOptions

    Additional options

  Returns Promise<void>

AbstractdropTable

• dropTable(tableName: string, options?: DropTableOptions): Promise<void>

  Drop a table

  Parameters

  • tableName: string

    Name of the table

  • Optionaloptions: DropTableOptions

    Additional options

  Returns Promise<void>

AbstractcreatePartitionedTable

• createPartitionedTable(
      tableName: string,
      columns: Record<string, ColumnDefinition>,
      options?: TableOptions & {
          partitionBy: {
              type: "range" | "list" | "hash";
              column: string | string[];
          };
          partitions?: {
              name: string;
              bound?: PartitionBound;
              tablespace?: string;
              storageParameters?: Record<string, string | number>;
          }[];
      },
  ): Promise<void>

  Create a partitioned table (PostgreSQL 10+)

  Parameters

  • tableName: string
  • columns: Record<string, ColumnDefinition>
  • Optionaloptions: TableOptions & {
        partitionBy: {
            type: "range" | "list" | "hash";
            column: string | string[];
        };
        partitions?: {
            name: string;
            bound?: PartitionBound;
            tablespace?: string;
            storageParameters?: Record<string, string | number>;
        }[];
    }

  Returns Promise<void>

AbstractcreatePartition

• createPartition(options: CreatePartitionOptions): Promise<void>

  Create a partition for an existing partitioned table (PostgreSQL 10+)

  Parameters

  • options: CreatePartitionOptions

  Returns Promise<void>

AbstractattachPartition

• attachPartition(options: AttachPartitionOptions): Promise<void>

  Attach a partition to a partitioned table (PostgreSQL 11+)

  Parameters

  • options: AttachPartitionOptions

  Returns Promise<void>

AbstractdetachPartition

• detachPartition(options: DetachPartitionOptions): Promise<void>

  Detach a partition from a partitioned table (PostgreSQL 11+)

  Parameters

  • options: DetachPartitionOptions

  Returns Promise<void>

AbstractdropPartition

• dropPartition(
      partitionName: string,
      options?: { ifExists?: boolean; cascade?: boolean },
  ): Promise<void>

  Drop a partition (PostgreSQL 10+)

  Parameters

  • partitionName: string
  • Optionaloptions: { ifExists?: boolean; cascade?: boolean }

  Returns Promise<void>

AbstractcreateView

• createView(
      viewName: string,
      query: string,
      options?: ViewOptions,
  ): Promise<void>

  Create a database view

  Parameters

  • viewName: string

    Name of the view to create

  • query: string

    The SELECT query for the view

  • Optionaloptions: ViewOptions

    View options

  Returns Promise<void>

AbstractdropView

• dropView(viewName: string, options?: DropViewOptions): Promise<void>

  Drop a database view

  Parameters

  • viewName: string

    Name of the view to drop

  • Optionaloptions: DropViewOptions

    Drop options

  Returns Promise<void>

AbstractcreateMaterializedView

• createMaterializedView(options: MaterializedViewOptions): Promise<void>

  Create a materialized view (PostgreSQL only)

  Parameters

  • options: MaterializedViewOptions

    Materialized view options

  Returns Promise<void>

AbstractrefreshMaterializedView

• refreshMaterializedView(
      viewName: string,
      options?: RefreshOptions,
  ): Promise<void>

  Refresh a materialized view (PostgreSQL only)

  Parameters

  • viewName: string

    Name of the materialized view to refresh

  • Optionaloptions: RefreshOptions

    Refresh options

  Returns Promise<void>

AbstractdropMaterializedView

• dropMaterializedView(
      viewName: string,
      options?: DropMaterializedViewOptions,
  ): Promise<void>

  Drop a materialized view (PostgreSQL only)

  Parameters

  • viewName: string

    Name of the materialized view to drop

  • Optionaloptions: DropMaterializedViewOptions

    Drop options

  Returns Promise<void>

AbstracthasMaterializedView

• hasMaterializedView(viewName: string): Promise<boolean>

  Check if a materialized view exists (PostgreSQL only)

  Parameters

  • viewName: string

    Name of the materialized view

  Returns Promise<boolean>

  True if the materialized view exists

AbstractcreateStoredProcedure

• createStoredProcedure(options: StoredProcedureOptions): Promise<void>

  Create a stored procedure

  Parameters

  • options: StoredProcedureOptions

    Stored procedure options

  Returns Promise<void>

createProcedure

• createProcedure(options: StoredProcedureOptions): Promise<void>

  Create a stored procedure (alias for createStoredProcedure)

  Parameters

  • options: StoredProcedureOptions

    Stored procedure options

  Returns Promise<void>

AbstractdropStoredProcedure

• dropStoredProcedure(
      procedureName: string,
      options?: DropStoredProcedureOptions,
  ): Promise<void>

  Drop a stored procedure

  Parameters

  • procedureName: string

    Name of the stored procedure

  • Optionaloptions: DropStoredProcedureOptions

    Drop options

  Returns Promise<void>

dropProcedure

• dropProcedure(
      procedureName: string,
      options?: DropStoredProcedureOptions,
  ): Promise<void>

  Drop a stored procedure (alias for dropStoredProcedure)

  Parameters

  • procedureName: string

    Name of the stored procedure

  • Optionaloptions: DropStoredProcedureOptions

    Drop options

  Returns Promise<void>

AbstractexecuteStoredProcedure

• executeStoredProcedure(
      options: ExecuteStoredProcedureOptions,
  ): Promise<QueryResult>

  Execute a stored procedure

  Parameters

  • options: ExecuteStoredProcedureOptions

    Execute options

  Returns Promise<QueryResult>

  Query result

AbstracthasStoredProcedure

• hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>

  Check if a stored procedure exists

  Parameters

  • procedureName: string

    Name of the stored procedure

  • Optionalschema: string

    Schema name (PostgreSQL)

  Returns Promise<boolean>

  True if the stored procedure exists

AbstractcreateTrigger

• createTrigger(options: TriggerOptions): Promise<void>

  Create a trigger

  Parameters

  • options: TriggerOptions

    Trigger options

  Returns Promise<void>

AbstractdropTrigger

• dropTrigger(
      triggerName: string,
      tableName: string,
      options?: DropTriggerOptions,
  ): Promise<void>

  Drop a trigger

  Parameters

  • triggerName: string

    Name of the trigger

  • tableName: string

    Table the trigger is attached to

  • Optionaloptions: DropTriggerOptions

    Drop options

  Returns Promise<void>

AbstracthasTrigger

• hasTrigger(triggerName: string, tableName: string): Promise<boolean>

  Check if a trigger exists

  Parameters

  • triggerName: string

    Name of the trigger

  • tableName: string

    Table the trigger is attached to

  Returns Promise<boolean>

  True if the trigger exists

AbstractcreateSequence

• createSequence(options: SequenceOptions): Promise<void>

  Create a sequence (PostgreSQL)

  Parameters

  • options: SequenceOptions

    Sequence options

  Returns Promise<void>

AbstractdropSequence

• dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>

  Drop a sequence (PostgreSQL)

  Parameters

  • sequenceName: string

    Name of the sequence

  • Optionaloptions: DropSequenceOptions

    Drop options

  Returns Promise<void>

AbstractnextSequenceValue

• nextSequenceValue(sequenceName: string): Promise<number>

  Get next value from a sequence (PostgreSQL)

  Parameters

  • sequenceName: string

    Name of the sequence

  Returns Promise<number>

  Next sequence value

AbstracthasSequence

• hasSequence(sequenceName: string): Promise<boolean>

  Check if a sequence exists (PostgreSQL)

  Parameters

  • sequenceName: string

    Name of the sequence

  Returns Promise<boolean>

  True if the sequence exists

AbstractcreatePolicy

• createPolicy(options: PolicyOptions): Promise<void>

  Create a policy (PostgreSQL RLS)

  Parameters

  • options: PolicyOptions

    Policy options

  Returns Promise<void>

AbstractdropPolicy

• dropPolicy(
      policyName: string,
      tableName: string,
      options?: DropPolicyOptions,
  ): Promise<void>

  Drop a policy (PostgreSQL RLS)

  Parameters

  • policyName: string

    Name of the policy

  • tableName: string

    Table name

  • Optionaloptions: DropPolicyOptions

    Drop options

  Returns Promise<void>

AbstractenableRLS

• enableRLS(tableName: string, schema?: string): Promise<void>

  Enable row-level security on a table (PostgreSQL)

  Parameters

  • tableName: string

    Table name

  • Optionalschema: string

    Schema name

  Returns Promise<void>

AbstractdisableRLS

• disableRLS(tableName: string, schema?: string): Promise<void>

  Disable row-level security on a table (PostgreSQL)

  Parameters

  • tableName: string

    Table name

  • Optionalschema: string

    Schema name

  Returns Promise<void>

AbstracthasPolicy

• hasPolicy(policyName: string, tableName: string): Promise<boolean>

  Check if a policy exists (PostgreSQL RLS)

  Parameters

  • policyName: string

    Name of the policy

  • tableName: string

    Table name

  Returns Promise<boolean>

  True if the policy exists

AbstractcommentTable

• commentTable(tableName: string, comment: string): Promise<void>

  Add comment to a table

  Parameters

  • tableName: string

    Table name

  • comment: string

    Comment text

  Returns Promise<void>

AbstractcommentColumn

• commentColumn(
      tableName: string,
      columnName: string,
      comment: string,
  ): Promise<void>

  Add comment to a column

  Parameters

  • tableName: string

    Table name

  • columnName: string

    Column name

  • comment: string

    Comment text

  Returns Promise<void>

AbstractcreatePartialIndex

• createPartialIndex(
      tableName: string,
      indexName: string,
      fields: string[],
      where: string,
      options?: IndexOptions,
  ): Promise<void>

  Create a partial index (index with WHERE clause)

  Parameters

  • tableName: string

    Table name

  • indexName: string

    Index name

  • fields: string[]

    Fields to index

  • where: string

    WHERE clause for partial index

  • Optionaloptions: IndexOptions

    Additional index options

  Returns Promise<void>

AbstractcreateExpressionIndex

• createExpressionIndex(
      tableName: string,
      indexName: string,
      expression: string,
      options?: IndexOptions,
  ): Promise<void>

  Create an expression index

  Parameters

  • tableName: string

    Table name

  • indexName: string

    Index name

  • expression: string

    Expression for the index

  • Optionaloptions: IndexOptions

    Additional index options

  Returns Promise<void>

AbstractcreateIdentityColumn

• createIdentityColumn(
      tableName: string,
      columnName: string,
      options?: {
          startWith?: number;
          incrementBy?: number;
          minvalue?: number;
          maxvalue?: number;
          cycle?: boolean;
      },
  ): Promise<void>

  Create an identity column

  Parameters

  • tableName: string

    Table name

  • columnName: string

    Column name

  • Optionaloptions: {
        startWith?: number;
        incrementBy?: number;
        minvalue?: number;
        maxvalue?: number;
        cycle?: boolean;
    }

    Identity options

  Returns Promise<void>

AbstractcreateComputedColumn

• createComputedColumn(
      tableName: string,
      columnName: string,
      expression: string,
      options?: { persisted?: boolean; type?: string },
  ): Promise<void>

  Create a computed column

  Parameters

  • tableName: string

    Table name

  • columnName: string

    Column name

  • expression: string

    Expression for computed column

  • Optionaloptions: { persisted?: boolean; type?: string }

    Computed column options

  Returns Promise<void>

AbstractaddColumn

• addColumn(
      tableName: string,
      columnName: string,
      definition: ColumnDefinition,
  ): Promise<void>

  Add a column to a table

  Parameters

  • tableName: string

    Name of the table

  • columnName: string

    Name of the new column

  • definition: ColumnDefinition

    Column definition

  Returns Promise<void>

AbstractremoveColumn

• removeColumn(tableName: string, columnName: string): Promise<void>

  Remove a column from a table

  Parameters

  • tableName: string

    Name of the table

  • columnName: string

    Name of the column to remove

  Returns Promise<void>

AbstractchangeColumn

• changeColumn(
      tableName: string,
      columnName: string,
      definition: ColumnDefinition,
  ): Promise<void>

  Change a column definition

  Parameters

  • tableName: string

    Name of the table

  • columnName: string

    Name of the column to change

  • definition: ColumnDefinition

    New column definition

  Returns Promise<void>

renameColumn

• renameColumn(
      _tableName: string,
      _oldColumnName: string,
      _newColumnName: string,
  ): Promise<void>

  Rename a column (default throws error)

  Parameters

  • _tableName: string
  • _oldColumnName: string
  • _newColumnName: string

  Returns Promise<void>

addForeignKey

• addForeignKey(
      _tableName: string,
      _columnName: string,
      _referencedTableName: string,
      _referencedColumnName: string,
      _options?: any,
  ): Promise<void>

  Add a foreign key (default throws error)

  Parameters

  • _tableName: string
  • _columnName: string
  • _referencedTableName: string
  • _referencedColumnName: string
  • Optional_options: any

  Returns Promise<void>

bulkInsert

• bulkInsert(
      tableName: string,
      records: Record<string, any>[],
      _options?: any,
  ): Promise<QueryResult>

  Bulk insert records (default implementation)

  Parameters

  • tableName: string
  • records: Record<string, any>[]
  • Optional_options: any

  Returns Promise<QueryResult>

AbstractshowTables

• showTables(): Promise<string[]>

  Show all tables in the database

  Returns Promise<string[]>

AbstractshowViews

• showViews(): Promise<string[]>

  Show all views in the database

  Returns Promise<string[]>

AbstractshowMaterializedViews

• showMaterializedViews(): Promise<string[]>

  Returns Promise<string[]>

AbstractshowConstraints

• showConstraints(tableName: string): Promise<any[]>

  Show constraints for a table

  Parameters

  • tableName: string

  Returns Promise<any[]>

AbstractaddConstraint

• addConstraint(
      tableName: string,
      options: {
          type: "UNIQUE" | "PRIMARY KEY" | "FOREIGN KEY" | "CHECK";
          fields: string[];
          name?: string;
          references?: { table: string; fields: string[] };
          check?: string;
      },
  ): Promise<void>

  Add a constraint to a table

  Parameters

  • tableName: string
  • options: {
        type: "UNIQUE" | "PRIMARY KEY" | "FOREIGN KEY" | "CHECK";
        fields: string[];
        name?: string;
        references?: { table: string; fields: string[] };
        check?: string;
    }

  Returns Promise<void>

AbstractremoveConstraint

• removeConstraint(tableName: string, constraintName: string): Promise<void>

  Remove a constraint from a table

  Parameters

  • tableName: string
  • constraintName: string

  Returns Promise<void>

AbstractshowIndexes

• showIndexes(tableName: string): Promise<any[]>

  Show indexes for a table

  Parameters

  • tableName: string

  Returns Promise<any[]>

AbstractdescribeTable

• describeTable(tableName: string): Promise<TableDescription>

  Describe a table (get column information)

  Parameters

  • tableName: string

    Name of the table

  Returns Promise<TableDescription>

AbstractrenameTable

• renameTable(oldName: string, newName: string): Promise<void>

  Rename a table

  Parameters

  • oldName: string

    Current table name

  • newName: string

    New table name

  Returns Promise<void>

AbstractaddIndex

• addIndex(
      tableName: string,
      indexName: string,
      fields: string[],
      options?: IndexOptions,
  ): Promise<void>

  Add an index to a table

  Parameters

  • tableName: string

    Name of the table

  • indexName: string

    Name of the index

  • fields: string[]

    Fields to index

  • Optionaloptions: IndexOptions

    Index options

  Returns Promise<void>

AbstractremoveIndex

• removeIndex(tableName: string, indexName: string): Promise<void>

  Remove an index from a table

  Parameters

  • tableName: string

    Name of the table

  • indexName: string

    Name of the index

  Returns Promise<void>

AbstractcreateIndex

• createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>

  Create an index on a table with full options support

  Parameters

  • tableName: string

    Name of the table

  • indexDef: IndexDefinition

    Index definition

  Returns Promise<void>

createFulltextIndex

• createFulltextIndex(
      _tableName: string,
      _indexName: string,
      _fields: string[],
      _options?: { parser?: string; comment?: string },
  ): Promise<void>

  Create a fulltext index (default throws error)

  Parameters

  • _tableName: string
  • _indexName: string
  • _fields: string[]
  • Optional_options: { parser?: string; comment?: string }

  Returns Promise<void>

createSpatialIndex

• createSpatialIndex(
      _tableName: string,
      _indexName: string,
      _fields: string[],
      _options?: { storage?: string; srid?: number },
  ): Promise<void>

  Create a spatial index (default throws error)

  Parameters

  • _tableName: string
  • _indexName: string
  • _fields: string[]
  • Optional_options: { storage?: string; srid?: number }

  Returns Promise<void>

AbstractdropIndex

• dropIndex(
      tableName: string,
      indexName: string,
      options?: DropIndexOptions,
  ): Promise<void>

  Drop an index from a table

  Parameters

  • tableName: string

    Name of the table

  • indexName: string

    Name of the index

  • Optionaloptions: DropIndexOptions

    Drop options

  Returns Promise<void>

AbstractcreateConstraint

• createConstraint(
      tableName: string,
      constraintDef: ConstraintDefinition,
  ): Promise<void>

  Create a constraint on a table

  Parameters

  • tableName: string

    Name of the table

  • constraintDef: ConstraintDefinition

    Constraint definition

  Returns Promise<void>

AbstractdropConstraint

• dropConstraint(
      tableName: string,
      constraintName: string,
      options?: DropConstraintOptions,
  ): Promise<void>

  Drop a constraint from a table

  Parameters

  • tableName: string

    Name of the table

  • constraintName: string

    Name of the constraint

  • Optionaloptions: DropConstraintOptions

    Drop options

  Returns Promise<void>

AbstractchangeOwner

• changeOwner(newOwner: string, tableName: string): Promise<void>

  Change owner of a table or view

  Parameters

  • newOwner: string
  • tableName: string

  Returns Promise<void>

AbstractcreateForeignDataWrapper

• createForeignDataWrapper(
      fdwName: string,
      options?: { handler?: string },
  ): Promise<void>

  Create a foreign data wrapper (PostgreSQL)

  Parameters

  • fdwName: string
  • Optionaloptions: { handler?: string }

  Returns Promise<void>

AbstractdropForeignDataWrapper

• dropForeignDataWrapper(
      fdwName: string,
      options?: { ifExists?: boolean },
  ): Promise<void>

  Drop a foreign data wrapper (PostgreSQL)

  Parameters

  • fdwName: string
  • Optionaloptions: { ifExists?: boolean }

  Returns Promise<void>

AbstractcreateForeignServer

• createForeignServer(
      serverName: string,
      fdwName: string,
      options?: { options?: Record<string, string>; ifNotExists?: boolean },
  ): Promise<void>

  Create a foreign server (PostgreSQL)

  Parameters

  • serverName: string
  • fdwName: string
  • Optionaloptions: { options?: Record<string, string>; ifNotExists?: boolean }

  Returns Promise<void>

AbstractdropForeignServer

• dropForeignServer(
      serverName: string,
      options?: { ifExists?: boolean; cascade?: boolean },
  ): Promise<void>

  Drop a foreign server (PostgreSQL)

  Parameters

  • serverName: string
  • Optionaloptions: { ifExists?: boolean; cascade?: boolean }

  Returns Promise<void>

AbstractcreateForeignTable

• createForeignTable(
      tableName: string,
      columns: Record<string, { type: string }>,
      options?: { serverName?: string; ifNotExists?: boolean },
  ): Promise<void>

  Create a foreign table (PostgreSQL)

  Parameters

  • tableName: string
  • columns: Record<string, { type: string }>
  • Optionaloptions: { serverName?: string; ifNotExists?: boolean }

  Returns Promise<void>

AbstractcreateSecurityPolicy

• createSecurityPolicy(
      policyName: string,
      tableName: string,
      options?: { predicate?: string },
  ): Promise<void>

  Create a security policy (MSSQL Row-Level Security)

  Parameters

  • policyName: string
  • tableName: string
  • Optionaloptions: { predicate?: string }

  Returns Promise<void>

AbstractdropSecurityPolicy

• dropSecurityPolicy(policyName: string, tableName: string): Promise<void>

  Drop a security policy (MSSQL Row-Level Security)

  Parameters

  • policyName: string
  • tableName: string

  Returns Promise<void>

AbstractstartTransaction

• startTransaction(options?: TransactionOptions): Promise<Transaction>

  Begin a new transaction

  Parameters

  • Optionaloptions: TransactionOptions

    Transaction options

  Returns Promise<Transaction>

AbstractcommitTransaction

• commitTransaction(transaction: Transaction): Promise<void>

  Commit a transaction

  Parameters

  • transaction: Transaction

    The transaction to commit

  Returns Promise<void>

AbstractrollbackTransaction

• rollbackTransaction(transaction: Transaction): Promise<void>

  Rollback a transaction

  Parameters

  • transaction: Transaction

    The transaction to rollback

  Returns Promise<void>

AbstractgetDataTypeSql

• getDataTypeSql(dataType: DataType): string

  Get the SQL for a data type

  Parameters

  • dataType: DataType

    The data type

  Returns string

AbstractbuildWhereClause

• buildWhereClause(
      where: WhereOptions,
      options?: BuildOptions,
  ): { sql: string; values: any[] }

  Build a WHERE clause from a WhereOptions object

  Parameters

  • where: WhereOptions

    The where options

  • Optionaloptions: BuildOptions

    Build options

  Returns { sql: string; values: any[] }

AbstractbuildOrderClause

• buildOrderClause(order: Order, options?: BuildOptions): string

  Build an ORDER BY clause

  Parameters

  • order: Order

    The order options

  • Optionaloptions: BuildOptions

    Build options

  Returns string

AbstractbuildLimitOffset

• buildLimitOffset(limit?: string | number, offset?: string | number): string

  Build a LIMIT/OFFSET clause

  Parameters

  • Optionallimit: string | number

    Limit value

  • Optionaloffset: string | number

    Offset value

  Returns string

AbstractbuildInsertQuery

• buildInsertQuery(
      tableName: string,
      values: Record<string, any>,
      options?: InsertOptions,
  ): { sql: string; values: any[] }

  Build an INSERT query

  Parameters

  • tableName: string

    Table name

  • values: Record<string, any>

    Values to insert

  • Optionaloptions: InsertOptions

    Query options

  Returns { sql: string; values: any[] }

AbstractbuildUpdateQuery

• buildUpdateQuery(
      tableName: string,
      values: Record<string, any>,
      where: WhereOptions,
      options?: UpdateOptions,
  ): { sql: string; values: any[] }

  Build an UPDATE query

  Parameters

  • tableName: string

    Table name

  • values: Record<string, any>

    Values to update

  • where: WhereOptions

    Where clause

  • Optionaloptions: UpdateOptions

    Query options

  Returns { sql: string; values: any[] }

AbstractbuildDeleteQuery

• buildDeleteQuery(
      tableName: string,
      where: WhereOptions,
      options?: DeleteOptions,
  ): { sql: string; values: any[] }

  Build a DELETE query

  Parameters

  • tableName: string

    Table name

  • where: WhereOptions

    Where clause

  • Optionaloptions: DeleteOptions

    Query options

  Returns { sql: string; values: any[] }

AbstractbuildSelectQuery

• buildSelectQuery(options: SelectOptions): { sql: string; values: any[] }

  Build a SELECT query

  Parameters

  • options: SelectOptions

    Select options

  Returns { sql: string; values: any[] }

AbstractcreateSchema

• createSchema(schema: string): Promise<void>

  Create a schema

  Parameters

  • schema: string

    The schema name to create

  Returns Promise<void>

AbstractdropSchema

• dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>

  Drop a schema

  Parameters

  • schema: string

    The schema name to drop

  • Optionaloptions: DropSchemaOptions

    Drop options

  Returns Promise<void>

AbstractshowAllSchemas

• showAllSchemas(): Promise<string[]>

  Show all schemas in the database

  Returns Promise<string[]>

listSchemas

• listSchemas(): Promise<string[]>

  List all schemas in the database

  Returns Promise<string[]>

createDatabaseSQL

• createDatabaseSQL(
      options: {
          name: string;
          encoding?: string;
          lcCollate?: string;
          lcCtype?: string;
          template?: string;
          tablespace?: string;
          collate?: string;
          isTemplate?: boolean;
      },
  ): string

  Generate SQL for creating a database (default implementation)

  Parameters

  • options: {
        name: string;
        encoding?: string;
        lcCollate?: string;
        lcCtype?: string;
        template?: string;
        tablespace?: string;
        collate?: string;
        isTemplate?: boolean;
    }

    Database creation options

  Returns string

dropDatabaseSQL

• dropDatabaseSQL(name: string): string

  Generate SQL for dropping a database

  Parameters

  • name: string

    Database name to drop

  Returns string

createSavepointSQL

• createSavepointSQL(name?: string): string

  Generate SQL for creating a savepoint

  Parameters

  • Optionalname: string

    Savepoint name (optional, will be generated if not provided)

  Returns string

releaseSavepointSQL

• releaseSavepointSQL(name: string): string

  Generate SQL for releasing a savepoint

  Parameters

  • name: string

    Savepoint name to release

  Returns string

rollbackToSavepointSQL

• rollbackToSavepointSQL(name: string): string

  Generate SQL for rolling back to a savepoint

  Parameters

  • name: string

    Savepoint name to rollback to

  Returns string

createExtension

• createExtension(
      _extensionName: string,
      _options?: CreateExtensionOptions,
  ): Promise<void>

  Create a PostgreSQL extension (only supported in PostgreSQL)

  Parameters

  • _extensionName: string
  • Optional_options: CreateExtensionOptions

  Returns Promise<void>

dropExtension

• dropExtension(
      _extensionName: string,
      _options?: DropExtensionOptions,
  ): Promise<void>

  Drop a PostgreSQL extension (only supported in PostgreSQL)

  Parameters

  • _extensionName: string
  • Optional_options: DropExtensionOptions

  Returns Promise<void>

getExtensions

• getExtensions(): Promise<ExtensionInfo[]>

  Get all installed PostgreSQL extensions (only supported in PostgreSQL)

  Returns Promise<ExtensionInfo[]>

  Array of extension information

hasExtension

• hasExtension(_extensionName: string): Promise<boolean>

  Check if a PostgreSQL extension is installed (only supported in PostgreSQL)

  Parameters

  • _extensionName: string

  Returns Promise<boolean>

  True if the extension is installed

createEnumType

• createEnumType(
      _name: string,
      _values: string[],
      _options?: CreateEnumTypeOptions,
  ): Promise<void>

  Create a PostgreSQL enum type (only supported in PostgreSQL)

  Parameters

  • _name: string
  • _values: string[]
  • Optional_options: CreateEnumTypeOptions

  Returns Promise<void>

dropType

• dropType(_name: string, _options?: DropTypeOptions): Promise<void>

  Drop a PostgreSQL type (only supported in PostgreSQL)

  Parameters

  • _name: string
  • Optional_options: DropTypeOptions

  Returns Promise<void>

createDomain

• createDomain(
      _name: string,
      _baseType: string,
      _options?: CreateDomainOptions,
  ): Promise<void>

  Create a PostgreSQL domain (only supported in PostgreSQL)

  Parameters

  • _name: string
  • _baseType: string
  • Optional_options: CreateDomainOptions

  Returns Promise<void>

dropDomain

• dropDomain(_name: string, _options?: DropDomainOptions): Promise<void>

  Drop a PostgreSQL domain (only supported in PostgreSQL)

  Parameters

  • _name: string
  • Optional_options: DropDomainOptions

  Returns Promise<void>

buildCreateServerQuery

• buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string

  Parameters

  • _name: string
  • _opts: FdwForeignServerOptions

  Returns string

buildAlterServerQuery

• buildAlterServerQuery(
      _name: string,
      _opts: FdwAlterForeignServerOptions,
  ): string

  Parameters

  • _name: string
  • _opts: FdwAlterForeignServerOptions

  Returns string

buildDropServerQuery

• buildDropServerQuery(
      _name: string,
      _opts?: { ifExists?: boolean; cascade?: boolean },
  ): string

  Parameters

  • _name: string
  • Optional_opts: { ifExists?: boolean; cascade?: boolean }

  Returns string

buildCreateUserMappingQuery

• buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string

  Parameters

  • _opts: FdwUserMappingOptions

  Returns string

buildAlterUserMappingQuery

• buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string

  Parameters

  • _opts: FdwUserMappingOptions

  Returns string

buildDropUserMappingQuery

• buildDropUserMappingQuery(
      _serverName: string,
      _user: string,
      _opts?: { ifExists?: boolean },
  ): string

  Parameters

  • _serverName: string
  • _user: string
  • Optional_opts: { ifExists?: boolean }

  Returns string

createUserMapping

• createUserMapping(
      _userName: string,
      _serverName: string,
      _options?: any,
  ): Promise<void>

  Create a user mapping (default throws error)

  Parameters

  • _userName: string
  • _serverName: string
  • Optional_options: any

  Returns Promise<void>

dropUserMapping

• dropUserMapping(
      _userName: string,
      _serverName: string,
      _options?: any,
  ): Promise<void>

  Drop a user mapping (default throws error)

  Parameters

  • _userName: string
  • _serverName: string
  • Optional_options: any

  Returns Promise<void>

buildCreateForeignTableQuery

• buildCreateForeignTableQuery(
      _tableName: string,
      _opts: FdwForeignTableOptions,
  ): string

  Parameters

  • _tableName: string
  • _opts: FdwForeignTableOptions

  Returns string

buildDropForeignTableQuery

• buildDropForeignTableQuery(
      _tableName: string,
      _opts?: { ifExists?: boolean; cascade?: boolean },
  ): string

  Parameters

  • _tableName: string
  • Optional_opts: { ifExists?: boolean; cascade?: boolean }

  Returns string

buildImportForeignSchemaQuery

• buildImportForeignSchemaQuery(
      _remoteSchema: string,
      _serverName: string,
      _opts?: FdwImportForeignSchemaOptions,
  ): string

  Parameters

  • _remoteSchema: string
  • _serverName: string
  • Optional_opts: FdwImportForeignSchemaOptions

  Returns string

getServersQuery

• getServersQuery(): string

  Returns string

buildCreateUserQuery

• buildCreateUserQuery(_username: string, _options?: any): string

  Parameters

  • _username: string
  • Optional_options: any

  Returns string

buildAlterUserQuery

• buildAlterUserQuery(_username: string, _options: any): string

  Parameters

  • _username: string
  • _options: any

  Returns string

buildDropUserQuery

• buildDropUserQuery(_username: string, _options?: any): string

  Parameters

  • _username: string
  • Optional_options: any

  Returns string

getUsersQuery

• getUsersQuery(): string

  Returns string

buildGrantQuery

• buildGrantQuery(_options: any): string

  Parameters

  • _options: any

  Returns string

buildRevokeQuery

• buildRevokeQuery(_options: any): string

  Parameters

  • _options: any

  Returns string

buildShowGrantsQuery