effect-qb 4.0.0-beta.66 → 4.0.0-beta.92

package/src/standard/function/index.ts

@@ -0,0 +1,18 @@
+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 * as temporal from "./temporal.js"
+
+export { coalesce, 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/standard/function/string.ts

@@ -0,0 +1,2 @@
+/** Standard string functions. */
+export { lower, upper, concat } from "../query.js"

package/src/standard/function/temporal.ts

@@ -0,0 +1,78 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/scalar.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import {
+  InstantStringSchema,
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type InstantString,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../../internal/runtime/value.js"
+import { standardDatatypes } from "../datatypes/index.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Scalar<
+  Runtime,
+  Db,
+  "never",
+  "standard",
+  "scalar",
+  never
+> & {
+  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>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "standard",
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** Standard current instant. */
+export const now = (): TemporalExpression<InstantString, ReturnType<typeof standardDatatypes.timestamp>, "now"> =>
+  makeTemporal("now", standardDatatypes.timestamp(), InstantStringSchema)
+
+/** Standard current date. */
+export const currentDate = (): TemporalExpression<LocalDateString, ReturnType<typeof standardDatatypes.date>, "current_date"> =>
+  makeTemporal("current_date", standardDatatypes.date(), LocalDateStringSchema)
+
+/** Standard current time. */
+export const currentTime = (): TemporalExpression<LocalTimeString, ReturnType<typeof standardDatatypes.time>, "current_time"> =>
+  makeTemporal("current_time", standardDatatypes.time(), LocalTimeStringSchema)
+
+/** Standard current timestamp. */
+export const currentTimestamp = (): TemporalExpression<LocalDateTimeString, ReturnType<typeof standardDatatypes.timestamp>, "current_timestamp"> =>
+  makeTemporal("current_timestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema)
+
+/** Standard local time. */
+export const localTime = (): TemporalExpression<LocalTimeString, ReturnType<typeof standardDatatypes.time>, "localtime"> =>
+  makeTemporal("localtime", standardDatatypes.time(), LocalTimeStringSchema)
+
+/** Standard local timestamp. */
+export const localTimestamp = (): TemporalExpression<LocalDateTimeString, ReturnType<typeof standardDatatypes.timestamp>, "localtimestamp"> =>
+  makeTemporal("localtimestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema)

package/src/standard/function/window.ts

@@ -0,0 +1,2 @@
+/** Standard window functions. */
+export { over, rowNumber, rank, denseRank } from "../query.js"

package/src/standard/index.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type IndexSpec = Extract<TableOptionSpec, { readonly kind: "index" }>
+
+export const make = BaseTable.index
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends IndexSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

package/src/standard/internal/renderer.ts

@@ -0,0 +1,45 @@
+import * as Query from "../../internal/query.js"
+import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
+import { type RenderState } from "../../internal/dialect.js"
+import { type Projection } from "../../internal/projections.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
+import { standardDialect } from "../dialect.js"
+
+export interface StandardRenderResult {
+  readonly sql: string
+  readonly params: readonly unknown[]
+  readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export interface StandardRenderOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
+}
+
+export const renderStandardPlan = <PlanValue extends Query.Plan.Any>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "standard">,
+  options: StandardRenderOptions = {}
+): StandardRenderResult => {
+  const state: RenderState = {
+    params: [],
+    valueMappings: options.valueMappings,
+    casing: options.casing,
+    ctes: [],
+    cteNames: new Set<string>(),
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
+  }
+  const rendered = renderQueryAst(
+    Query.getAst(plan as Query.Plan.Any) as any,
+    state,
+    standardDialect
+  )
+  return {
+    sql: rendered.sql,
+    params: state.params,
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
+  }
+}