Dialects

interface Dialect {
  /**
   * Creates a driver for the dialect.
   */
  createDriver(): Driver

  /**
   * Creates a query compiler for the dialect.
   */
  createQueryCompiler(): QueryCompiler

  /**
   * Creates an adapter for the dialect.
   */
  createAdapter(): DialectAdapter

  /**
   * Creates a database introspector that can be used to get database metadata
   * such as the table names and column names of those tables.
   */
  createIntrospector(db: Kysely<any>): DatabaseIntrospector
}

npm install pg
npm install --save-dev @types/pg

import { Kysely, PostgresDialect } from 'kysely'
import { Pool } from 'pg'

interface Database {
  person: {
    id: Generated<number>
    first_name: string
    last_name: string
  }
}

const db = new Kysely<Database>({
  dialect: new PostgresDialect({
    pool: new Pool({
      database: 'postgres',
      host: 'localhost',
      user: 'postgres',
      port: 5432,
      max: 10,
    })
  })
})

import { Pool } from 'pg'

const db = new Kysely<Database>({
  dialect: new PostgresDialect({
    pool: async () => new Pool({
      database: 'postgres',
      host: 'localhost',
      user: 'postgres',
    })
  })
})

const person = await db
  .insertInto('person')
  .values({ first_name: 'Jennifer', last_name: 'Aniston' })
  .returningAll()
  .executeTakeFirst()

await db
  .selectFrom('person')
  .select((eb) => [
    eb.fn('json_agg', ['person.id']).as('ids')
  ])
  .execute()

npm install mysql2

import { Kysely, MysqlDialect } from 'kysely'
import { createPool } from 'mysql2'

const db = new Kysely<Database>({
  dialect: new MysqlDialect({
    pool: createPool({
      database: 'test',
      host: 'localhost',
      user: 'root',
      port: 3306,
      connectionLimit: 10,
    })
  })
})

import { createPool } from 'mysql2'

const db = new Kysely<Database>({
  dialect: new MysqlDialect({
    pool: async () => createPool({
      database: 'test',
      host: 'localhost',
    })
  })
})

await db
  .selectFrom('person')
  .selectAll()
  .limit(10)
  .offset(20)
  .execute()

npm install better-sqlite3
npm install --save-dev @types/better-sqlite3

import { Kysely, SqliteDialect } from 'kysely'
import Database from 'better-sqlite3'

const db = new Kysely<Database>({
  dialect: new SqliteDialect({
    database: new Database('database.db')
  })
})

const db = new Kysely<Database>({
  dialect: new SqliteDialect({
    database: new Database(':memory:')
  })
})

import Database from 'better-sqlite3'

const db = new Kysely<Database>({
  dialect: new SqliteDialect({
    database: async () => new Database('database.db')
  })
})

interface PersonTable {
  id: Generated<number>  // SQLite's INTEGER PRIMARY KEY AUTOINCREMENT
  name: string
}

const inserted = await db
  .insertInto('person')
  .values({ name: 'Jennifer' })
  .returningAll()
  .executeTakeFirst()

npm install tedious
npm install tarn

import { Kysely, MssqlDialect } from 'kysely'
import * as Tedious from 'tedious'
import * as Tarn from 'tarn'

const db = new Kysely<Database>({
  dialect: new MssqlDialect({
    tarn: {
      ...Tarn,
      options: {
        min: 0,
        max: 10,
      },
    },
    tedious: {
      ...Tedious,
      connectionFactory: () => new Tedious.Connection({
        authentication: {
          options: {
            password: 'password',
            userName: 'sa',
          },
          type: 'default',
        },
        options: {
          database: 'master',
          port: 1433,
          trustServerCertificate: true,
        },
        server: 'localhost',
      }),
    },
  })
})

await db
  .selectFrom('person')
  .selectAll()
  .top(10)
  .execute()

const inserted = await db
  .insertInto('person')
  .output(['inserted.id', 'inserted.first_name'])
  .values({ first_name: 'Jennifer', last_name: 'Aniston' })
  .execute()

import { Pool } from 'pg'

const pool = new Pool({
  max: 10,                // Maximum pool size
  idleTimeoutMillis: 30000, // Close idle clients after 30s
  connectionTimeoutMillis: 2000, // Return error after 2s if can't connect
})

import { createPool } from 'mysql2'

const pool = createPool({
  connectionLimit: 10,
  queueLimit: 0,
  waitForConnections: true,
})

// No connection pooling - synchronous, single-connection
import Database from 'better-sqlite3'

const database = new Database('db.sqlite', {
  readonly: false,
  fileMustExist: false,
})

import * as Tarn from 'tarn'

const tarnConfig = {
  ...Tarn,
  options: {
    min: 2,
    max: 10,
    acquireTimeoutMillis: 30000,
    createTimeoutMillis: 30000,
    idleTimeoutMillis: 30000,
  },
}

import {
  Dialect,
  Driver,
  QueryCompiler,
  DialectAdapter,
  DatabaseIntrospector,
  Kysely
} from 'kysely'

class CustomDialect implements Dialect {
  createDriver(): Driver {
    // Return your custom driver
  }

  createQueryCompiler(): QueryCompiler {
    // Return your custom query compiler
  }

  createAdapter(): DialectAdapter {
    // Return your custom adapter
  }

  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
    // Return your custom introspector
  }
}