Some notes that may help:

So basically you need to implement the four interfaces returned by the different methods of the Dialect interface:

export class SqliteDialect implements Dialect {
  readonly #config: SqliteDialectConfig

  constructor(config: SqliteDialectConfig) {
    this.#config = config
  }

  createDriver(): Driver {
    return new SqliteDriver(this.#config)
  }

  createQueryCompiler(): QueryCompiler {
    return new SqliteQueryCompiler()
  }

  createAdapter(): DialectAdapter {
    return new SqliteAdapter()
  }

  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
    return new SqliteIntrospector(db)
  }
}

// This interface needs to be a copy-paste of the sqlite driver config.
// We can't use and export the actual type from sqlite types because
// then all Kysely users would need to install sqlite types even if they
// use some other dialect.
export interface SqliteDialectConfig {

}

The interfaces are Driver, QueryCompiler, DialectAdapter and DatabaseIntrospector.

DialectAdapter

This one is easy on sqlite:

export class SqliteAdapter implements DialectAdapter {
  get supportsTransactionalDdl(): boolean {
    return true
  }

  get supportsReturning(): boolean {
    return false
  }

  async acquireMigrationLock(db: Kysely<any>): Promise<void> {
    // Nothing to do here.
  }

  async releaseMigrationLock(db: Kysely<any>): Promise<void> {
    // Nothing to do here.
  }
}

QueryCompiler

It's easy to get a basic version going by doing something like this:

export class SqliteQueryCompiler extends DefaultQueryCompiler {
  protected override visitColumnDefinition(node: ColumnDefinitionNode): void {
    this.visitNode(node.column)
    this.append(' ')
    this.visitNode(node.dataType)

    if (node.defaultTo) {
      this.append(' default ')
      this.visitNode(node.defaultTo)
    }

    if (!node.isNullable) {
      this.append(' not null')
    }

    if (node.isAutoIncrementing) {
      this.append(' autoincrement')
    }

    if (node.isUnique) {
      this.append(' unique')
    }

    if (node.isPrimaryKey) {
      this.append(' primary key')
    }

    if (node.references) {
      this.append(' ')
      this.visitNode(node.references)
    }

    if (node.check) {
      this.append(' ')
      this.visitNode(node.check)
    }
  }

  protected override visitReturning(): void {
    // Do nothing.
  }

  protected override getCurrentParameterPlaceholder() {
    return '?'
  }
}

Then there are probably some other stuff you need to add to the query compiler, bu the above should get you started.

Driver

The driver is the actual glue between Kysely and the better-sqlite3 library. Sqlite essentially has one single connection so you'll need to implement some sort of a "mutex" to only allow one connection to be acquired at a time. You can copy paste the mechanism from here if you want.

export class SqliteDriver implements Driver {
  init(): Promise<void> {
    // Here you should import and initialize the better-sqlite3 library.
    // See how it's done in the other drivers.
  }

  acquireConnection(): Promise<DatabaseConnection> {
    // This should only ever allow one connection to be acquired! Once
    // a connection is acquired, all calls to this method should await for the
    // single connection to be released and then the next one in the queue
    // gets the connection. This is because Sqlite basically has one single
    // connection (actually it doesn't have the concept of connections at all). 
  } 

  beginTransaction(
    connection: DatabaseConnection,
    settings: TransactionSettings
  ): Promise<void> {
    // This you can copy paste from postgres.
  }

  commitTransaction(connection: DatabaseConnection): Promise<void> {
    // This you can copy paste from postgres.
  }

  rollbackTransaction(connection: DatabaseConnection): Promise<void> {
    // This you can copy paste from postgres.
  }

  releaseConnection(connection: DatabaseConnection): Promise<void> {
    // See acquireConnection
  }

  destroy(): Promise<void> {
    // Destroy and release everything.
  }
}

DatabaseIntrospector

This one should probably use this and to get the columns, something like PRAGMA table_info('table_name').

SQLite #19

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.