@housekit/orm 0.1.47 → 0.1.48

package/dist/modules/geo.js

@@ -0,0 +1,112 @@
+import { sql } from '../expressions';
+export function geoDistance(point1, point2, unit = 'km') {
+    if (unit === 'mi') {
+        return sql `greatCircleDistance(${point1}, ${point2}) * 0.621371`;
+    }
+    return sql `greatCircleDistance(${point1}, ${point2})`;
+}
+export function greatCircleDistance(point1, point2) {
+    return sql `greatCircleDistance(${point1}, ${point2})`;
+}
+export function euclideanDistance(point1, point2) {
+    return sql `sqrt(pow(${point1}.1 - ${point2}.1, 2) + pow(${point1}.2 - ${point2}.2, 2))`;
+}
+export function manhattanDistance(point1, point2) {
+    return sql `abs(${point1}.1 - ${point2}.1) + abs(${point1}.2 - ${point2}.2)`;
+}
+export function geoPoint(longitude, latitude) {
+    return sql `(${longitude}, ${latitude})`;
+}
+export function geoLongitude(point) {
+    return sql `${point}.1`;
+}
+export function geoLatitude(point) {
+    return sql `${point}.2`;
+}
+export function geoX(point) {
+    return sql `${point}.1`;
+}
+export function geoY(point) {
+    return sql `${point}.2`;
+}
+export function pointInPolygon(point, polygon) {
+    return sql `pointInPolygon(${point}, ${polygon})`;
+}
+export function polygonContains(polygon1, polygon2) {
+    return sql `polygonContains(${polygon1}, ${polygon2})`;
+}
+export function polygonsIntersect(polygon1, polygon2) {
+    return sql `polygonsIntersect(${polygon1}, ${polygon2})`;
+}
+export function boundingBox(point1, point2) {
+    return sql `boundingBox(${point1}, ${point2})`;
+}
+export function pointInBoundingBox(point, bbox) {
+    return sql `pointInBoundingBox(${point}, ${bbox})`;
+}
+export function bboxMin(bbox) {
+    return sql `bboxMin(${bbox})`;
+}
+export function bboxMax(bbox) {
+    return sql `bboxMax(${bbox})`;
+}
+export function polygonArea(polygon) {
+    return sql `polygonArea(${polygon})`;
+}
+export function polygonPerimeter(polygon) {
+    return sql `polygonPerimeter(${polygon})`;
+}
+export function polygonCentroid(polygon) {
+    return sql `polygonCentroid(${polygon})`;
+}
+export function polygonSimplify(polygon, epsilon) {
+    return sql `polygonSimplify(${polygon}, ${epsilon})`;
+}
+export function polygonBuffer(polygon, distance) {
+    return sql `polygonBuffer(${polygon}, ${distance})`;
+}
+export function geoHashEncode(point, precision = 10) {
+    return sql `geoHashEncode(${point}, ${precision})`;
+}
+export function geoHashDecode(geohash) {
+    return sql `geoHashDecode(${geohash})`;
+}
+export function geoHashNeighbors(geohash) {
+    return sql `geoHashNeighbors(${geohash})`;
+}
+export function geoHashAreNeighbors(geohash1, geohash2) {
+    return sql `geoHashAreNeighbors(${geohash1}, ${geohash2})`;
+}
+export function pointsWithinRadius(center, radius, points) {
+    return sql `arrayFilter(x -> greatCircleDistance(${center}, x) <= ${radius}, ${points})`;
+}
+export function nearestNeighbors(point, points, k) {
+    return sql `arraySlice(arraySort(x -> greatCircleDistance(${point}, x), ${points}), 1, ${k})`;
+}
+export function kMeansClustering(points, k) {
+    return sql `kMeans(${points}, ${k})`;
+}
+export function degreesToRadians(degrees) {
+    return sql `radians(${degrees})`;
+}
+export function radiansToDegrees(radians) {
+    return sql `degrees(${radians})`;
+}
+export function webMercatorToWGS84(point) {
+    return sql `webMercatorToWGS84(${point})`;
+}
+export function wGS84ToWebMercator(point) {
+    return sql `wGS84ToWebMercator(${point})`;
+}
+export function isValidGeometry(geometry) {
+    return sql `isValidGeometry(${geometry})`;
+}
+export function geometryType(geometry) {
+    return sql `geometryType(${geometry})`;
+}
+export function geometryNumPoints(geometry) {
+    return sql `geometryNumPoints(${geometry})`;
+}
+export function polygonNumInteriorRings(polygon) {
+    return sql `polygonNumInteriorRings(${polygon})`;
+}

package/dist/modules/hash.js

@@ -0,0 +1,4 @@
+import { sql } from '../expressions';
+export const cityHash64 = (col) => sql `cityHash64(${col})`;
+export const md5 = (col) => sql `MD5(${col})`;
+export const sha256 = (col) => sql `SHA256(${col})`;

package/dist/modules/index.js

@@ -0,0 +1,12 @@
+export * from './array';
+export * from './json';
+export * from './geo';
+export * from './time';
+export * from './types';
+export * from './aggregates';
+export * from './conditional';
+export * from './conversion';
+export * from './string';
+export * from './math';
+export * from './hash';
+export * from './window';

package/dist/modules/json.d.ts

@@ -1,130 +1,24 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
 type Expr<T = any> = ClickHouseColumn<T, any, any> | SQLExpression<T>;
-/**
- * Extract string value from JSON
- * @param col - JSON column or expression
- * @param path - JSONPath expression (e.g., 'user.name', '$.items[0].price')
- */
 export declare function jsonExtractString(col: Expr, path: string): SQLExpression<string>;
-/**
- * Extract integer value from JSON
- * @param col - JSON column or expression
- * @param path - JSONPath expression (e.g., 'user.age', '$.count')
- */
 export declare function jsonExtractInt(col: Expr, path: string): SQLExpression<number>;
-/**
- * Extract float value from JSON
- * @param col - JSON column or expression
- * @param path - JSONPath expression (e.g., 'user.score', '$.price')
- */
 export declare function jsonExtractFloat(col: Expr, path: string): SQLExpression<number>;
-/**
- * Extract boolean value from JSON
- * @param col - JSON column or expression
- * @param path - JSONPath expression (e.g., 'user.active', '$.enabled')
- */
 export declare function jsonExtractBool(col: Expr, path: string): SQLExpression<boolean>;
-/**
- * Generic JSON extraction with type specification
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- * @param type - ClickHouse type literal (e.g., 'String', 'Int', 'Float', 'Bool', 'Array(String)')
- */
 export declare function jsonExtract(col: Expr, path: string, type: string): SQLExpression<any>;
-/**
- * Extract raw JSON value as string
- * Useful when you want to preserve the JSON structure
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- */
 export declare function jsonExtractRaw(col: Expr, path: string): SQLExpression<string>;
-/**
- * Check if JSON has a specific path
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- */
 export declare function jsonHas(col: Expr, path: string): SQLExpression<boolean>;
-/**
- * Extract all keys from JSON object at specified path
- * Useful for introspecting JSON blobs
- * @param col - JSON column or expression
- * @param path - JSONPath expression (optional, defaults to root)
- */
 export declare function jsonExtractKeys(col: Expr, path?: string): SQLExpression<any>;
-/**
- * Extract all values from JSON object at specified path
- * Useful for introspecting JSON blobs
- * @param col - JSON column or expression
- * @param path - JSONPath expression (optional, defaults to root)
- */
 export declare function jsonExtractValues(col: Expr, path?: string): SQLExpression<any>;
-/**
- * Extract keys and values as tuples from JSON object
- * Useful for introspecting JSON blobs
- * @param col - JSON column or expression
- * @param path - JSONPath expression (optional, defaults to root)
- */
 export declare function jsonExtractKeysAndValues(col: Expr, path?: string): SQLExpression<any>;
-/**
- * Get the length of JSON array or object
- * @param col - JSON column or expression
- * @param path - JSONPath expression (optional, defaults to root)
- */
 export declare function jsonLength(col: Expr, path?: string): SQLExpression<number>;
-/**
- * Get the type of JSON value at specified path
- * Returns: 'null', 'bool', 'number', 'string', 'array', 'object'
- * @param col - JSON column or expression
- * @param path - JSONPath expression (optional, defaults to root)
- */
 export declare function jsonType(col: Expr, path?: string): SQLExpression<string>;
-/**
- * Insert value into JSON at specified path
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- * @param value - Value to insert
- */
 export declare function jsonInsert(col: Expr, path: string, value: any): SQLExpression<any>;
-/**
- * Replace value in JSON at specified path
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- * @param value - Value to replace with
- */
 export declare function jsonReplace(col: Expr, path: string, value: any): SQLExpression<any>;
-/**
- * Remove value from JSON at specified path
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- */
 export declare function jsonRemove(col: Expr, path: string): SQLExpression<any>;
-/**
- * Parse string as JSON
- * @param col - String column or expression containing JSON
- */
 export declare function parseJSON(col: Expr): SQLExpression<any>;
-/**
- * Parse string as JSONBestEffort (more tolerant)
- * @param col - String column or expression containing JSON
- */
 export declare function parseJSONBestEffort(col: Expr): SQLExpression<any>;
-/**
- * Convert JSON to string
- * @param col - JSON column or expression
- */
 export declare function jsonStringify(col: Expr): SQLExpression<string>;
-/**
- * Extract JSON array as ClickHouse array
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- * @param type - ClickHouse type for array elements (e.g., 'String', 'Int')
- */
 export declare function jsonArrayExtract(col: Expr, path: string, type: string): SQLExpression<any>;
-/**
- * Get length of JSON array
- * @param col - JSON column or expression
- * @param path - JSONPath expression
- */
 export declare function jsonArrayLength(col: Expr, path: string): SQLExpression<number>;
 export {};

package/dist/modules/json.js

@@ -0,0 +1,76 @@
+import { sql } from '../expressions';
+export function jsonExtractString(col, path) {
+    return sql `JSONExtractString(${col}, ${path})`;
+}
+export function jsonExtractInt(col, path) {
+    return sql `JSONExtractInt(${col}, ${path})`;
+}
+export function jsonExtractFloat(col, path) {
+    return sql `JSONExtractFloat(${col}, ${path})`;
+}
+export function jsonExtractBool(col, path) {
+    return sql `JSONExtractBool(${col}, ${path})`;
+}
+export function jsonExtract(col, path, type) {
+    return sql `JSONExtract(${col}, ${path}, '${type}')`;
+}
+export function jsonExtractRaw(col, path) {
+    return sql `JSONExtractRaw(${col}, ${path})`;
+}
+export function jsonHas(col, path) {
+    return sql `JSONHas(${col}, ${path})`;
+}
+export function jsonExtractKeys(col, path) {
+    if (path) {
+        return sql `JSONKeys(${col}, ${path})`;
+    }
+    return sql `JSONKeys(${col})`;
+}
+export function jsonExtractValues(col, path) {
+    if (path) {
+        return sql `JSONValues(${col}, ${path})`;
+    }
+    return sql `JSONValues(${col})`;
+}
+export function jsonExtractKeysAndValues(col, path) {
+    if (path) {
+        return sql `JSONKeysAndValues(${col}, ${path})`;
+    }
+    return sql `JSONKeysAndValues(${col})`;
+}
+export function jsonLength(col, path) {
+    if (path) {
+        return sql `JSONLength(${col}, ${path})`;
+    }
+    return sql `JSONLength(${col})`;
+}
+export function jsonType(col, path) {
+    if (path) {
+        return sql `JSONType(${col}, ${path})`;
+    }
+    return sql `JSONType(${col})`;
+}
+export function jsonInsert(col, path, value) {
+    return sql `JSONInsert(${col}, ${path}, ${value})`;
+}
+export function jsonReplace(col, path, value) {
+    return sql `JSONReplace(${col}, ${path}, ${value})`;
+}
+export function jsonRemove(col, path) {
+    return sql `JSONRemove(${col}, ${path})`;
+}
+export function parseJSON(col) {
+    return sql `parseJSON(${col})`;
+}
+export function parseJSONBestEffort(col) {
+    return sql `parseJSONBestEffort(${col})`;
+}
+export function jsonStringify(col) {
+    return sql `JSONString(${col})`;
+}
+export function jsonArrayExtract(col, path, type) {
+    return sql `JSONArrayExtract(${col}, ${path}, '${type}')`;
+}
+export function jsonArrayLength(col, path) {
+    return sql `JSONArrayLength(${col}, ${path})`;
+}

package/dist/modules/math.d.ts

@@ -6,23 +6,7 @@ export declare const floor: (col: ClickHouseColumn | SQLExpression) => SQLExpres
 export declare const ceil: (col: ClickHouseColumn | SQLExpression) => SQLExpression<any>;
 export declare const sqrt: (col: ClickHouseColumn | SQLExpression) => SQLExpression<any>;
 export declare const power: (col: ClickHouseColumn | SQLExpression, exponent: number) => SQLExpression<any>;
-/**
- * ⚠️ Advanced: Low-value arithmetic wrapper.
- * Consider using `sql`${a} + ${b}`` directly.
- */
 export declare const plus: (a: ClickHouseColumn | SQLExpression | number, b: ClickHouseColumn | SQLExpression | number) => SQLExpression<any>;
-/**
- * ⚠️ Advanced: Low-value arithmetic wrapper.
- * Consider using `sql`${a} - ${b}`` directly.
- */
 export declare const minus: (a: ClickHouseColumn | SQLExpression | number, b: ClickHouseColumn | SQLExpression | number) => SQLExpression<any>;
-/**
- * ⚠️ Advanced: Low-value arithmetic wrapper.
- * Consider using `sql`${a} * ${b}`` directly.
- */
 export declare const mult: (a: ClickHouseColumn | SQLExpression | number, b: ClickHouseColumn | SQLExpression | number) => SQLExpression<any>;
-/**
- * ⚠️ Advanced: Low-value arithmetic wrapper.
- * Consider using `sql`${a} / ${b}`` directly.
- */
 export declare const div: (a: ClickHouseColumn | SQLExpression | number, b: ClickHouseColumn | SQLExpression | number) => SQLExpression<any>;

package/dist/modules/math.js

@@ -0,0 +1,16 @@
+import { sql } from '../expressions';
+export const abs = (col) => sql `abs(${col})`;
+export const round = (col, precision) => {
+    if (precision !== undefined) {
+        return sql `round(${col}, ${precision})`;
+    }
+    return sql `round(${col})`;
+};
+export const floor = (col) => sql `floor(${col})`;
+export const ceil = (col) => sql `ceil(${col})`;
+export const sqrt = (col) => sql `sqrt(${col})`;
+export const power = (col, exponent) => sql `power(${col}, ${exponent})`;
+export const plus = (a, b) => sql `${a} + ${b}`;
+export const minus = (a, b) => sql `${a} - ${b}`;
+export const mult = (a, b) => sql `${a} * ${b}`;
+export const div = (a, b) => sql `${a} / ${b}`;

package/dist/modules/string.d.ts

@@ -1,167 +1,31 @@
 import { ClickHouseColumn } from '../core';
 import { SQLExpression } from '../expressions';
-/**
- * Get string length
- * @param col - Column or expression
- */
 export declare function length(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Get string length in UTF-8 bytes
- * @param col - Column or expression
- */
 export declare function lengthUTF8(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to lowercase
- * @param col - Column or expression
- */
 export declare function lower(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Convert to uppercase
- * @param col - Column or expression
- */
 export declare function upper(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Reverse string
- * @param col - Column or expression
- */
 export declare function reverse(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Repeat string N times
- * @param col - Column or expression
- * @param n - Number of repetitions
- */
 export declare function repeat(col: ClickHouseColumn | SQLExpression, n: number): SQLExpression;
-/**
- * Get substring
- * @param col - Column or expression
- * @param offset - Starting position (1-based)
- * @param length - Length of substring
- */
 export declare function substring(col: ClickHouseColumn | SQLExpression, offset: number, length?: number): SQLExpression;
-/**
- * Get substring from left
- * @param col - Column or expression
- * @param length - Length from left
- */
 export declare function left(col: ClickHouseColumn | SQLExpression, length: number): SQLExpression;
-/**
- * Get substring from right
- * @param col - Column or expression
- * @param length - Length from right
- */
 export declare function right(col: ClickHouseColumn | SQLExpression, length: number): SQLExpression;
-/**
- * Trim whitespace from string
- * @param col - Column or expression
- */
 export declare function stringTrim(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Trim left whitespace
- * @param col - Column or expression
- */
 export declare function stringTrimLeft(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Trim right whitespace
- * @param col - Column or expression
- */
 export declare function stringTrimRight(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Check if string contains substring
- * @param col - Column or expression
- * @param substring - Substring to search for
- */
 export declare function contains(col: ClickHouseColumn | SQLExpression, substring: string): SQLExpression;
-/**
- * Check if string starts with substring
- * @param col - Column or expression
- * @param substring - Substring to check
- */
 export declare function startsWith(col: ClickHouseColumn | SQLExpression, substring: string): SQLExpression;
-/**
- * Check if string ends with substring
- * @param col - Column or expression
- * @param substring - Substring to check
- */
 export declare function endsWith(col: ClickHouseColumn | SQLExpression, substring: string): SQLExpression;
-/**
- * Find position of substring
- * @param col - Column or expression
- * @param substring - Substring to find
- */
 export declare function position(col: ClickHouseColumn | SQLExpression, substring: string): SQLExpression;
-/**
- * Count occurrences of substring
- * @param col - Column or expression
- * @param substring - Substring to count
- */
 export declare function countMatches(col: ClickHouseColumn | SQLExpression, substring: string): SQLExpression;
-/**
- * Concatenate strings
- * @param cols - Strings to concatenate
- */
 export declare function concat(...cols: (ClickHouseColumn | SQLExpression | string)[]): SQLExpression;
-/**
- * Replace all occurrences of substring
- * @param col - Column or expression
- * @param pattern - Pattern to replace
- * @param replacement - Replacement string
- */
 export declare function replace(col: ClickHouseColumn | SQLExpression, pattern: string, replacement: string): SQLExpression;
-/**
- * Replace using regex
- * @param col - Column or expression
- * @param pattern - Regex pattern
- * @param replacement - Replacement string
- */
 export declare function replaceRegexpAll(col: ClickHouseColumn | SQLExpression, pattern: string, replacement: string): SQLExpression;
-/**
- * Match using regex (returns 1 if matches, 0 if not)
- * @param col - Column or expression
- * @param pattern - Regex pattern
- */
 export declare function match(col: ClickHouseColumn | SQLExpression, pattern: string): SQLExpression;
-/**
- * Check if string matches pattern (LIKE)
- * @param col - Column or expression
- * @param pattern - Pattern to match
- */
 export declare function like(col: ClickHouseColumn | SQLExpression, pattern: string): SQLExpression;
-/**
- * Check if string matches pattern (NOT LIKE)
- * @param col - Column or expression
- * @param pattern - Pattern to match
- */
 export declare function notLike(col: ClickHouseColumn | SQLExpression, pattern: string): SQLExpression;
-/**
- * Check if string matches pattern (ILIKE - case insensitive)
- * @param col - Column or expression
- * @param pattern - Pattern to match
- */
 export declare function ilike(col: ClickHouseColumn | SQLExpression, pattern: string): SQLExpression;
-/**
- * Check if string matches pattern (NOT ILIKE)
- * @param col - Column or expression
- * @param pattern - Pattern to match
- */
 export declare function notIlike(col: ClickHouseColumn | SQLExpression, pattern: string): SQLExpression;
-/**
- * Calculate SHA1 hash
- * @param col - Column or expression
- */
 export declare function sha1(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Calculate SIP hash
- * @param col - Column or expression
- */
 export declare function sipHash64(col: ClickHouseColumn | SQLExpression): SQLExpression;
-/**
- * Split string by delimiter
- * @param col - Column or expression
- * @param delimiter - Delimiter string
- */
 export declare function splitByChar(col: ClickHouseColumn | SQLExpression, delimiter: string): SQLExpression;
-/**
- * Split string by whitespace
- * @param col - Column or expression
- */
 export declare function splitByWhitespace(col: ClickHouseColumn | SQLExpression): SQLExpression;

package/dist/modules/string.js

@@ -0,0 +1,89 @@
+import { sql } from '../expressions';
+export function length(col) {
+    return sql `length(${col})`;
+}
+export function lengthUTF8(col) {
+    return sql `lengthUTF8(${col})`;
+}
+export function lower(col) {
+    return sql `lower(${col})`;
+}
+export function upper(col) {
+    return sql `upper(${col})`;
+}
+export function reverse(col) {
+    return sql `reverse(${col})`;
+}
+export function repeat(col, n) {
+    return sql `repeat(${col}, ${n})`;
+}
+export function substring(col, offset, length) {
+    return length ? sql `substring(${col}, ${offset}, ${length})` : sql `substring(${col}, ${offset})`;
+}
+export function left(col, length) {
+    return sql `left(${col}, ${length})`;
+}
+export function right(col, length) {
+    return sql `right(${col}, ${length})`;
+}
+export function stringTrim(col) {
+    return sql `trim(${col})`;
+}
+export function stringTrimLeft(col) {
+    return sql `trimLeft(${col})`;
+}
+export function stringTrimRight(col) {
+    return sql `trimRight(${col})`;
+}
+export function contains(col, substring) {
+    return sql `contains(${col}, ${substring})`;
+}
+export function startsWith(col, substring) {
+    return sql `startsWith(${col}, ${substring})`;
+}
+export function endsWith(col, substring) {
+    return sql `endsWith(${col}, ${substring})`;
+}
+export function position(col, substring) {
+    return sql `position(${substring}, ${col})`;
+}
+export function countMatches(col, substring) {
+    return sql `countMatches(${col}, ${substring})`;
+}
+export function concat(...cols) {
+    const params = cols.map(col => sql `${col}`).join(', ');
+    return sql `concat(${params})`;
+}
+export function replace(col, pattern, replacement) {
+    return sql `replace(${col}, ${pattern}, ${replacement})`;
+}
+export function replaceRegexpAll(col, pattern, replacement) {
+    return sql `replaceRegexpAll(${col}, ${pattern}, ${replacement})`;
+}
+export function match(col, pattern) {
+    return sql `match(${col}, ${pattern})`;
+}
+export function like(col, pattern) {
+    return sql `${col} LIKE ${pattern}`;
+}
+export function notLike(col, pattern) {
+    return sql `${col} NOT LIKE ${pattern}`;
+}
+export function ilike(col, pattern) {
+    return sql `${col} ILIKE ${pattern}`;
+}
+export function notIlike(col, pattern) {
+    return sql `${col} NOT ILIKE ${pattern}`;
+}
+export function sha1(col) {
+    return sql `sha1(${col})`;
+}
+export function sipHash64(col) {
+    return sql `sipHash64(${col})`;
+}
+export function splitByChar(col, delimiter) {
+    return sql `splitByChar(${col}, ${delimiter})`;
+}
+export function splitByWhitespace(col) {
+    return sql `splitByWhitespace(${col})`;
+}