@housekit/orm 0.1.46 → 0.1.48

package/dist/modules/conditional.js

@@ -0,0 +1,138 @@
+import { sql, SQL } from '../expressions';
+export function ifNull(col, alt) {
+    return sql `ifNull(${col}, ${alt})`;
+}
+export function sqlIf(condition, trueVal, falseVal) {
+    return sql `if(${condition}, ${trueVal}, ${falseVal})`;
+}
+export function multiIf(...args) {
+    if (args.length < 3) {
+        throw new Error('multiIf requires at least 3 arguments: condition, value, default');
+    }
+    if (args.length % 2 === 0) {
+        throw new Error('multiIf requires an odd number of arguments: condition-value pairs plus a default value');
+    }
+    const params = args.map(arg => sql `${arg}`).join(', ');
+    return sql `multiIf(${params})`;
+}
+export function caseWhen() {
+    return new CaseWhenBuilder();
+}
+class CaseWhenBuilder {
+    conditions = [];
+    values = [];
+    defaultValue;
+    when(condition, value) {
+        this.conditions.push(condition);
+        this.values.push(value);
+        return this;
+    }
+    otherwise(value) {
+        this.defaultValue = value;
+        return this.build();
+    }
+    build() {
+        if (!this.defaultValue) {
+            throw new Error('CaseWhenBuilder requires a default value via .otherwise()');
+        }
+        const args = [];
+        for (let i = 0; i < this.conditions.length; i++) {
+            args.push(this.conditions[i]);
+            args.push(this.values[i]);
+        }
+        args.push(this.defaultValue);
+        return multiIf(...args);
+    }
+}
+export function coalesce(...args) {
+    const chunks = ['coalesce('];
+    const params = [];
+    args.forEach((arg, i) => {
+        params.push(arg);
+        if (i < args.length - 1) {
+            chunks.push(', ');
+        }
+    });
+    chunks.push(')');
+    return new SQL(chunks, params);
+}
+export function greatest(...args) {
+    const chunks = ['greatest('];
+    const params = [];
+    args.forEach((arg, i) => {
+        params.push(arg);
+        if (i < args.length - 1) {
+            chunks.push(', ');
+        }
+    });
+    chunks.push(')');
+    return new SQL(chunks, params);
+}
+export function least(...args) {
+    const chunks = ['least('];
+    const params = [];
+    args.forEach((arg, i) => {
+        params.push(arg);
+        if (i < args.length - 1) {
+            chunks.push(', ');
+        }
+    });
+    chunks.push(')');
+    return new SQL(chunks, params);
+}
+export function isNull(col) {
+    return sql `${col} IS NULL`;
+}
+export function isNotNull(col) {
+    return sql `${col} IS NOT NULL`;
+}
+export function nullIf(condition, col) {
+    return sql `nullIf(${col}, ${condition})`;
+}
+export function nullIfEqual(col, value) {
+    return sql `nullIf(${col}, ${value})`;
+}
+export function not(expr) {
+    return sql `NOT (${expr})`;
+}
+export function and(...exprs) {
+    const filtered = exprs.filter((e) => !!e);
+    if (filtered.length === 0)
+        return undefined;
+    if (filtered.length === 1)
+        return filtered[0];
+    const finalChunks = ['('];
+    const finalParams = [];
+    filtered.forEach((e, i) => {
+        finalParams.push(e);
+        if (i < filtered.length - 1) {
+            finalChunks.push(') AND (');
+        }
+        else {
+            finalChunks.push(')');
+        }
+    });
+    return new SQL(finalChunks, finalParams);
+}
+export function or(...exprs) {
+    const filtered = exprs.filter((e) => !!e);
+    if (filtered.length === 0)
+        return undefined;
+    if (filtered.length === 1)
+        return filtered[0];
+    const finalChunks = ['('];
+    const finalParams = [];
+    filtered.forEach((e, i) => {
+        finalParams.push(e);
+        if (i < filtered.length - 1) {
+            finalChunks.push(') OR (');
+        }
+        else {
+            finalChunks.push(')');
+        }
+    });
+    return new SQL(finalChunks, finalParams);
+}
+export function xor(expr1, expr2) {
+    return sql `xor(${expr1}, ${expr2})`;
+}

package/dist/modules/conversion.d.ts

@@ -1,189 +1,42 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
 type Expr<T = any> = ClickHouseColumn<T, any, any> | SQLExpression<T>;
-/**
- * Convert to string
- * @param col - Column or expression to convert
- */
 export declare function toString(col: Expr): SQLExpression<string>;
 export declare function toInt32(col: Expr): SQLExpression<number>;
-/**
- * Convert to integer (alias for toInt32)
- */
 export declare const toInteger: typeof toInt32;
-/**
- * Convert to 64-bit integer
- * @param col - Column or expression to convert
- */
 export declare function toInt64(col: Expr): SQLExpression<number>;
-/**
- * Convert to 32-bit unsigned integer
- * @param col - Column or expression to convert
- */
 export declare function toUInt32(col: Expr): SQLExpression<number>;
-/**
- * Convert to 64-bit unsigned integer
- * @param col - Column or expression to convert
- */
 export declare function toUInt64(col: Expr): SQLExpression<number>;
-/**
- * Convert to 32-bit float
- * @param col - Column or expression to convert
- */
 export declare function toFloat32(col: Expr): SQLExpression<number>;
-/**
- * Convert to 64-bit float
- * @param col - Column or expression to convert
- */
 export declare function toFloat64(col: Expr): SQLExpression<number>;
 export declare function toBool(col: Expr): SQLExpression<boolean>;
-/**
- * Convert to boolean (alias for toBool)
- */
 export declare const toBoolean: typeof toBool;
-/**
- * Convert to UUID
- * @param col - Column or expression to convert
- */
 export declare function toUUID(col: Expr): SQLExpression<string>;
-/**
- * Convert to Date type (without time)
- * @param col - Column or expression to convert
- */
 export declare function toDate(col: Expr): SQLExpression<string>;
 export declare function toDateTime(col: Expr): SQLExpression<string>;
-/**
- * Convert to timestamp (alias for toDateTime)
- */
 export declare const toTimestamp: typeof toDateTime;
-/**
- * Convert to DateTime64 type
- * @param col - Column or expression to convert
- * @param precision - DateTime precision (default: 3)
- */
 export declare function toDateTime64(col: Expr, precision?: number): SQLExpression<string>;
-/**
- * Convert to lowercase
- * @param col - Column or expression to convert
- */
 export declare function toLowercase(col: Expr): SQLExpression<string>;
-/**
- * Convert to uppercase
- * @param col - Column or expression to convert
- */
 export declare function toUppercase(col: Expr): SQLExpression<string>;
-/**
- * Convert to title case (first letter uppercase, rest lowercase)
- * @param col - Column or expression to convert
- */
 export declare function toTitleCase(col: Expr): SQLExpression<string>;
-/**
- * Trim whitespace from string
- * @param col - Column or expression to trim
- */
 export declare function convertTrim(col: Expr): SQLExpression<string>;
-/**
- * Trim left whitespace
- * @param col - Column or expression to trim
- */
 export declare function convertTrimLeft(col: Expr): SQLExpression<string>;
-/**
- * Trim right whitespace
- * @param col - Column or expression to trim
- */
 export declare function convertTrimRight(col: Expr): SQLExpression<string>;
-/**
- * Left pad string
- * @param col - Column or expression to pad
- * @param length - Target length
- * @param fill - Fill character (default: space)
- */
 export declare function leftPad(col: Expr, length: number, fill?: string): SQLExpression<string>;
-/**
- * Right pad string
- * @param col - Column or expression to pad
- * @param length - Target length
- * @param fill - Fill character (default: space)
- */
 export declare function rightPad(col: Expr, length: number, fill?: string): SQLExpression<string>;
-/**
- * Convert to hexadecimal string
- * @param col - Column or expression to convert
- */
 export declare function toHex(col: Expr): SQLExpression<string>;
-/**
- * Convert from hexadecimal string
- * @param col - Column or expression to convert
- */
 export declare function fromHex(col: Expr): SQLExpression<string>;
-/**
- * Convert to base64 string
- * @param col - Column or expression to convert
- */
 export declare function toBase64(col: Expr): SQLExpression<string>;
-/**
- * Convert from base64 string
- * @param col - Column or expression to convert
- */
 export declare function fromBase64(col: Expr): SQLExpression<string>;
-/**
- * Convert to binary string
- * @param col - Column or expression to convert
- */
 export declare function toBin(col: Expr): SQLExpression<string>;
-/**
- * Convert from binary string
- * @param col - Column or expression to convert
- */
 export declare function fromBin(col: Expr): SQLExpression<string>;
-/**
- * URL encode string
- * @param col - Column or expression to encode
- */
 export declare function urlEncode(col: Expr): SQLExpression<string>;
-/**
- * URL decode string
- * @param col - Column or expression to decode
- */
 export declare function urlDecode(col: Expr): SQLExpression<string>;
-/**
- * HTML escape string
- * @param col - Column or expression to escape
- */
 export declare function htmlEscape(col: Expr): SQLExpression<string>;
-/**
- * HTML unescape string
- * @param col - Column or expression to unescape
- */
 export declare function htmlUnescape(col: Expr): SQLExpression<string>;
-/**
- * Format number with specified decimal places
- * @param col - Column or expression to format
- * @param precision - Number of decimal places
- */
 export declare function formatDecimal(col: Expr, precision: number): SQLExpression<string>;
-/**
- * Format number in human-readable format
- * @param col - Column or expression to format
- * @param precision - Number of decimal places
- */
 export declare function formatReadableDecimal(col: Expr, precision: number): SQLExpression<string>;
-/**
- * Format number with specified number of digits
- * @param col - Column or expression to format
- * @param digits - Total number of digits
- */
 export declare function formatNumber(col: Expr, digits: number): SQLExpression<string>;
-/**
- * Format bytes in human-readable format
- * @param col - Column or expression to format
- * @param precision - Number of decimal places
- */
 export declare function formatBytes(col: Expr, precision?: number): SQLExpression<string>;
-/**
- * Format percentage
- * @param col - Column or expression to format
- * @param precision - Number of decimal places
- */
 export declare function formatPercentage(col: Expr, precision?: number): SQLExpression<string>;
 export {};

package/dist/modules/conversion.js

@@ -0,0 +1,109 @@
+import { sql } from '../expressions';
+export function toString(col) {
+    return sql `toString(${col})`;
+}
+export function toInt32(col) {
+    return sql `toInt32(${col})`;
+}
+export const toInteger = toInt32;
+export function toInt64(col) {
+    return sql `toInt64(${col})`;
+}
+export function toUInt32(col) {
+    return sql `toUInt32(${col})`;
+}
+export function toUInt64(col) {
+    return sql `toUInt64(${col})`;
+}
+export function toFloat32(col) {
+    return sql `toFloat32(${col})`;
+}
+export function toFloat64(col) {
+    return sql `toFloat64(${col})`;
+}
+export function toBool(col) {
+    return sql `toBool(${col})`;
+}
+export const toBoolean = toBool;
+export function toUUID(col) {
+    return sql `toUUID(${col})`;
+}
+export function toDate(col) {
+    return sql `toDate(${col})`;
+}
+export function toDateTime(col) {
+    return sql `toDateTime(${col})`;
+}
+export const toTimestamp = toDateTime;
+export function toDateTime64(col, precision = 3) {
+    return sql `toDateTime64(${col}, ${precision})`;
+}
+export function toLowercase(col) {
+    return sql `toLowercase(${col})`;
+}
+export function toUppercase(col) {
+    return sql `toUppercase(${col})`;
+}
+export function toTitleCase(col) {
+    return sql `toTitleCase(${col})`;
+}
+export function convertTrim(col) {
+    return sql `trim(${col})`;
+}
+export function convertTrimLeft(col) {
+    return sql `trimLeft(${col})`;
+}
+export function convertTrimRight(col) {
+    return sql `trimRight(${col})`;
+}
+export function leftPad(col, length, fill = ' ') {
+    return sql `leftPad(${col}, ${length}, ${fill})`;
+}
+export function rightPad(col, length, fill = ' ') {
+    return sql `rightPad(${col}, ${length}, ${fill})`;
+}
+export function toHex(col) {
+    return sql `toHex(${col})`;
+}
+export function fromHex(col) {
+    return sql `fromHex(${col})`;
+}
+export function toBase64(col) {
+    return sql `toBase64(${col})`;
+}
+export function fromBase64(col) {
+    return sql `fromBase64(${col})`;
+}
+export function toBin(col) {
+    return sql `toBin(${col})`;
+}
+export function fromBin(col) {
+    return sql `fromBin(${col})`;
+}
+export function urlEncode(col) {
+    return sql `urlEncode(${col})`;
+}
+export function urlDecode(col) {
+    return sql `urlDecode(${col})`;
+}
+export function htmlEscape(col) {
+    return sql `htmlEscape(${col})`;
+}
+export function htmlUnescape(col) {
+    return sql `htmlUnescape(${col})`;
+}
+export function formatDecimal(col, precision) {
+    return sql `formatDecimal(${col}, ${precision})`;
+}
+export function formatReadableDecimal(col, precision) {
+    return sql `formatReadableDecimal(${col}, ${precision})`;
+}
+export function formatNumber(col, digits) {
+    return sql `formatNumber(${col}, ${digits})`;
+}
+export function formatBytes(col, precision = 2) {
+    return sql `formatBytes(${col}, ${precision})`;
+}
+export function formatPercentage(col, precision = 2) {
+    return sql `formatPercentage(${col}, ${precision})`;
+}

package/dist/modules/geo.d.ts

@@ -1,202 +1,38 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Calculate great circle distance between two points using Haversine formula
- * @param point1 - First point (longitude, latitude)
- * @param point2 - Second point (longitude, latitude)
- * @param unit - Distance unit ('km' or 'mi')
- */
 export declare function geoDistance(point1: ClickHouseColumn | SQLExpression, point2: ClickHouseColumn | SQLExpression, unit?: 'km' | 'mi'): SQLExpression;
-/**
- * Calculate great circle distance between two points (ClickHouse native)
- * @param point1 - First point (longitude, latitude)
- * @param point2 - Second point (longitude, latitude)
- */
 export declare function greatCircleDistance(point1: ClickHouseColumn | SQLExpression, point2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Calculate distance between two points using Euclidean distance
- * @param point1 - First point (x, y)
- * @param point2 - Second point (x, y)
- */
 export declare function euclideanDistance(point1: ClickHouseColumn | SQLExpression, point2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Calculate Manhattan distance between two points
- * @param point1 - First point (x, y)
- * @param point2 - Second point (x, y)
- */
 export declare function manhattanDistance(point1: ClickHouseColumn | SQLExpression, point2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Create a point from longitude and latitude
- * @param longitude - Longitude coordinate
- * @param latitude - Latitude coordinate
- */
 export declare function geoPoint(longitude: ClickHouseColumn | SQLExpression | number, latitude: ClickHouseColumn | SQLExpression | number): SQLExpression;
-/**
- * Extract longitude from point
- * @param point - Point column or expression
- */
 export declare function geoLongitude(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract latitude from point
- * @param point - Point column or expression
- */
 export declare function geoLatitude(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract x coordinate from point
- * @param point - Point column or expression
- */
 export declare function geoX(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Extract y coordinate from point
- * @param point - Point column or expression
- */
 export declare function geoY(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if point is within polygon
- * @param point - Point to check
- * @param polygon - Polygon to check against
- */
 export declare function pointInPolygon(point: ClickHouseColumn | SQLExpression, polygon: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if polygon contains another polygon
- * @param polygon1 - First polygon
- * @param polygon2 - Second polygon
- */
 export declare function polygonContains(polygon1: ClickHouseColumn | SQLExpression, polygon2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if two polygons intersect
- * @param polygon1 - First polygon
- * @param polygon2 - Second polygon
- */
 export declare function polygonsIntersect(polygon1: ClickHouseColumn | SQLExpression, polygon2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Create a bounding box from two points (bottom-left and top-right)
- * @param point1 - Bottom-left point
- * @param point2 - Top-right point
- */
 export declare function boundingBox(point1: ClickHouseColumn | SQLExpression, point2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if point is within bounding box
- * @param point - Point to check
- * @param bbox - Bounding box
- */
 export declare function pointInBoundingBox(point: ClickHouseColumn | SQLExpression, bbox: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the minimum point of a bounding box
- * @param bbox - Bounding box
- */
 export declare function bboxMin(bbox: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the maximum point of a bounding box
- * @param bbox - Bounding box
- */
 export declare function bboxMax(bbox: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Calculate area of a polygon
- * @param polygon - Polygon column or expression
- */
 export declare function polygonArea(polygon: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Calculate perimeter of a polygon
- * @param polygon - Polygon column or expression
- */
 export declare function polygonPerimeter(polygon: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the centroid of a polygon
- * @param polygon - Polygon column or expression
- */
 export declare function polygonCentroid(polygon: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Simplify a polygon (reduce number of points)
- * @param polygon - Polygon to simplify
- * @param epsilon - Simplification tolerance
- */
 export declare function polygonSimplify(polygon: ClickHouseColumn | SQLExpression, epsilon: number): SQLExpression;
-/**
- * Buffer a polygon (expand/contract by distance)
- * @param polygon - Polygon to buffer
- * @param distance - Buffer distance
- */
 export declare function polygonBuffer(polygon: ClickHouseColumn | SQLExpression, distance: number): SQLExpression;
-/**
- * Encode a point as geohash
- * @param point - Point to encode
- * @param precision - Geohash precision (1-12)
- */
 export declare function geoHashEncode(point: ClickHouseColumn | SQLExpression, precision?: number): SQLExpression;
-/**
- * Decode a geohash to a point
- * @param geohash - Geohash string to decode
- */
 export declare function geoHashDecode(geohash: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get neighbors of a geohash
- * @param geohash - Geohash string
- */
 export declare function geoHashNeighbors(geohash: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if two geohashes are neighbors
- * @param geohash1 - First geohash
- * @param geohash2 - Second geohash
- */
 export declare function geoHashAreNeighbors(geohash1: ClickHouseColumn | SQLExpression, geohash2: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Find points within radius of a center point
- * @param center - Center point
- * @param radius - Search radius
- * @param points - Points to search
- */
 export declare function pointsWithinRadius(center: ClickHouseColumn | SQLExpression, radius: number, points: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Find nearest neighbors to a point
- * @param point - Reference point
- * @param points - Array of points to search
- * @param k - Number of neighbors to find
- */
 export declare function nearestNeighbors(point: ClickHouseColumn | SQLExpression, points: ClickHouseColumn | SQLExpression, k: number): SQLExpression;
-/**
- * Cluster points using k-means
- * @param points - Array of points to cluster
- * @param k - Number of clusters
- */
 export declare function kMeansClustering(points: ClickHouseColumn | SQLExpression, k: number): SQLExpression;
-/**
- * Convert degrees to radians
- * @param degrees - Degrees value
- */
 export declare function degreesToRadians(degrees: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert radians to degrees
- * @param radians - Radians value
- */
 export declare function radiansToDegrees(radians: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert Web Mercator to WGS84
- * @param point - Point in Web Mercator coordinates
- */
 export declare function webMercatorToWGS84(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert WGS84 to Web Mercator
- * @param point - Point in WGS84 coordinates
- */
 export declare function wGS84ToWebMercator(point: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if a geometry is valid
- * @param geometry - Geometry to validate
- */
 export declare function isValidGeometry(geometry: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the geometry type
- * @param geometry - Geometry column or expression
- */
 export declare function geometryType(geometry: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the number of points in a geometry
- * @param geometry - Geometry column or expression
- */
 export declare function geometryNumPoints(geometry: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get the number of interior rings in a polygon
- * @param polygon - Polygon column or expression
- */
 export declare function polygonNumInteriorRings(polygon: ClickHouseColumn | SQLExpression): SQLExpression;