effect-qb 0.12.3 → 0.14.0

package/src/internal/table.ts

@@ -2,14 +2,18 @@ import { pipeArguments, type Pipeable } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
 import * as Plan from "./plan.js"
+import type { Any as AnyExpression } from "./expression.js"
+import type { TrueFormula } from "./predicate-formula.js"
 import type { BoundColumnFrom } from "./column-state.js"
 import { bindColumn, type AnyColumnDefinition } from "./column-state.js"
 import {
   collectInlineOptions,
   normalizeColumnList,
   resolvePrimaryKeyColumns,
-  type DeclaredTableOptions as InternalDeclaredTableOptions,
+  type DdlExpressionLike,
+  type IndexKeySpec,
   type NormalizeColumns,
+  type ReferentialAction,
   type TableOptionSpec,
   type ValidateKnownColumns,
   type ValidatePrimaryKeyColumns,
@@ -41,7 +45,16 @@ type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof im
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
 type ClassOptionSpec = Exclude<TableOptionSpec, { readonly kind: "primaryKey" }>
-type ClassTableOption = TableOption<ClassOptionSpec>
+interface TableOptionBuilderLike<
+  Spec extends TableOptionSpec = TableOptionSpec
+> {
+  (
+    table: TableDefinition<any, any, any, "schema", any>
+  ): TableDefinition<any, any, any, "schema", any>
+  readonly option: Spec
+}
+
+type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>
 type ClassDeclaredTableOptions = readonly ClassTableOption[]
 
 type BuildPrimaryKey<
@@ -82,12 +95,13 @@ export type BoundColumns<
 
 /** Derived runtime schemas exposed by a table definition. */
 export interface TableSchemas<
+  Name extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 > {
-  readonly select: Schema.Schema<SelectRow<Fields>>
-  readonly insert: Schema.Schema<InsertRow<Fields>>
-  readonly update: Schema.Schema<UpdateRow<Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Schema<SelectRow<Name, Fields>>
+  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
+  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
 }
 
 interface TableState<
@@ -115,11 +129,12 @@ export interface TableSchemaNamespace<SchemaName extends string> {
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
 }
 
-export type DeclaredTableOptions = InternalDeclaredTableOptions
+export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
+export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js"
 
 export type TableDefinition<
   Name extends string,
@@ -130,12 +145,12 @@ export type TableDefinition<
 > = Pipeable & {
   readonly name: Name
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
@@ -143,7 +158,7 @@ export type TableDefinition<
 } & BoundColumns<Name, Fields> & Plan.Plan<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -160,12 +175,12 @@ export type TableClassStatic<
   SchemaName extends string | undefined = DefaultSchemaName
 > = (abstract new (...args: any[]) => any) & Pipeable & {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
@@ -175,7 +190,7 @@ export type TableClassStatic<
 } & BoundColumns<Name, Fields> & Plan.Plan<
     BoundColumns<Name, Fields>,
     never,
-    Record<Name, Plan.Source<Name>>,
+    Record<Name, Plan.Source<Name, "required", TrueFormula>>,
     TableDialect<Fields>
   >
 
@@ -208,7 +223,7 @@ type BuildArtifacts<
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
 }
@@ -230,7 +245,7 @@ const buildArtifacts = <
   const columns = Object.fromEntries(
     Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
   ) as BoundColumns<Name, Fields>
-  const schemas = deriveSchemas(fields, primaryKey)
+  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
     schemas,
@@ -298,6 +313,21 @@ const extractDeclaredOptions = (
   declaredOptions: DeclaredTableOptions | undefined
 ): readonly TableOptionSpec[] => declaredOptions?.map((option) => option.option) ?? []
 
+const applyDeclaredOptions = <
+  Table extends TableDefinition<any, any, any, "schema", any>
+>(
+  table: Table,
+  declaredOptions: DeclaredTableOptions | undefined
+): Table => {
+  if (declaredOptions === undefined || declaredOptions.length === 0) {
+    return table
+  }
+  return declaredOptions.reduce<TableDefinition<any, any, any, "schema", any>>(
+    (current, option) => option(current),
+    table
+  ) as unknown as Table
+}
+
 const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void => {
   for (const option of declaredOptions) {
     if (option.kind === "primaryKey") {
@@ -339,14 +369,26 @@ const ensureClassArtifacts = <
     return cached
   }
   const state = self[TypeId]
-  const declaredOptions = extractDeclaredOptions(self[options])
-  validateClassOptions(declaredOptions)
-  const artifacts = buildArtifacts(
-    state.name,
-    state.fields,
-    declaredOptions,
-    state.schemaName
-  ) as BuildArtifacts<Name, Fields, PrimaryKeyColumns>
+  const classOptions = self[options]
+  validateClassOptions(extractDeclaredOptions(classOptions))
+  const table = applyDeclaredOptions(
+    makeTable(
+      state.name,
+      state.fields,
+      [],
+      state.name,
+      "schema",
+      state.schemaName,
+      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"
+    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", typeof state.schemaName>,
+    classOptions
+  )
+  const artifacts = {
+    columns: table.columns,
+    schemas: table.schemas,
+    normalizedOptions: table[OptionsSymbol],
+    primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
+  } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
     value: artifacts
@@ -383,6 +425,25 @@ const makeOption = <Spec extends TableOptionSpec>(option: Spec): TableOption<Spe
   return builder
 }
 
+const makeResolvedOption = <Spec extends TableOptionSpec>(
+  option: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> => {
+  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
+    appendOption(table, resolve(table))) as unknown as TableOption<Spec>
+  ;(builder as { option: Spec }).option = option
+  return builder
+}
+
+export const option = <Spec extends TableOptionSpec>(spec: Spec): TableOption<Spec> =>
+  makeOption(spec)
+
+export const optionFromTable = <Spec extends TableOptionSpec>(
+  spec: Spec,
+  resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+): TableOption<Spec> =>
+  makeResolvedOption(spec, resolve)
+
 /** Creates a table definition from a name and field map. */
 export function make<
   Name extends string,
@@ -421,17 +482,20 @@ export const schema = <SchemaName extends string>(
   >(
     name: Name,
     fields: Fields,
-    ...options: InternalDeclaredTableOptions
+    ...options: DeclaredTableOptions
   ): TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName> =>
-    makeTable(
-      name,
-      fields,
-      extractDeclaredOptions(options),
-      name,
-      "schema",
-      schemaName,
-      "explicit"
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    applyDeclaredOptions(
+      makeTable(
+        name,
+        fields,
+        [],
+        name,
+        "schema",
+        schemaName,
+        "explicit"
+      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+      options
+    )
 })
 
 /**
@@ -464,7 +528,7 @@ export const alias = <
   const aliased = Object.create(TableProto)
   aliased.name = aliasName
   aliased.columns = columns
-  aliased.schemas = table.schemas
+  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
   aliased[TypeId] = {
     name: aliasName,
     baseName: state.baseName,
@@ -580,7 +644,7 @@ export function Class<
 
 /** Declares a table-level primary key. */
 export const primaryKey = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -593,7 +657,7 @@ export const primaryKey = <
 
 /** Declares a table-level unique constraint. */
 export const unique = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -606,7 +670,7 @@ export const unique = <
 
 /** Declares a table-level index. */
 export const index = <
-  Columns extends string | readonly string[]
+  const Columns extends string | readonly string[]
 >(
   columns: Columns
 ): TableOption<{
@@ -619,9 +683,9 @@ export const index = <
 
 /** Declares a table-level foreign key. */
 export const foreignKey = <
-  LocalColumns extends string | readonly string[],
+  const LocalColumns extends string | readonly string[],
   TargetTable extends AnyTable,
-  TargetColumns extends string | readonly string[]
+  const TargetColumns extends string | readonly string[]
 >(
   columns: LocalColumns,
   target: () => TargetTable,
@@ -646,14 +710,14 @@ export const foreignKey = <
   })
 })
 
-/** Declares a metadata-only check constraint placeholder. */
+/** Declares a check constraint expression. */
 export const check = <Name extends string>(
   name: Name,
-  predicate: unknown
+  predicate: DdlExpressionLike
 ): TableOption<{
   readonly kind: "check"
   readonly name: Name
-  readonly predicate: unknown
+  readonly predicate: DdlExpressionLike
 }> => makeOption({
   kind: "check",
   name,

package/src/mysql/column.ts

@@ -19,12 +19,14 @@ export const json = BaseColumn.mysql.json
 export const custom = BaseColumn.mysql.custom
 
 export const nullable = BaseColumn.nullable
+export const brand = BaseColumn.brand
 export const primaryKey = BaseColumn.primaryKey
 export const unique = BaseColumn.unique
-export const hasDefault = BaseColumn.hasDefault
+const default_ = BaseColumn.default_
 export const generated = BaseColumn.generated
 export const references = BaseColumn.references
 export const schema = BaseColumn.schema
+export { default_ as default }
 
 export type Any = BaseColumn.Any
 export type AnyBound = BaseColumn.AnyBound

package/src/mysql/datatypes/index.ts

@@ -1,6 +1,21 @@
-import { makeDatatypeModule } from "../../internal/datatypes/define.js"
+import type { DatatypeModule } from "../../internal/datatypes/define.js"
+import type * as Expression from "../../internal/expression.js"
 import { mysqlDatatypeKinds } from "./spec.js"
 
-export const mysqlDatatypes = makeDatatypeModule("mysql", mysqlDatatypeKinds)
+const mysqlDatatypeModule = {
+  custom: (kind: string) => ({
+    dialect: "mysql",
+    kind
+  })
+} as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"mysql", string>>
+
+for (const kind of Object.keys(mysqlDatatypeKinds)) {
+  mysqlDatatypeModule[kind] = () => ({
+    dialect: "mysql",
+    kind
+  })
+}
+
+export const mysqlDatatypes = mysqlDatatypeModule as DatatypeModule<"mysql", typeof mysqlDatatypeKinds>
 
 export type MysqlDatatypeModule = typeof mysqlDatatypes

package/src/mysql/executor.ts

@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
 import * as SqlClient from "@effect/sql/SqlClient"
 
 import * as CoreExecutor from "../internal/executor.js"
-import * as Query from "./query.js"
-import * as Renderer from "./renderer.js"
+import * as CoreQuery from "../internal/query.js"
+import * as CoreRenderer from "../internal/renderer.js"
+import { renderMysqlPlan } from "../internal/mysql-renderer.js"
 import {
   narrowMysqlDriverErrorForReadQuery,
   normalizeMysqlDriverError,
@@ -19,17 +20,19 @@ export type RowDecodeError = CoreExecutor.RowDecodeError
 export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"mysql", Error, Context>
 /** MySQL-specialized executor contract. */
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"mysql", Error, Context>
+/** MySQL-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"mysql">
 /** Optional renderer / driver overrides for the standard MySQL executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
-  readonly renderer?: Renderer.Renderer
+  readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
 }
 /** Standard composed error shape for MySQL executors. */
 export type MysqlExecutorError = MysqlDriverError | RowDecodeError
 /** Read-query error surface emitted by built-in MySQL executors. */
-export type MysqlQueryError<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
-  Exclude<Query.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? MysqlReadQueryError : MysqlExecutorError
+export type MysqlQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? MysqlReadQueryError : MysqlExecutorError
 
 /** Runs an effect within the ambient MySQL SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
@@ -39,9 +42,9 @@ export const withSavepoint = CoreExecutor.withSavepoint
 /** MySQL executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
   readonly dialect: "mysql"
-  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
-  ): Effect.Effect<Query.ResultRows<PlanValue>, MysqlQueryError<PlanValue>, Context>
+  execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
+  ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, MysqlQueryError<PlanValue>, Context>
 }
 
 /** Constructs a MySQL-specialized SQL driver. */
@@ -50,7 +53,7 @@ export const driver = <
   Context = never
 >(
   execute: <Row>(
-    query: Renderer.RenderedQuery<Row>
+    query: CoreRenderer.RenderedQuery<Row, "mysql">
   ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
 ): Driver<Error, Context> =>
   CoreExecutor.driver("mysql", execute)
@@ -59,7 +62,7 @@ const fromDriver = <
   Error = never,
   Context = never
 >(
-  renderer: Renderer.Renderer,
+  renderer: Renderer,
   sqlDriver: Driver<Error, Context>,
   driverMode: CoreExecutor.DriverMode = "raw"
 ): QueryExecutor<Context> => ({
@@ -102,13 +105,13 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
 export function make(): QueryExecutor<SqlClient.SqlClient>
 export function make(
   options: {
-    readonly renderer?: Renderer.Renderer
+    readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
   options: {
-    readonly renderer?: Renderer.Renderer
+    readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
   }
@@ -117,9 +120,9 @@ export function make<Error = never, Context = never>(
   options: MakeOptions<Error, Context> = {}
 ): QueryExecutor<any> {
   if (options.driver) {
-    return fromDriver(options.renderer ?? Renderer.make(), options.driver, options.driverMode)
+    return fromDriver(options.renderer ?? CoreRenderer.make("mysql", renderMysqlPlan), options.driver, options.driverMode)
   }
-  return fromDriver(options.renderer ?? Renderer.make(), sqlClientDriver(), options.driverMode)
+  return fromDriver(options.renderer ?? CoreRenderer.make("mysql", renderMysqlPlan), sqlClientDriver(), options.driverMode)
 }
 
 /** Creates a MySQL-specialized executor from a typed implementation callback. */
@@ -127,8 +130,8 @@ export const custom = <
   Error = never,
   Context = never
 >(
-  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
-  ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+  execute: <PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
+  ) => Effect.Effect<CoreQuery.ResultRows<PlanValue>, Error, Context>
 ): Executor<Error, Context> =>
   CoreExecutor.make("mysql", execute as any) as Executor<Error, Context>

package/src/mysql/function/aggregate.ts

@@ -0,0 +1,6 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL aggregate functions. */
+export const count = mysqlQuery.count
+export const max = mysqlQuery.max
+export const min = mysqlQuery.min

package/src/mysql/function/core.ts

@@ -0,0 +1,5 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL scalar core functions. */
+export const coalesce = mysqlQuery.coalesce
+export const call = mysqlQuery.call

package/src/mysql/function/index.ts

@@ -0,0 +1,20 @@
+export * as core from "./core.js"
+export * as string from "./string.js"
+export * as aggregate from "./aggregate.js"
+export * as window from "./window.js"
+export { json } from "./json.js"
+export * as temporal from "./temporal.js"
+
+export { coalesce } from "./core.js"
+export { call } from "./core.js"
+export { lower, upper, concat } from "./string.js"
+export { count, max, min } from "./aggregate.js"
+export { over, rowNumber, rank, denseRank } from "./window.js"
+export {
+  currentDate,
+  currentTime,
+  currentTimestamp,
+  localTime,
+  localTimestamp,
+  now
+} from "./temporal.js"

package/src/mysql/function/json.ts

@@ -0,0 +1,4 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL JSON expression helpers. */
+export const json = mysqlQuery.json

package/src/mysql/function/string.ts

@@ -0,0 +1,6 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL string functions. */
+export const lower = mysqlQuery.lower
+export const upper = mysqlQuery.upper
+export const concat = mysqlQuery.concat

package/src/mysql/function/temporal.ts

@@ -0,0 +1,103 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/expression.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import {
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../../internal/runtime-value.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Expression<
+  Runtime,
+  Db,
+  "never",
+  "mysql",
+  "scalar",
+  never,
+  {},
+  "resolved"
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
+}
+
+const makeTemporal = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+>(
+  name: Name,
+  dbType: Db,
+  runtimeSchema: Schema.Schema<Runtime, any, any>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "mysql",
+    aggregation: "scalar",
+    source: undefined as never,
+    dependencies: {},
+    sourceNullability: "resolved"
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** MySQL current date. */
+export const currentDate = () =>
+  makeTemporal(
+    "current_date",
+    { dialect: "mysql", kind: "date" } as Expression.DbType.MySqlDate,
+    LocalDateStringSchema
+  )
+
+/** MySQL current time. */
+export const currentTime = () =>
+  makeTemporal(
+    "current_time",
+    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    LocalTimeStringSchema
+  )
+
+/** MySQL current timestamp. */
+export const currentTimestamp = () =>
+  makeTemporal(
+    "current_timestamp",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )
+
+/** MySQL local time. */
+export const localTime = () =>
+  makeTemporal(
+    "localtime",
+    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    LocalTimeStringSchema
+  )
+
+/** MySQL local timestamp. */
+export const localTimestamp = () =>
+  makeTemporal(
+    "localtimestamp",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )
+
+/** MySQL current instant-like timestamp. */
+export const now = () =>
+  makeTemporal(
+    "now",
+    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    LocalDateTimeStringSchema
+  )

package/src/mysql/function/window.ts

@@ -0,0 +1,7 @@
+import { mysqlQuery } from "../private/query.js"
+
+/** MySQL window functions. */
+export const over = mysqlQuery.over
+export const rowNumber = mysqlQuery.rowNumber
+export const rank = mysqlQuery.rank
+export const denseRank = mysqlQuery.denseRank

package/src/mysql/private/query.ts

@@ -0,0 +1 @@
+export { mysqlQuery } from "../../internal/mysql-query.js"