@based/db 0.0.14 → 0.0.16

package/dist/lib/darwin_aarch64/include/selva/hll.h

@@ -8,13 +8,14 @@
 #include <stdbool.h>
 #include "cdefs.h"
 
+#define HLL_INIT_SIZE 8
 
 SELVA_EXPORT
 void hll_init(struct selva_string *hllss, uint8_t precision, bool is_sparse);
 SELVA_EXPORT
 void hll_add(struct selva_string *hllss, uint64_t element);
 SELVA_EXPORT
-double hll_count(struct selva_string *hllss);
+uint8_t *hll_count(struct selva_string *hllss);
 SELVA_EXPORT
 struct selva_string hll_array_union(struct selva_string *hll_array, size_t count);
 

package/dist/lib/linux_aarch64/include/selva/hll.h

@@ -8,13 +8,14 @@
 #include <stdbool.h>
 #include "cdefs.h"
 
+#define HLL_INIT_SIZE 8
 
 SELVA_EXPORT
 void hll_init(struct selva_string *hllss, uint8_t precision, bool is_sparse);
 SELVA_EXPORT
 void hll_add(struct selva_string *hllss, uint64_t element);
 SELVA_EXPORT
-double hll_count(struct selva_string *hllss);
+uint8_t *hll_count(struct selva_string *hllss);
 SELVA_EXPORT
 struct selva_string hll_array_union(struct selva_string *hll_array, size_t count);
 

package/dist/lib/linux_x86_64/include/selva/hll.h

@@ -8,13 +8,14 @@
 #include <stdbool.h>
 #include "cdefs.h"
 
+#define HLL_INIT_SIZE 8
 
 SELVA_EXPORT
 void hll_init(struct selva_string *hllss, uint8_t precision, bool is_sparse);
 SELVA_EXPORT
 void hll_add(struct selva_string *hllss, uint64_t element);
 SELVA_EXPORT
-double hll_count(struct selva_string *hllss);
+uint8_t *hll_count(struct selva_string *hllss);
 SELVA_EXPORT
 struct selva_string hll_array_union(struct selva_string *hll_array, size_t count);
 

package/dist/src/client/bitWise.js

@@ -79,4 +79,5 @@ export const concatUint8Arr = (arrs) => {
     });
     return result;
 };
+const textDecoder = new TextDecoder('utf-8');
 //# sourceMappingURL=bitWise.js.map

package/dist/src/client/modify/cardinality.js

@@ -17,25 +17,24 @@ export function writeHll(value, ctx, def, t, parentId, modifyOp) {
 }
 function addHll(value, ctx, def, t, parentId, modifyOp) {
     const len = value.length;
-    let size = 2 + len * 8;
+    let size = 4 + len * 8;
     if (ctx.len + size + 11 > ctx.max) {
         return RANGE_ERR;
     }
     setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
     ctx.buf[ctx.len++] = modifyOp;
-    ctx.buf.writeUint16LE(len, ctx.len);
-    ctx.len += 2;
+    ctx.buf.writeUint32LE(len, ctx.len);
+    ctx.len += 4;
     for (let val of value) {
-        let b;
         if (typeof val === 'string') {
-            b = Buffer.from(val);
+            xxHash64(Buffer.from(val), ctx.buf, ctx.len);
         }
-        else if (!(val instanceof Buffer)) {
-            b = val;
+        else if (val instanceof Buffer && val.byteLength === 8) {
+            ctx.buf.set(val, ctx.len);
+        }
+        else {
             return new ModifyError(t, val);
         }
-        const hash = xxHash64(b);
-        ctx.buf.writeBigUInt64LE(hash, ctx.len);
         ctx.len += 8;
     }
 }

package/dist/src/client/query/BasedDbQuery.d.ts

@@ -14,9 +14,9 @@ export declare class QueryBranch<T> {
     constructor(db: DbClient, def: QueryDef);
     sort(field: string, order?: 'asc' | 'desc'): T;
     filter<O extends Operator>(field: string, operator?: O | boolean, value?: any, opts?: FilterOpts<O>): T;
+    filterBatch(f: FilterAst): this;
     search(query: string, ...fields: Search[]): T;
     search(query: ArrayBufferView, field: string, opts?: Omit<FilterOpts, 'lowerCase'>): T;
-    filterBatch(f: FilterAst): this;
     or(fn: FilterBranchFn): T;
     or(field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts): T;
     range(offset: number, limit: number): T;

package/dist/src/client/query/BasedDbQuery.js

@@ -1,4 +1,4 @@
-import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, convertFilter, isAlias, includeField, includeFields, } from './query.js';
+import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, isAlias, includeField, includeFields, } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
 import { FilterBranch } from './filter/FilterBranch.js';
@@ -8,6 +8,7 @@ import { REFERENCE, REFERENCES } from '../../server/schema/types.js';
 import { subscribe } from './subscription/index.js';
 import { registerQuery } from './registerQuery.js';
 import { langCodesMap } from '@based/schema';
+import { convertFilter } from './filter/convertFilter.js';
 export class QueryBranch {
     db;
     def;
@@ -22,6 +23,15 @@ export class QueryBranch {
     }
     filter(field, operator, value, opts) {
         const f = convertFilter(this.def, field, operator, value, opts);
+        if (!f) {
+            // @ts-ignore
+            return this;
+        }
+        filter(this.db, this.def, f, this.def.filter);
+        // @ts-ignore
+        return this;
+    }
+    filterBatch(f) {
         filter(this.db, this.def, f, this.def.filter);
         // @ts-ignore
         return this;
@@ -81,11 +91,6 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    filterBatch(f) {
-        filter(this.db, this.def, f, this.def.filter);
-        // @ts-ignore
-        return this;
-    }
     or(field, operator, value, opts) {
         if (typeof field === 'function') {
             const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), this.def);
@@ -94,7 +99,9 @@ export class QueryBranch {
         }
         else {
             const f = convertFilter(this.def, field, operator, value, opts);
-            filterOr(this.db, this.def, f, this.def.filter);
+            if (f) {
+                filterOr(this.db, this.def, f, this.def.filter);
+            }
         }
         // @ts-ignore
         return this;

package/dist/src/client/query/display.js

@@ -1,5 +1,5 @@
 import picocolors from 'picocolors';
-import { BINARY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '../../server/schema/types.js';
+import { BINARY, CARDINALITY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '../../server/schema/types.js';
 const decimals = (v) => ~~(v * 100) / 100;
 const sizeCalc = (size) => {
     if (size > 1e6) {
@@ -59,6 +59,9 @@ const prettyPrintVal = (v, type) => {
             return `"${v}"`;
         }
     }
+    if (type === CARDINALITY) {
+        return `${picocolors.blue(v)} ${picocolors.italic(picocolors.dim('unique'))}`;
+    }
     if (type === TIMESTAMP) {
         if (v === 0) {
             return `0 ${picocolors.italic(picocolors.dim('No date'))}`;
@@ -100,8 +103,10 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
             // skip
         }
         else if (key === 'id') {
-            // @ts-ignore
-            str += v + picocolors.italic(picocolors.dim(` ${q.target.type}`));
+            str +=
+                picocolors.blue(v) +
+                    // @ts-ignore
+                    picocolors.italic(picocolors.dim(` ${q.target.type}`));
             str += ',\n';
         }
         else if (!def) {
@@ -146,6 +151,9 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
                 }
                 str += prettyPrintVal(v, def.typeIndex);
             }
+            else if (def.typeIndex === CARDINALITY) {
+                str += prettyPrintVal(v, def.typeIndex);
+            }
             else if (def.typeIndex === TIMESTAMP) {
                 str += prettyPrintVal(v, def.typeIndex);
             }

package/dist/src/client/query/filter/FilterBranch.js

@@ -1,4 +1,5 @@
-import { convertFilter, filter, filterOr } from './filter.js';
+import { filter, filterOr } from './filter.js';
+import { convertFilter } from './convertFilter.js';
 export class FilterBranch {
     constructor(db, filterBranch, def) {
         this.def = def;
@@ -16,13 +17,17 @@ export class FilterBranch {
         }
         else {
             const f = convertFilter(this.def, field, operator, value, opts);
-            filterOr(this.db, this.def, f, this.filterBranch);
+            if (f) {
+                filterOr(this.db, this.def, f, this.filterBranch);
+            }
         }
         return this;
     }
     filter(field, operator, value) {
         const f = convertFilter(this.def, field, operator, value);
-        filter(this.db, this.def, f, this.filterBranch);
+        if (f) {
+            filter(this.db, this.def, f, this.filterBranch);
+        }
         return this;
     }
 }

package/dist/src/client/query/filter/convertFilter.d.ts

@@ -0,0 +1,4 @@
+import { QueryDef } from '../types.js';
+import { Operator } from './filter.js';
+import { FilterOpts, FilterAst } from './types.js';
+export declare const convertFilter: (def: QueryDef, field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts | undefined) => FilterAst;

package/dist/src/client/query/filter/convertFilter.js

@@ -0,0 +1,56 @@
+import { toFilterCtx } from './types.js';
+const normalizeNeedle = (s) => {
+    return s
+        .normalize('NFKD')
+        .split('')
+        .filter((ch) => ch.charCodeAt(0) <= 127)
+        .join('');
+};
+export const convertFilter = (def, field, operator, value, opts) => {
+    if (operator === undefined) {
+        operator = '=';
+        value = true;
+    }
+    else if (typeof operator === 'boolean') {
+        value = operator;
+        operator = '=';
+    }
+    if (value === '' || value === undefined) {
+        return;
+    }
+    if (operator === '!..') {
+        return [
+            [field, toFilterCtx(def, '>', opts), value[1]],
+            [field, toFilterCtx(def, '<', opts), value[0]],
+        ];
+    }
+    else if (operator === '..') {
+        return [
+            [field, toFilterCtx(def, '>', opts), value[0]],
+            [field, toFilterCtx(def, '<', opts), value[1]],
+        ];
+    }
+    else {
+        if (operator == 'like') {
+            if (value == null) {
+                throw new Error('Value is required');
+            }
+            if (value?.normalize) {
+                value = normalizeNeedle(value);
+            }
+            else if (Array.isArray(value)) {
+                if (value[0]?.normalize) {
+                    value = value.map(normalizeNeedle);
+                }
+                else if (value[0]?.BYTES_PER_ELEMENT > 1) {
+                    value = value.map((v) => v.buffer);
+                }
+            }
+            else if (value?.BYTES_PER_ELEMENT > 1) {
+                value = value.buffer;
+            }
+        }
+        return [[field, toFilterCtx(def, operator, opts), value]];
+    }
+};
+//# sourceMappingURL=convertFilter.js.map

package/dist/src/client/query/filter/filter.d.ts

@@ -1,10 +1,9 @@
 import { QueryDef, QueryDefFilter } from '../types.js';
 import { SchemaTypeDef } from '../../../server/schema/schema.js';
-import { FilterOpts, Operator } from './types.js';
+import { Operator } from './types.js';
 import { Filter, FilterAst } from './types.js';
 import { DbClient } from '../../index.js';
 export { Operator, Filter };
 export declare const filterRaw: (db: DbClient, filter: Filter, schema: SchemaTypeDef, conditions: QueryDefFilter, def: QueryDef) => number;
 export declare const filter: (db: DbClient, def: QueryDef, filterAst: FilterAst, conditions: QueryDefFilter) => void;
 export declare const filterOr: (db: DbClient, def: QueryDef, filterAst: FilterAst[], conditions: QueryDefFilter) => QueryDefFilter;
-export declare const convertFilter: (def: QueryDef, field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts) => FilterAst;

package/dist/src/client/query/filter/filter.js

@@ -1,6 +1,5 @@
 import { isPropDef, ID_FIELD_DEF, TEXT, REFERENCE, } from '../../../server/schema/schema.js';
 import { primitiveFilter } from './primitiveFilter.js';
-import { toFilterCtx } from './types.js';
 import { IsFilter } from './types.js';
 import { langCodesMap } from '@based/schema';
 import { filterFieldDoesNotExist, filterInvalidLang } from '../validation.js';
@@ -22,7 +21,8 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
                     const edgeDef = edges[p];
                     if (edgeDef) {
                         conditions.edges ??= new Map();
-                        size += 3 + primitiveFilter(edgeDef, filter, conditions, def.lang);
+                        size +=
+                            3 + primitiveFilter(def, edgeDef, filter, conditions, def.lang);
                     }
                 }
             }
@@ -71,16 +71,16 @@ export const filterRaw = (db, filter, schema, conditions, def) => {
                     filterInvalidLang(def, field);
                     return 0;
                 }
-                return primitiveFilter(fieldDef, filter, conditions, code);
+                return primitiveFilter(def, fieldDef, filter, conditions, code);
             }
         }
         if (field === 'id') {
             fieldDef = ID_FIELD_DEF;
-            return primitiveFilter(fieldDef, filter, conditions, def.lang);
+            return primitiveFilter(def, fieldDef, filter, conditions, def.lang);
         }
         return referencesFilter(db, filter, schema, conditions, def);
     }
-    return primitiveFilter(fieldDef, filter, conditions, def.lang);
+    return primitiveFilter(def, fieldDef, filter, conditions, def.lang);
 };
 export const filter = (db, def, filterAst, conditions) => {
     for (const f of filterAst) {
@@ -104,55 +104,4 @@ export const filterOr = (db, def, filterAst, conditions) => {
     conditions.size += conditions.or.size;
     return conditions.or;
 };
-const normalizeNeedle = (s) => {
-    return s
-        .normalize('NFKD')
-        .split('')
-        .filter((ch) => ch.charCodeAt(0) <= 127)
-        .join('');
-};
-export const convertFilter = (def, field, operator, value, opts) => {
-    if (operator === undefined) {
-        operator = '=';
-        value = true;
-    }
-    else if (typeof operator === 'boolean') {
-        value = operator;
-        operator = '=';
-    }
-    if (operator === '!..') {
-        return [
-            [field, toFilterCtx(def, '>', opts), value[1]],
-            [field, toFilterCtx(def, '<', opts), value[0]],
-        ];
-    }
-    else if (operator === '..') {
-        return [
-            [field, toFilterCtx(def, '>', opts), value[0]],
-            [field, toFilterCtx(def, '<', opts), value[1]],
-        ];
-    }
-    else {
-        if (operator == 'like') {
-            if (value == null) {
-                throw new Error('Value is required');
-            }
-            if (value?.normalize) {
-                value = normalizeNeedle(value);
-            }
-            else if (Array.isArray(value)) {
-                if (value[0]?.normalize) {
-                    value = value.map(normalizeNeedle);
-                }
-                else if (value[0]?.BYTES_PER_ELEMENT > 1) {
-                    value = value.map((v) => v.buffer);
-                }
-            }
-            else if (value?.BYTES_PER_ELEMENT > 1) {
-                value = value.buffer;
-            }
-        }
-        return [[field, toFilterCtx(def, operator, opts), value]];
-    }
-};
 //# sourceMappingURL=filter.js.map

package/dist/src/client/query/filter/primitiveFilter.d.ts

@@ -1,5 +1,5 @@
 import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
-import { QueryDefFilter } from '../types.js';
+import { QueryDef, QueryDefFilter } from '../types.js';
 import { Filter } from './types.js';
 import { LangCode } from '@based/schema';
-export declare const primitiveFilter: (prop: PropDef | PropDefEdge, filter: Filter, conditions: QueryDefFilter, lang: LangCode) => number;
+export declare const primitiveFilter: (def: QueryDef, prop: PropDef | PropDefEdge, filter: Filter, conditions: QueryDefFilter, lang: LangCode) => number;

package/dist/src/client/query/filter/primitiveFilter.js

@@ -3,7 +3,11 @@ import { EQUAL, isNumerical } from './types.js';
 import { createVariableFilterBuffer } from './createVariableFilterBuffer.js';
 import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
 import { createReferenceFilter } from './createReferenceFilter.js';
-export const primitiveFilter = (prop, filter, conditions, lang) => {
+import { validateFilter } from '../validation.js';
+export const primitiveFilter = (def, prop, filter, conditions, lang) => {
+    if (validateFilter(def, prop, filter)) {
+        return;
+    }
     let [, ctx, value] = filter;
     const fieldIndexChar = prop.prop;
     let buf;

package/dist/src/client/query/filter/types.d.ts

@@ -4,8 +4,8 @@ export type Filter = [fieldStr: string, ctx: FilterCtx, value: any];
 export type FilterBranchFn = (filterBranch: FilterBranch) => void;
 export type FilterAst = (Filter | FilterAst)[];
 export declare const IsFilter: (f: FilterAst) => f is Filter;
-export declare const validOperators: readonly ["=", "has", "!has", "<", ">", "!=", "like", ">=", "<=", "..", "!.."];
 export type Operator = '=' | 'has' | '!has' | '<' | '>' | '!=' | 'like' | '>=' | '<=' | '..' | '!..' | 'like';
+export declare const VECTOR_FNS: string[];
 export type FilterOpts<O = Operator> = {
     lowerCase?: boolean;
     fn?: 'dotProduct' | 'manhattanDistance' | 'cosineSimilarity' | 'euclideanDistance';
@@ -54,3 +54,4 @@ export declare const VECTOR_COSTINE_SIMILARITY = 2;
 export declare const VECTOR_EUCLIDEAN_DIST = 3;
 export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 0 | 1 | 2 | 3;
 export declare const toFilterCtx: (def: QueryDef, op: Operator, opts?: FilterOpts) => FilterCtx;
+export declare const operatorReverseMap: Record<OPERATOR, string>;

package/dist/src/client/query/filter/types.js

@@ -5,18 +5,11 @@ export const IsFilter = (f) => {
     }
     return false;
 };
-export const validOperators = [
-    '=',
-    'has',
-    '!has',
-    '<',
-    '>',
-    '!=',
-    'like',
-    '>=',
-    '<=',
-    '..',
-    '!..',
+export const VECTOR_FNS = [
+    'dotProduct',
+    'manhattanDistance',
+    'cosineSimilarity',
+    'euclideanDistance',
 ];
 // -------------------------------------------
 // operations shared
@@ -119,4 +112,22 @@ export const toFilterCtx = (def, op, opts = {}) => {
     }
     filterOperatorDoesNotExist(def, op);
 };
+export const operatorReverseMap = {
+    [EQUAL]: '=',
+    [HAS]: 'has',
+    [ENDS_WITH]: 'endsWith',
+    [STARTS_WITH]: 'startsWith',
+    [GREATER_THAN]: '>',
+    [SMALLER_THAN]: '<',
+    [GREATER_THAN_INCLUSIVE]: '>=',
+    [SMALLER_THAN_INCLUSIVE]: '<=',
+    [RANGE]: '..',
+    [RANGE_EXCLUDE]: '!..',
+    [EQUAL_LOWER_CASE]: '= (lowerCase)',
+    [HAS_TO_LOWER_CASE]: 'has (lowerCase)',
+    [STARTS_WITH_LOWER_CASE]: 'startsWith (lowerCase)',
+    [ENDS_WITH_LOWER_CASE]: 'endsWith (lowerCase)',
+    [LIKE]: 'like',
+    [EQUAL_CRC32]: '= (crc32)',
+};
 //# sourceMappingURL=types.js.map