@housekit/orm 0.1.47 → 0.1.48

package/dist/modules/time.d.ts

@@ -1,154 +1,31 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Get current timestamp
- */
 export declare function timeNow(): SQLExpression;
-/**
- * Get current date (without time)
- */
 export declare function timeToday(): SQLExpression;
-/**
- * Get yesterday's date (without time)
- */
 export declare function timeYesterday(): SQLExpression;
-/**
- * Convert to Date type (without time)
- * @param col - Date/datetime column or expression
- */
 export declare function timeToDate(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to DateTime type
- * @param col - Date/datetime column or expression
- */
 export declare function timeToDateTime(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to Unix timestamp (super common in time-series analytics)
- * @param col - DateTime column or expression
- */
 export declare function toUnixTimestamp(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Format datetime to string
- * @param col - DateTime column or expression
- * @param format - Format string (e.g., '%Y-%m-%d %H:%M:%S')
- */
 export declare function timeFormatDateTime(col: ClickHouseColumn | SQLExpression, format: string): SQLExpression;
-/**
- * Truncate to start of hour
- * @param col - DateTime column or expression
- */
 export declare function timeToStartOfHour(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of day
- * @param col - DateTime column or expression
- */
 export declare function timeToStartOfDay(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of week
- * @param col - DateTime column or expression
- */
 export declare function timeToStartOfWeek(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of month
- * @param col - DateTime column or expression
- */
 export declare function timeToStartOfMonth(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of quarter
- * @param col - DateTime column or expression
- */
 export declare function toStartOfQuarter(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of year
- * @param col - DateTime column or expression
- */
 export declare function toStartOfYear(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Truncate to start of interval (very flexible for custom time buckets)
- * @param col - DateTime column or expression
- * @param interval - Interval string (e.g., 'INTERVAL 1 HOUR', 'INTERVAL 15 MINUTE')
- * @param timezone - Optional timezone
- */
 export declare function toStartOfInterval(col: ClickHouseColumn | SQLExpression, interval: string, timezone?: string): SQLExpression;
-/**
- * Calculate difference between two dates
- * @param unit - Unit of difference ('year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second')
- * @param start - Start date
- * @param end - End date
- */
 export declare function dateDiff(unit: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second', start: ClickHouseColumn | SQLExpression, end: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Add interval to date
- * @param unit - Unit to add ('year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second')
- * @param amount - Amount to add
- * @param date - Date to add to
- */
 export declare function dateAdd(unit: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second', amount: number, date: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Subtract interval from date
- * @param unit - Unit to subtract ('year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second')
- * @param amount - Amount to subtract
- * @param date - Date to subtract from
- */
 export declare function dateSub(unit: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second', amount: number, date: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert datetime to different timezone
- * @param col - DateTime column or expression
- * @param timezone - Target timezone
- */
 export declare function toTimezone(col: ClickHouseColumn | SQLExpression, timezone: string): SQLExpression;
-/**
- * Get timezone offset for datetime
- * @param col - DateTime column or expression
- */
 export declare function timeOffset(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract year from date
- * @param col - Date/datetime column or expression
- */
 export declare function toYear(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract quarter from date
- * @param col - Date/datetime column or expression
- */
 export declare function toQuarter(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract month from date
- * @param col - Date/datetime column or expression
- */
 export declare function toMonth(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract day of month from date
- * @param col - Date/datetime column or expression
- */
 export declare function toDayOfMonth(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract day of week from date
- * @param col - Date/datetime column or expression
- */
 export declare function toDayOfWeek(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract hour from datetime
- * @param col - DateTime column or expression
- */
 export declare function toHour(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract minute from datetime
- * @param col - DateTime column or expression
- */
 export declare function toMinute(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract second from datetime
- * @param col - DateTime column or expression
- */
 export declare function toSecond(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get ISO week number from date
- * @param col - Date/datetime column or expression
- */
 export declare function toISOWeek(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get week number from date (ClickHouse-specific)
- * @param col - Date/datetime column or expression
- */
 export declare function toWeek(col: ClickHouseColumn | SQLExpression): SQLExpression;

package/dist/modules/time.js

@@ -0,0 +1,91 @@
+import { sql } from '../expressions';
+export function timeNow() {
+    return sql `now()`;
+}
+export function timeToday() {
+    return sql `today()`;
+}
+export function timeYesterday() {
+    return sql `yesterday()`;
+}
+export function timeToDate(col) {
+    return sql `toDate(${col})`;
+}
+export function timeToDateTime(col) {
+    return sql `toDateTime(${col})`;
+}
+export function toUnixTimestamp(col) {
+    return sql `toUnixTimestamp(${col})`;
+}
+export function timeFormatDateTime(col, format) {
+    return sql `formatDateTime(${col}, '${format}')`;
+}
+export function timeToStartOfHour(col) {
+    return sql `toStartOfHour(${col})`;
+}
+export function timeToStartOfDay(col) {
+    return sql `toStartOfDay(${col})`;
+}
+export function timeToStartOfWeek(col) {
+    return sql `toStartOfWeek(${col})`;
+}
+export function timeToStartOfMonth(col) {
+    return sql `toStartOfMonth(${col})`;
+}
+export function toStartOfQuarter(col) {
+    return sql `toStartOfQuarter(${col})`;
+}
+export function toStartOfYear(col) {
+    return sql `toStartOfYear(${col})`;
+}
+export function toStartOfInterval(col, interval, timezone) {
+    if (timezone) {
+        return sql `toStartOfInterval(${col}, ${interval}, '${timezone}')`;
+    }
+    return sql `toStartOfInterval(${col}, ${interval})`;
+}
+export function dateDiff(unit, start, end) {
+    return sql `dateDiff('${unit}', ${start}, ${end})`;
+}
+export function dateAdd(unit, amount, date) {
+    return sql `dateAdd(${unit}, ${amount}, ${date})`;
+}
+export function dateSub(unit, amount, date) {
+    return sql `dateSub(${unit}, ${amount}, ${date})`;
+}
+export function toTimezone(col, timezone) {
+    return sql `toTimezone(${col}, '${timezone}')`;
+}
+export function timeOffset(col) {
+    return sql `timeOffset(${col})`;
+}
+export function toYear(col) {
+    return sql `toYear(${col})`;
+}
+export function toQuarter(col) {
+    return sql `toQuarter(${col})`;
+}
+export function toMonth(col) {
+    return sql `toMonth(${col})`;
+}
+export function toDayOfMonth(col) {
+    return sql `toDayOfMonth(${col})`;
+}
+export function toDayOfWeek(col) {
+    return sql `toDayOfWeek(${col})`;
+}
+export function toHour(col) {
+    return sql `toHour(${col})`;
+}
+export function toMinute(col) {
+    return sql `toMinute(${col})`;
+}
+export function toSecond(col) {
+    return sql `toSecond(${col})`;
+}
+export function toISOWeek(col) {
+    return sql `toISOWeek(${col})`;
+}
+export function toWeek(col) {
+    return sql `toWeek(${col})`;
+}

package/dist/modules/types.d.ts

@@ -1,118 +1,26 @@
 export type JsonValue = Record<string, any> | any[];
 import { ClickHouseColumn } from '../column';
-/**
- * Low cardinality string column (very common for dimensions)
- * @param name - Column name
- */
 export declare function lowCardinalityString(name: string): ClickHouseColumn<string>;
-/**
- * Low cardinality nullable string column
- * @param name - Column name
- */
 export declare function lowCardinalityNullableString(name: string): ClickHouseColumn<string | null>;
-/**
- * Nullable JSON column
- * @param name - Column name
- */
 export declare function nullableJson(name: string): ClickHouseColumn<JsonValue | null>;
-/**
- * Low cardinality JSON column
- * @param name - Column name
- */
 export declare function lowCardinalityJson(name: string): ClickHouseColumn<JsonValue>;
-/**
- * Low cardinality nullable JSON column
- * @param name - Column name
- */
 export declare function lowCardinalityNullableJson(name: string): ClickHouseColumn<JsonValue | null>;
-/**
- * Create an Enum8 column with TypeScript union type support
- * @param name - Column name
- * @param values - Array of possible values
- */
 export declare function enum8<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T>;
-/**
- * Create a nullable Enum8 column with TypeScript union type support
- * @param name - Column name
- * @param values - Array of possible values
- */
 export declare function nullableEnum8<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T | null>;
-/**
- * Create an Enum16 column with TypeScript union type support
- * @param name - Column name
- * @param values - Array of possible values
- */
 export declare function enum16<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T>;
-/**
- * Create a nullable Enum16 column with TypeScript union type support
- * @param name - Column name
- * @param values - Array of possible values
- */
 export declare function nullableEnum16<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T | null>;
-/**
- * Array of strings with low cardinality
- * @param name - Column name
- */
 export declare function lowCardinalityStringArray(name: string): ClickHouseColumn<string[]>;
-/**
- * Nullable array of strings
- * @param name - Column name
- */
 export declare function nullableStringArray(name: string): ClickHouseColumn<string[] | null>;
-/**
- * Array of nullable strings
- * @param name - Column name
- */
 export declare function stringNullableArray(name: string): ClickHouseColumn<(string | null)[]>;
-/**
- * Array of integers with low cardinality
- * @param name - Column name
- */
 export declare function lowCardinalityInt32Array(name: string): ClickHouseColumn<number[]>;
-/**
- * Email column (low cardinality string)
- * @param name - Column name
- */
 export declare function email(name: string): ClickHouseColumn<string>;
-/**
- * Nullable email column
- * @param name - Column name
- */
 export declare function nullableEmail(name: string): ClickHouseColumn<string | null>;
-/**
- * Phone number column (low cardinality string)
- * @param name - Column name
- */
 export declare function phone(name: string): ClickHouseColumn<string>;
-/**
- * Nullable phone number column
- * @param name - Column name
- */
 export declare function nullablePhone(name: string): ClickHouseColumn<string | null>;
-/**
- * Country code column (Enum8 with common country codes)
- * @param name - Column name
- */
 export declare function countryCode(name: string): ClickHouseColumn<string>;
-/**
- * Nullable country code column
- * @param name - Column name
- */
 export declare function nullableCountryCode(name: string): ClickHouseColumn<string | null>;
-/**
- * Status column (Enum8 with common statuses)
- * @param name - Column name
- */
 export declare function status<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T>;
-/**
- * Nullable status column
- * @param name - Column name
- * @param values - Array of possible status values
- */
 export declare function nullableStatus<T extends string>(name: string, values: readonly T[]): ClickHouseColumn<T | null>;
-/**
- * Common status values for reference
- */
 export declare const COMMON_STATUSES: {
     readonly ACTIVE: "active";
     readonly INACTIVE: "inactive";
@@ -125,53 +33,12 @@ export declare const COMMON_STATUSES: {
     readonly ARCHIVED: "archived";
     readonly DELETED: "deleted";
 };
-/**
- * Create a status column with common predefined values
- * @param name - Column name
- * @param customValues - Optional custom status values
- */
 export declare function commonStatus(name: string, customValues?: readonly string[]): ClickHouseColumn<string>;
-/**
- * Create a nullable status column with common predefined values
- * @param name - Column name
- * @param customValues - Optional custom status values
- */
 export declare function nullableCommonStatus(name: string, customValues?: readonly string[]): ClickHouseColumn<string | null>;
-/**
- * Created at timestamp column (DateTime with default now())
- * @param name - Column name
- * @param timezone - Optional timezone
- */
 export declare function createdAt(name?: string, timezone?: string): ClickHouseColumn<string>;
-/**
- * Updated at timestamp column (DateTime with default now() and on update)
- * @param name - Column name
- * @param timezone - Optional timezone
- */
 export declare function updatedAt(name?: string, timezone?: string): ClickHouseColumn<string>;
-/**
- * Deleted at timestamp column (nullable DateTime for soft deletes)
- * @param name - Column name
- * @param timezone - Optional timezone
- */
 export declare function deletedAt(name?: string, timezone?: string): ClickHouseColumn<string | null>;
-/**
- * Auto-generated UUID primary key
- * @param name - Column name
- */
 export declare function uuidPrimaryKey(name?: string): ClickHouseColumn<string>;
-/**
- * Auto-generated UUID primary key with low cardinality (for distributed systems)
- * @param name - Column name
- */
 export declare function lowCardinalityUuidPrimaryKey(name?: string): ClickHouseColumn<string>;
-/**
- * Sequential integer primary key
- * @param name - Column name
- */
 export declare function int32PrimaryKey(name?: string): ClickHouseColumn<number>;
-/**
- * Sequential big integer primary key
- * @param name - Column name
- */
 export declare function int64PrimaryKey(name?: string): ClickHouseColumn<number>;

package/dist/modules/types.js

@@ -0,0 +1,114 @@
+import { ClickHouseColumn } from '../column';
+import { sql } from '../expressions';
+export function lowCardinalityString(name) {
+    return new ClickHouseColumn(name, 'LowCardinality(String)');
+}
+export function lowCardinalityNullableString(name) {
+    return new ClickHouseColumn(name, 'LowCardinality(Nullable(String))', true);
+}
+export function nullableJson(name) {
+    return new ClickHouseColumn(name, 'Nullable(JSON)', true, { isJson: true });
+}
+export function lowCardinalityJson(name) {
+    return new ClickHouseColumn(name, 'LowCardinality(JSON)', false, { isJson: true });
+}
+export function lowCardinalityNullableJson(name) {
+    return new ClickHouseColumn(name, 'LowCardinality(Nullable(JSON))', true, { isJson: true });
+}
+export function enum8(name, values) {
+    const enumDef = values.map((v, i) => `'${v}'=${i}`).join(', ');
+    return new ClickHouseColumn(name, `Enum8(${enumDef})`, false, { enumValues: values });
+}
+export function nullableEnum8(name, values) {
+    const enumDef = values.map((v, i) => `'${v}'=${i}`).join(', ');
+    return new ClickHouseColumn(name, `Nullable(Enum8(${enumDef}))`, true, { enumValues: values });
+}
+export function enum16(name, values) {
+    const enumDef = values.map((v, i) => `'${v}'=${i}`).join(', ');
+    return new ClickHouseColumn(name, `Enum16(${enumDef})`, false, { enumValues: values });
+}
+export function nullableEnum16(name, values) {
+    const enumDef = values.map((v, i) => `'${v}'=${i}`).join(', ');
+    return new ClickHouseColumn(name, `Nullable(Enum16(${enumDef}))`, true, { enumValues: values });
+}
+export function lowCardinalityStringArray(name) {
+    return new ClickHouseColumn(name, 'Array(LowCardinality(String))');
+}
+export function nullableStringArray(name) {
+    return new ClickHouseColumn(name, 'Nullable(Array(String))', true);
+}
+export function stringNullableArray(name) {
+    return new ClickHouseColumn(name, 'Array(Nullable(String))');
+}
+export function lowCardinalityInt32Array(name) {
+    return new ClickHouseColumn(name, 'Array(LowCardinality(Int32))');
+}
+export function email(name) {
+    return lowCardinalityString(name);
+}
+export function nullableEmail(name) {
+    return lowCardinalityNullableString(name);
+}
+export function phone(name) {
+    return lowCardinalityString(name);
+}
+export function nullablePhone(name) {
+    return lowCardinalityNullableString(name);
+}
+export function countryCode(name) {
+    return enum8(name, ['US', 'CA', 'GB', 'DE', 'FR', 'IT', 'ES', 'JP', 'CN', 'IN', 'BR', 'MX', 'AU', 'RU', 'KR', 'OTHER']);
+}
+export function nullableCountryCode(name) {
+    return nullableEnum8(name, ['US', 'CA', 'GB', 'DE', 'FR', 'IT', 'ES', 'JP', 'CN', 'IN', 'BR', 'MX', 'AU', 'RU', 'KR', 'OTHER']);
+}
+export function status(name, values) {
+    return enum8(name, values);
+}
+export function nullableStatus(name, values) {
+    return nullableEnum8(name, values);
+}
+export const COMMON_STATUSES = {
+    ACTIVE: 'active',
+    INACTIVE: 'inactive',
+    PENDING: 'pending',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+    DRAFT: 'draft',
+    PUBLISHED: 'published',
+    ARCHIVED: 'archived',
+    DELETED: 'deleted',
+};
+export function commonStatus(name, customValues) {
+    const values = customValues || Object.values(COMMON_STATUSES);
+    return enum8(name, values);
+}
+export function nullableCommonStatus(name, customValues) {
+    const values = customValues || Object.values(COMMON_STATUSES);
+    return nullableEnum8(name, values);
+}
+export function createdAt(name = 'created_at', timezone) {
+    const col = new ClickHouseColumn(name, timezone ? `DateTime('${timezone}')` : 'DateTime');
+    return col.default(sql `now()`);
+}
+export function updatedAt(name = 'updated_at', timezone) {
+    const col = new ClickHouseColumn(name, timezone ? `DateTime('${timezone}')` : 'DateTime');
+    return col.default(sql `now()`);
+}
+export function deletedAt(name = 'deleted_at', timezone) {
+    const col = new ClickHouseColumn(name, timezone ? `DateTime('${timezone}')` : 'DateTime', true);
+    return col.nullable();
+}
+export function uuidPrimaryKey(name = 'id') {
+    return new ClickHouseColumn(name, 'UUID').autoGenerate().primaryKey();
+}
+export function lowCardinalityUuidPrimaryKey(name = 'id') {
+    const col = new ClickHouseColumn(name, 'LowCardinality(UUID)');
+    return col.autoGenerate().primaryKey();
+}
+export function int32PrimaryKey(name = 'id') {
+    return new ClickHouseColumn(name, 'Int32').primaryKey();
+}
+export function int64PrimaryKey(name = 'id') {
+    return new ClickHouseColumn(name, 'Int64').primaryKey();
+}

package/dist/modules/window.js

@@ -0,0 +1,140 @@
+import { ClickHouseColumn } from '../core';
+import { sql } from '../expressions';
+class WindowExpression {
+    base;
+    spec;
+    _type;
+    constructor(base, spec) {
+        this.base = base;
+        this.spec = spec;
+    }
+    as(alias) {
+        const clone = new WindowExpression(this.base, this.spec);
+        clone._alias = alias;
+        return clone;
+    }
+    over(spec) {
+        return new WindowExpression(this.base, mergeSpecs(this.spec, spec));
+    }
+    toSQL(options) {
+        const baseResult = this.base.toSQL(options);
+        const params = { ...baseResult.params };
+        const clause = buildWindowClause(this.spec, options, params);
+        return {
+            sql: `${baseResult.sql} OVER ${clause}`,
+            params
+        };
+    }
+    walk(visitor) {
+        const baseWalk = this.base.walk(visitor);
+        const walkExpr = (expr) => {
+            if (expr instanceof ClickHouseColumn) {
+                return expr.tableName ? `${expr.tableName}.${expr.name}` : expr.name;
+            }
+            return expr.walk(visitor);
+        };
+        const parts = [];
+        const spec = this.spec;
+        const partitions = normalizeArray(spec?.partitionBy);
+        if (partitions.length > 0) {
+            const partitionSql = partitions.map(part => walkExpr(part)).join(', ');
+            parts.push(`PARTITION BY ${partitionSql}`);
+        }
+        const orderings = normalizeArray(spec?.orderBy).map(order => {
+            if (order && typeof order === 'object' && 'col' in order) {
+                return { col: order.col, dir: order.dir };
+            }
+            return { col: order, dir: undefined };
+        });
+        if (orderings.length > 0) {
+            const orderSql = orderings
+                .map(order => {
+                const rendered = walkExpr(order.col);
+                return order.dir ? `${rendered} ${order.dir}` : rendered;
+            })
+                .join(', ');
+            parts.push(`ORDER BY ${orderSql}`);
+        }
+        const clause = parts.length === 0 ? '()' : `(${parts.join(' ')})`;
+        return `${baseWalk} OVER ${clause}`;
+    }
+}
+function mergeSpecs(current, next) {
+    if (!current && !next)
+        return undefined;
+    return {
+        partitionBy: next?.partitionBy ?? current?.partitionBy,
+        orderBy: next?.orderBy ?? current?.orderBy
+    };
+}
+function normalizeArray(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function formatColumn(col, options) {
+    if (options?.ignoreTablePrefix) {
+        return `\`${col.name}\``;
+    }
+    return col.tableName ? `\`${col.tableName}\`.\`${col.name}\`` : `\`${col.name}\``;
+}
+function renderExpr(expr, options, params) {
+    if (expr instanceof ClickHouseColumn) {
+        return formatColumn(expr, options);
+    }
+    const res = expr.toSQL(options);
+    Object.assign(params, res.params);
+    return res.sql;
+}
+function buildWindowClause(spec, options, params) {
+    const parts = [];
+    const partitions = normalizeArray(spec?.partitionBy);
+    if (partitions.length > 0) {
+        const partitionSql = partitions.map(part => renderExpr(part, options, params)).join(', ');
+        parts.push(`PARTITION BY ${partitionSql}`);
+    }
+    const orderings = normalizeArray(spec?.orderBy).map(order => {
+        if (order && typeof order === 'object' && 'col' in order) {
+            return { col: order.col, dir: order.dir };
+        }
+        return { col: order, dir: undefined };
+    });
+    if (orderings.length > 0) {
+        const orderSql = orderings
+            .map(order => {
+            const rendered = renderExpr(order.col, options, params);
+            return order.dir ? `${rendered} ${order.dir}` : rendered;
+        })
+            .join(', ');
+        parts.push(`ORDER BY ${orderSql}`);
+    }
+    if (parts.length === 0) {
+        return '()';
+    }
+    return `(${parts.join(' ')})`;
+}
+export function over(expr, spec) {
+    return new WindowExpression(expr, spec);
+}
+export function rowNumber(spec) {
+    return new WindowExpression(sql `row_number()`, spec);
+}
+export function rank(spec) {
+    return new WindowExpression(sql `rank()`, spec);
+}
+export function denseRank(spec) {
+    return new WindowExpression(sql `dense_rank()`, spec);
+}
+export function lag(col, offset = 1, defaultValue, spec) {
+    const base = defaultValue !== undefined
+        ? sql `lag(${col}, ${offset}, ${defaultValue})`
+        : sql `lag(${col}, ${offset})`;
+    return new WindowExpression(base, spec);
+}
+export function lead(col, offset = 1, defaultValue, spec) {
+    const base = defaultValue !== undefined
+        ? sql `lead(${col}, ${offset}, ${defaultValue})`
+        : sql `lead(${col}, ${offset})`;
+    return new WindowExpression(base, spec);
+}
+export const windowFns = { over, rowNumber, rank, denseRank, lag, lead };