effect-qb 0.20.0 → 0.22.0

package/src/mysql/executor.ts

@@ -26,6 +26,16 @@ export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"my
 /** MySQL-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"mysql">
 export type ValueMappings = Expression.DriverValueMappingsFor<MysqlDatatypeKind | "uuid", MysqlDatatypeFamily | "uuid">
+/** MySQL EXPLAIN options. ANALYZE always uses TREE output. */
+export type ExplainOptions =
+  | {
+      readonly analyze?: false
+      readonly format?: "text" | "json"
+    }
+  | {
+      readonly analyze: true
+      readonly format?: "text"
+    }
 /** Optional renderer / driver overrides for the standard MySQL executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
@@ -39,20 +49,37 @@ export type MysqlExecutorError = MysqlDriverError | RowDecodeError
 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
 
+/** Pipeable execution cardinality helpers. */
+export const atMostOne = CoreExecutor.atMostOne
+export const exactlyOne = CoreExecutor.exactlyOne
+export const nonEmpty = CoreExecutor.nonEmpty
+
 /** Runs an effect within the ambient MySQL SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
 
 /** MySQL executor whose error channel narrows based on the query plan. */
-export interface QueryExecutor<Context = never> {
+export interface QueryExecutor<Context = never> extends CoreExecutor.Executor<"mysql", MysqlQueryError<any>, Context> {
   readonly dialect: "mysql"
   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>
+  executeResult<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
+  ): Effect.Effect<CoreExecutor.ExecutionResult<CoreQuery.ResultRow<PlanValue>>, MysqlQueryError<PlanValue>, Context>
+  prepare<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
+  ): CoreExecutor.PreparedQuery<CoreQuery.ResultRow<PlanValue>, MysqlQueryError<PlanValue>, Context>
   stream<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
       ? CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
       : never
   ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, MysqlQueryError<PlanValue>, Context>
+  explain<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
+      ? CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
+      : never,
+    options?: ExplainOptions
+  ): Effect.Effect<ReadonlyArray<FlatRow>, MysqlQueryError<PlanValue>, Context>
 }
 
 /** Constructs a MySQL-specialized SQL driver. */
@@ -72,6 +99,9 @@ export function driver<
     readonly execute: <Row>(
       query: CoreRenderer.RenderedQuery<Row, "mysql">
     ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+    readonly executeResult?: <Row>(
+      query: CoreRenderer.RenderedQuery<Row, "mysql">
+    ) => Effect.Effect<CoreExecutor.DriverResult, Error, Context>
     readonly stream: <Row>(
       query: CoreRenderer.RenderedQuery<Row, "mysql">
     ) => Stream.Stream<FlatRow, Error, Context>
@@ -89,6 +119,9 @@ export function driver<
       readonly execute: <Row>(
         query: CoreRenderer.RenderedQuery<Row, "mysql">
       ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+      readonly executeResult?: <Row>(
+        query: CoreRenderer.RenderedQuery<Row, "mysql">
+      ) => Effect.Effect<CoreExecutor.DriverResult, Error, Context>
       readonly stream: <Row>(
         query: CoreRenderer.RenderedQuery<Row, "mysql">
       ) => Stream.Stream<FlatRow, Error, Context>
@@ -105,57 +138,105 @@ const fromDriver = <
   sqlDriver: Driver<Error, Context>,
   driverMode: CoreExecutor.DriverMode = "raw",
   valueMappings?: Expression.DriverValueMappings
-): QueryExecutor<Context> => ({
-  dialect: "mysql",
-  execute(plan) {
-    const rendered = renderer.render(plan)
-    return Effect.mapError(
-      Effect.flatMap(
-        sqlDriver.execute(rendered),
-        (rows) => Effect.try({
-          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
-          catch: (error) => error as RowDecodeError
-        })
-      ),
-      (error) => {
-        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-          return error as RowDecodeError
-        }
-        const normalized = normalizeMysqlDriverError(error, rendered)
-        return CoreExecutor.hasWriteCapability(plan)
-          ? normalized
-          : narrowMysqlDriverErrorForReadQuery(normalized)
-      }
-    ) as Effect.Effect<any, any, Context>
-  },
-  stream(plan) {
-    const rendered = renderer.render(plan)
-    return Stream.mapError(
-      Stream.mapArrayEffect(
-        sqlDriver.stream(rendered),
-        (rows) => Effect.try({
-          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
-          catch: (error) => error as RowDecodeError
-        })
-      ),
-      (error) => {
-        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-          return error as RowDecodeError
-        }
-        const normalized = normalizeMysqlDriverError(error, rendered)
-        return CoreExecutor.hasWriteCapability(plan)
-          ? normalized
-          : narrowMysqlDriverErrorForReadQuery(normalized)
-      }
-    ) as Stream.Stream<any, any, Context>
+): QueryExecutor<Context> => {
+  const renderedCache = new WeakMap<object, CoreRenderer.RenderedQuery<any, "mysql">>()
+  const render = (plan: CoreQuery.Plan.Any) => {
+    const cached = renderedCache.get(plan)
+    if (cached !== undefined) {
+      return cached
+    }
+    const rendered = renderer.render(plan as any)
+    renderedCache.set(plan, rendered)
+    return rendered
+  }
+  const mapExecutionError = (
+    error: unknown,
+    rendered: CoreRenderer.RenderedQuery<any, "mysql">,
+    plan: CoreQuery.Plan.Any
+  ) => {
+    if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+      return error as RowDecodeError
+    }
+    const normalized = normalizeMysqlDriverError(error, rendered)
+    return CoreExecutor.hasWriteCapability(plan)
+      ? normalized
+      : narrowMysqlDriverErrorForReadQuery(normalized)
   }
-})
+  return CoreExecutor.withResultContracts({
+    dialect: "mysql",
+    execute(plan) {
+      const rendered = render(plan)
+      return Effect.mapError(
+        Effect.flatMap(
+          sqlDriver.execute(rendered),
+          (rows) => Effect.try({
+            try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
+            catch: (error) => error as RowDecodeError
+          })
+        ),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    },
+    executeResult(plan) {
+      const rendered = render(plan)
+      const result = sqlDriver.executeResult
+        ? sqlDriver.executeResult(rendered)
+        : Effect.map(sqlDriver.execute(rendered), (rows) => ({ rows }))
+      return Effect.mapError(
+        Effect.flatMap(result, ({ rows, ...metadata }) => Effect.try({
+          try: () => ({
+            ...metadata,
+            rows: CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings })
+          }),
+          catch: (error) => error as RowDecodeError
+        })),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    },
+    stream(plan) {
+      const rendered = render(plan)
+      return Stream.mapError(
+        Stream.mapArrayEffect(
+          sqlDriver.stream(rendered),
+          (rows) => Effect.try({
+            try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
+            catch: (error) => error as RowDecodeError
+          })
+        ),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Stream.Stream<any, any, Context>
+    },
+    explain(plan, options) {
+      const rendered = CoreExecutor.explainQuery(render(plan), options)
+      return Effect.mapError(
+        sqlDriver.execute(rendered),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    }
+  }) as QueryExecutor<Context>
+}
 
 const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
   driver({
     execute: (query) =>
       Effect.flatMap(SqlClient.SqlClient, (sql) =>
         sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    executeResult: (query) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        Effect.map(sql.unsafe<FlatRow>(query.sql, [...query.params]).raw, (raw) => {
+          if (Array.isArray(raw)) {
+            return { rows: raw as ReadonlyArray<FlatRow> }
+          }
+          const header = raw as {
+            readonly affectedRows?: number
+            readonly insertId?: number | string
+          } | null
+          return {
+            rows: [],
+            ...(typeof header?.affectedRows === "number" ? { affectedRows: header.affectedRows } : {}),
+            ...(header?.insertId === undefined ? {} : { insertId: header.insertId })
+          }
+        })),
     stream: (query) =>
       CoreExecutor.streamFromSqlClient(query)
   })

package/src/mysql/function/aggregate.ts

@@ -1,2 +1,88 @@
-/** MySQL aggregate functions. */
+import * as Numeric from "../../internal/dialect-numeric.js"
+import * as Expression from "../../internal/scalar.js"
+import { mysqlDatatypes } from "../datatypes/index.js"
+
 export { count, max, min } from "../internal/dsl.js"
+
+type MyDecimal = ReturnType<typeof mysqlDatatypes.decimal>
+type MyDouble = ReturnType<typeof mysqlDatatypes.double>
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type BaseDb<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? BaseDb<Base>
+    : Db
+
+type MyAggregateCategory<Db extends Expression.DbType.Any> =
+  BaseDb<Db> extends infer Base extends Expression.DbType.Any
+    ? Base["dialect"] extends "standard"
+      ? Base["kind"] extends "int" | "integer" | "bigint" | "numeric" | "decimal"
+        ? "exact"
+        : Base["kind"] extends "real" ? "approximate" : never
+      : Base["dialect"] extends "mysql"
+        ? Base["kind"] extends "tinyint" | "smallint" | "mediumint" | "int" | "integer" | "bigint" |
+          "decimal" | "dec" | "numeric" | "fixed"
+          ? "exact"
+          : Base["kind"] extends "float" | "double" | "real" ? "approximate" : never
+        : never
+    : never
+
+type AggregateInputError<
+  Operation extends "sum" | "avg",
+  Db extends Expression.DbType.Any
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported mysql aggregate input"
+  readonly __effect_qb_operation__: Operation
+  readonly __effect_qb_db_type__: Db
+  readonly __effect_qb_expected__: "an integer, decimal, float, double, or real database type"
+  readonly __effect_qb_hint__: "Use Cast.to(...) with a supported Type or My.Type witness"
+}
+
+type MyAggregateConstraint<
+  Value extends Numeric.Input,
+  Operation extends "sum" | "avg"
+> = IsAny<Value> extends true ? unknown
+  : Numeric.DialectConstraint<Value, MyDouble, "mysql"> & (
+    MyAggregateCategory<Numeric.DbTypeOfInput<Value, MyDouble, "mysql">> extends never
+      ? AggregateInputError<
+          Operation,
+          Numeric.DbTypeOfInput<Value, MyDouble, "mysql">
+        >
+      : unknown
+  )
+
+type MyAggregateResultDb<Value extends Numeric.Input> =
+  MyAggregateCategory<Numeric.DbTypeOfInput<Value, MyDouble, "mysql">> extends "exact"
+    ? MyDecimal
+    : MyDouble
+
+const baseDb = (db: Expression.DbType.Any): Expression.DbType.Any =>
+  "base" in db ? baseDb(db.base) : db
+
+const resultDb = (value: Numeric.Input): MyDecimal | MyDouble => {
+  if (typeof value === "number") return mysqlDatatypes.double()
+  const db = baseDb(value[Expression.TypeId].dbType)
+  const approximate = db.kind === "real" || db.kind === "float" || db.kind === "double"
+  return approximate
+    ? mysqlDatatypes.double()
+    : mysqlDatatypes.decimal()
+}
+
+export const sum = <Value extends Numeric.Input>(
+  value: Value & MyAggregateConstraint<NoInfer<Value>, "sum">
+): Numeric.AggregateResult<"sum", Value, MyDouble, MyAggregateResultDb<Value>, "mysql"> =>
+  (Numeric.aggregate as any)("sum", value, {
+    dialect: "mysql",
+    literalDb: mysqlDatatypes.double(),
+    resultDb: resultDb(value)
+  })
+
+export const avg = <Value extends Numeric.Input>(
+  value: Value & MyAggregateConstraint<NoInfer<Value>, "avg">
+): Numeric.AggregateResult<"avg", Value, MyDouble, MyAggregateResultDb<Value>, "mysql"> =>
+  (Numeric.aggregate as any)("avg", value, {
+    dialect: "mysql",
+    literalDb: mysqlDatatypes.double(),
+    resultDb: resultDb(value)
+  })

package/src/mysql/function/index.ts

@@ -1,14 +1,17 @@
 export * as core from "./core.js"
 export * as string from "./string.js"
 export * as aggregate from "./aggregate.js"
+export * as numeric from "./numeric.js"
 export * as window from "./window.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 { avg, count, max, min, sum } from "./aggregate.js"
+export { modulo, round } from "./numeric.js"
+export { firstValue, lastValue, over, rowNumber, rank, denseRank } from "./window.js"
+export type { WindowSpec } from "./window.js"
 export {
   currentDate,
   currentTime,

package/src/mysql/function/numeric.ts

@@ -0,0 +1,185 @@
+import * as Numeric from "../../internal/dialect-numeric.js"
+import * as Expression from "../../internal/scalar.js"
+import { mysqlDatatypes } from "../datatypes/index.js"
+import { mysqlDatatypeFamilies } from "../datatypes/spec.js"
+
+type MyNumericDb<
+  Kind extends "bigint" | "decimal" | "double",
+  Runtime extends "number" | "bigintString" | "decimalString"
+> = Expression.DbType.Base<"mysql", Kind> & {
+  readonly family: "numeric"
+  readonly runtime: Runtime
+  readonly compareGroup: "numeric"
+  readonly castTargets: typeof mysqlDatatypeFamilies.numeric.castTargets
+  readonly implicitTargets: readonly []
+  readonly traits: { readonly ordered: true }
+}
+
+type MyBigInt = MyNumericDb<"bigint", "bigintString">
+type MyDecimal = MyNumericDb<"decimal", "decimalString">
+type MyDouble = MyNumericDb<"double", "number">
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type BaseDb<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? BaseDb<Base>
+    : Db
+
+type MyNumericCategory<Db extends Expression.DbType.Any> =
+  BaseDb<Db> extends infer Base extends Expression.DbType.Any
+    ? Base["dialect"] extends "standard"
+      ? Base["kind"] extends "int" | "integer" | "bigint" ? "integer"
+        : Base["kind"] extends "numeric" | "decimal" ? "exact"
+          : Base["kind"] extends "real" ? "approximate"
+            : never
+      : Base["dialect"] extends "mysql"
+        ? Base["kind"] extends "tinyint" | "smallint" | "mediumint" | "int" | "integer" | "bigint"
+          ? "integer"
+          : Base["kind"] extends "decimal" | "dec" | "numeric" | "fixed"
+            ? "exact"
+            : Base["kind"] extends "float" | "double" | "real"
+              ? "approximate"
+              : never
+        : never
+    : never
+
+type NumericInputError<
+  Operation extends "modulo" | "round",
+  Db extends Expression.DbType.Any
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported mysql numeric input"
+  readonly __effect_qb_operation__: Operation
+  readonly __effect_qb_db_type__: Db
+  readonly __effect_qb_expected__: "an integer, decimal, float, double, or real database type"
+  readonly __effect_qb_hint__: "Use Cast.to(...) with a supported Type or My.Type witness"
+}
+
+type MyNumericConstraint<
+  Value extends Numeric.Input,
+  Operation extends "modulo" | "round"
+> =
+  IsAny<Value> extends true ? unknown
+    : Numeric.DialectConstraint<Value, MyDouble, "mysql"> & (
+      MyNumericCategory<Numeric.DbTypeOfInput<Value, MyDouble, "mysql">> extends never
+        ? NumericInputError<Operation, Numeric.DbTypeOfInput<Value, MyDouble, "mysql">>
+        : unknown
+    )
+
+type MyResultCategory<
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+> =
+  MyNumericCategory<Numeric.DbTypeOfInput<Left, MyDouble, "mysql">> extends infer LeftCategory
+    ? MyNumericCategory<Numeric.DbTypeOfInput<Right, MyDouble, "mysql">> extends infer RightCategory
+      ? "approximate" extends LeftCategory | RightCategory ? "approximate"
+        : "exact" extends LeftCategory | RightCategory ? "exact"
+          : "integer"
+      : never
+    : never
+
+type MyResultDbForCategory<Category> =
+  Category extends "approximate" ? MyDouble
+    : Category extends "exact" ? MyDecimal
+      : MyBigInt
+
+type MyModuloResultDb<
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+> = MyResultDbForCategory<MyResultCategory<Left, Right>>
+
+type MyRoundResultDb<Value extends Numeric.Input> =
+  MyResultDbForCategory<MyNumericCategory<Numeric.DbTypeOfInput<Value, MyDouble, "mysql">>>
+
+type MyModuloResult<
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+> = Numeric.BinaryResult<
+  Left,
+  Right,
+  MyDouble,
+  MyModuloResultDb<Left, Right>,
+  Numeric.ZeroDivisorNullability<Left, Right, MyDouble, "mysql">,
+  "mysql"
+>
+
+type MyRoundResult<
+  Value extends Numeric.Input,
+  WithScale extends boolean
+> = Numeric.RoundResult<
+  Value,
+  MyDouble,
+  MyRoundResultDb<Value>,
+  Value extends Expression.Any ? Expression.NullabilityOf<Value> : "never",
+  "mysql",
+  WithScale
+>
+
+const baseDb = (db: Expression.DbType.Any): Expression.DbType.Any =>
+  "base" in db ? baseDb(db.base) : db
+
+const category = (value: Numeric.Input): "integer" | "exact" | "approximate" => {
+  if (typeof value === "number") return "approximate"
+  const db = baseDb(value[Expression.TypeId].dbType)
+  if (db.kind === "int" || db.kind === "integer" || db.kind === "bigint" ||
+    db.kind === "tinyint" || db.kind === "smallint" || db.kind === "mediumint") {
+    return "integer"
+  }
+  if (db.kind === "numeric" || db.kind === "decimal" || db.kind === "dec" || db.kind === "fixed") {
+    return "exact"
+  }
+  return "approximate"
+}
+
+const resultDb = (categoryValue: "integer" | "exact" | "approximate") => {
+  if (categoryValue === "integer") return mysqlDatatypes.bigint()
+  if (categoryValue === "exact") return mysqlDatatypes.decimal()
+  return mysqlDatatypes.double()
+}
+
+const mergedCategory = (
+  left: Numeric.Input,
+  right: Numeric.Input
+): "integer" | "exact" | "approximate" => {
+  const categories = [category(left), category(right)]
+  return categories.includes("approximate")
+    ? "approximate"
+    : categories.includes("exact") ? "exact" : "integer"
+}
+
+export const modulo = <
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+>(
+  left: Left & MyNumericConstraint<NoInfer<Left>, "modulo">,
+  right: Right & MyNumericConstraint<NoInfer<Right>, "modulo">
+): MyModuloResult<Left, Right> =>
+  (Numeric.modulo as any)(left, right, {
+    dialect: "mysql",
+    literalDb: mysqlDatatypes.double(),
+    resultDb: resultDb(mergedCategory(left, right)) as MyModuloResultDb<Left, Right>,
+    nullability: Numeric.nullableForZeroDivisor(left, right) as Numeric.ZeroDivisorNullability<Left, Right, MyDouble, "mysql">
+  }) as MyModuloResult<Left, Right>
+
+const roundRuntime = (
+  value: Numeric.Input,
+  scale?: number
+): Expression.Any => {
+  return Numeric.round(value, scale, {
+    dialect: "mysql",
+    literalDb: mysqlDatatypes.double(),
+    scaleDb: mysqlDatatypes.bigint(),
+    resultDb: resultDb(category(value)),
+    nullability: typeof value === "number" ? "never" : value[Expression.TypeId].nullability
+  }) as Expression.Any
+}
+
+export const round: {
+  <Value extends Numeric.Input>(
+    value: Value & MyNumericConstraint<NoInfer<Value>, "round">
+  ): MyRoundResult<Value, false>
+  <Value extends Numeric.Input>(
+    value: Value & MyNumericConstraint<NoInfer<Value>, "round">,
+    scale: number
+  ): MyRoundResult<Value, true>
+} = roundRuntime as any

package/src/mysql/function/temporal.ts

@@ -71,23 +71,23 @@ export const currentTime = () =>
 export const currentTimestamp = () =>
   makeTemporal(
     "current_timestamp",
-    mysqlDatatypes.timestamp(),
+    mysqlDatatypes.datetime(),
     LocalDateTimeStringSchema
   )
 
-/** MySQL local time. */
+/** MySQL LOCALTIME, a synonym for NOW that returns a local date and time. */
 export const localTime = () =>
   makeTemporal(
     "localtime",
-    mysqlDatatypes.time(),
-    LocalTimeStringSchema
+    mysqlDatatypes.datetime(),
+    LocalDateTimeStringSchema
   )
 
 /** MySQL local timestamp. */
 export const localTimestamp = () =>
   makeTemporal(
     "localtimestamp",
-    mysqlDatatypes.timestamp(),
+    mysqlDatatypes.datetime(),
     LocalDateTimeStringSchema
   )
 
@@ -95,6 +95,6 @@ export const localTimestamp = () =>
 export const now = () =>
   makeTemporal(
     "now",
-    mysqlDatatypes.timestamp(),
+    mysqlDatatypes.datetime(),
     LocalDateTimeStringSchema
   )

package/src/mysql/function/window.ts

@@ -1,2 +1,14 @@
+import {
+  makeDialectFirstValue,
+  makeDialectLastValue
+} from "../../internal/analytics.js"
+export type { WindowSpec } from "../../internal/analytics.js"
+
 /** MySQL window functions. */
 export { over, rowNumber, rank, denseRank } from "../internal/dsl.js"
+
+/** First value in a MySQL window frame. */
+export const firstValue = makeDialectFirstValue("mysql")
+
+/** Last value in a MySQL window frame. */
+export const lastValue = makeDialectLastValue("mysql")