wip

GEMINI.md

@@ -81,18 +81,14 @@ const a = (ctx) => {
 - Prefer self-documenting code (clear variable names, etc.).
 - If you must add a comment, keep it minimal and explain the _why_, not the _what_.
 
-## Running db Tests
+## Running Tests
 
-The following instructions apply only to the `@based/db` package. Other packages have their own test runners.
+The project uses a custom test runner. **Always use `npm test`** to run tests. Do **NOT** use `npx tsx` or `node` directly on test files.
 
-The `db` package uses a custom test runner. To run the tests, you can use `npm run test` from the `packages/db` directory, or `npm run test -w @based/db` from the root of the project. You can pass arguments to filter the tests.
+You can run tests from the root simply with `npm test`. You can pass arguments to filter the tests.
 
 ```bash
-# From packages/db
-npm run test -- [filters]
-
-# From root
-npm run test -w @based/db -- [filters]
+npm test [filter]
 ```
 
 There is also a `test-fast` script that skips the build step.
@@ -111,28 +107,23 @@ You can filter which tests to run by providing one or more filter arguments.
 
 - **Run all tests:**
   ```bash
-  # from packages/db
-  npm run test
+  npm test
   ```
-- **Run all tests and stop on the first failure:**
+- **Run tests for a specific file or folder (e.g. `query/ast`):**
   ```bash
-  # from packages/db
-  npm run test -- stopOnFail
+  npm test query/ast
   ```
-- **Run tests in files with "view" in the path:**
+- **Run all tests and stop on the first failure:**
   ```bash
-  # from packages/db
-  npm run test -- view
+  npm test stopOnFail
   ```
 - **Run tests with "observe" in the name, in files with "view" in the path:**
   ```bash
-  # from packages/db
-  npm run test -- view:observe
+  npm test view:observe
   ```
 - **Run all tests 10 times:**
   ```bash
-  # from packages/db
-  npm run test -- 10
+  npm test 10
   ```
 
 ## Zig version

src/db-client/modify/Ctx.ts → _modify/Ctx.ts

@@ -8,7 +8,7 @@ export const MODIFY_HEADER_SIZE = 1 + 4 + 8 + 4
 export class Ctx {
   constructor(schemaChecksum: number, buf: Uint8Array<ArrayBufferLike>) {
     this.buf = buf
-    buf[4] = OpType.modify // make enum later 1 means normal MODIFY
+    buf[4] = OpType.modify
     writeUint64(buf, schemaChecksum, 5)
     this.reset()
   }
@@ -19,18 +19,18 @@ export class Ctx {
     this.cursor = {}
     this.batch = {}
   }
-  start: number
-  index: number
-  schema: SchemaTypeDef
+  start!: number
+  index!: number
+  schema!: SchemaTypeDef
   buf: Uint8Array<ArrayBufferLike>
-  max: number
-  size: number
+  max!: number
+  size!: number
   unsafe?: boolean
-  operation: ModOpEnum
+  operation!: ModOpEnum
   main: Map<PropDef, any> = new Map()
-  draining: Promise<void>
+  draining!: Promise<void>
   scheduled: Promise<void> | undefined
-  locale: LangCodeEnum
+  locale!: LangCodeEnum
   sort: number = 0
   sortText: number = 0
   defaults: number = 0
@@ -39,7 +39,6 @@ export class Ctx {
     prop?: number
     main?: number
     operation?: ModOpEnum
-    upserting?: boolean
   } = {}
   batch: {
     count?: number

src/db-client/modify/Tmp.ts → _modify/Tmp.ts

@@ -43,10 +43,10 @@ export class Tmp implements Promise<number> {
     this.batch = ctx.batch
     this.tmpId = ctx.batch.count++
   }
-  [Symbol.toStringTag]: 'ModifyPromise'
+  [Symbol.toStringTag]!: 'ModifyPromise'
   #schema: SchemaTypeDef
-  #id: number
-  #err: number
+  #id!: number
+  #err!: number
   get error(): Error | undefined {
     if (this.batch.ready && !this.id) {
       if (this.#err in errorMap) {

src/db-client/modify/props/references.ts → _modify/props/references.ts

@@ -5,6 +5,19 @@ import type { Ctx } from '../Ctx.js'
 import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js'
 import { reserve } from '../resize.js'
 import { writeU32, writeU8 } from '../uint.js'
+import { writeObject } from './object.js'
+
+type Edges = Record<string, any> | undefined
+const getEdges = (obj: Record<string, any>): Edges => {
+  let edges: Edges
+  for (const i in obj) {
+    if (i[0] === '$' && i !== '$index') {
+      edges ??= {}
+      edges[i] = obj[i]
+    }
+  }
+  return edges
+}
 
 export const writeReferences = (ctx: Ctx, def: PropDef, val: any) => {
   if (typeof val !== 'object') {
@@ -27,40 +40,51 @@ export const writeReferences = (ctx: Ctx, def: PropDef, val: any) => {
       writeU8(ctx, RefOp.clear)
     }
 
-    let op: RefOpEnum | undefined
+    let prevOp: RefOpEnum | undefined
     let pos = 0
     let len = 0
 
     for (const item of val) {
       let id: number
-      let nextOp: RefOpEnum
+      let op: RefOpEnum
+      let edges: Edges
       if (typeof item === 'number') {
         id = item
-        nextOp = RefOp.set
+        op = RefOp.set
       } else if (typeof item === 'object' && item !== null && item.id) {
         id = item.id
-        nextOp = RefOp.set
+        edges = getEdges(item)
+        if (edges) {
+          op = RefOp.setEdge
+        } else {
+          op = RefOp.set
+        }
       } else {
         // not handled yet
         throw new Error('references payload, not handled yet - wip')
       }
 
-      if (op !== nextOp!) {
-        if (op) {
+      if (prevOp !== op!) {
+        if (prevOp) {
           // write previous len
           writeUint32(ctx.buf, len * 4, pos)
         }
-        writeU8(ctx, (op = nextOp!))
+        writeU8(ctx, (prevOp = op!))
         pos = ctx.index
         len = 0
         ctx.index += 4
       }
 
       writeU32(ctx, id)
+      if (edges) {
+        writeObject(ctx, def.edges as any, edges)
+        writeU8(ctx, ModOp.end)
+      }
+
       len++
     }
 
-    writeUint32(ctx.buf, len * 4, pos)
+    writeUint32(ctx.buf, len, pos)
     writeU8(ctx, RefOp.end)
     return
   }

_modify/types.ts

@@ -0,0 +1,35 @@
+import { LangCode, ModOp } from '../../zigTsExports.js'
+
+export const RANGE_ERR = 1
+export const MOD_OPS_TO_STRING = {
+  [ModOp.createProp]: 'create',
+  [ModOp.updateProp]: 'update',
+  [ModOp.increment]: 'update',
+  [ModOp.expire]: 'update',
+} as const
+
+export const enum SIZE {
+  DEFAULT_CURSOR = 11,
+}
+
+export type ModifyOpts = {
+  unsafe?: boolean
+  locale?: keyof typeof LangCode
+}
+
+export const NOEDGE_NOINDEX_REALID = 0
+export const EDGE_NOINDEX_REALID = 1
+export const EDGE_INDEX_REALID = 2
+export const NOEDGE_INDEX_REALID = 3
+export const NOEDGE_NOINDEX_TMPID = 4
+export const EDGE_NOINDEX_TMPID = 5
+export const EDGE_INDEX_TMPID = 6
+export const NOEDGE_INDEX_TMPID = 7
+
+// export const REF_OP_OVERWRITE = 0
+// export const REF_OP_UPDATE = 1
+// export const REF_OP_DELETE = 2
+// export const REF_OP_PUT_OVERWRITE = 3
+// export const REF_OP_PUT_ADD = 4
+
+// export type RefOp = typeof REF_OP_OVERWRITE | typeof REF_OP_UPDATE

src/db-client/modify/update/index.ts → _modify/update/index.ts

@@ -114,3 +114,72 @@ export function update(
     return handleError(db, ctx, update, arguments, e)
   }
 }
+
+// const simpleUpdate = () => {
+
+// }
+
+/*
+  CREATE
+
+  article {
+    body: 'xxx',
+    age: 10,
+    rating: 4
+  }
+
+  ==>
+
+  create|article|main:10,4|body:xxx
+
+  UPDATE
+
+  article 10 {
+    body: 'xxx',
+    age: 10,
+    rating: 4
+  }
+
+  ==>
+
+  update|article|id:10|main:0:10|main:1:4|body:xxx
+
+  update(u8)|size(u32)|type(u8)|id(u32)|...[prop(u8)]
+
+
+  propType,size,value
+  // age:number:81
+  1,4,81
+
+
+
+  name,string,value
+
+
+  UPSERT
+
+  article 'abc', {
+    body: 'xxx',
+    age: 10,
+    rating: 4
+  }
+
+  ==>
+
+  upsert|article|abc|main:0:10|main:1:4|body:xxx
+
+
+
+
+
+
+
+
+
+  --------------------------------------------------------------------
+
+
+
+
+
+*/

clibs/common.mk

@@ -50,6 +50,8 @@ endif
 
 ifeq ($(uname_S),Linux)
 	CFLAGS += -g -ggdb3 -fno-math-errno -ftree-vectorize -Wstrict-aliasing=3
+	# Mute the gcc bug when `auto` is used to infer the type
+	CFLAGS += -Wno-old-style-declaration
 	#CFLAGS += -opt-info-vec-optimized
 	#CFLAGS += -ftree-vectorizer-verbose=5 -fopt-info-vec-missed
 

clibs/include/cdefs.h

@@ -204,7 +204,8 @@
  *     unsigned int len;
  *     char buf[] __counted_by(len);
  * };
- * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf)
+ * *__builtin_counted_by_ref(p->puf) = len;
+ * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf);
  */
 #define __counted_by(member) __attribute__((__counted_by__(member)))
 #else
@@ -213,13 +214,16 @@
 #endif
 
 #ifndef __pcounted_by
-#if __has_attribute(__counted_by__) && !defined(__clang__)
+#if __has_attribute(__counted_by__) && \
+    !defined(__clang__) && \
+    (__GNUC__ > 15 || (__GNUC__ == 14 && __GNUC_MINOR__ > 2))
 /**
  * struct foo {
  *     unsigned int len;
  *     char *buf __pcounted_by(len);
  * };
- * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf)
+ * *__builtin_counted_by_ref(p->puf) = len;
+ * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf);
  */
 #define __pcounted_by(member) __attribute__((__counted_by__(member)))
 #else

clibs/include/selva/colvec.h

@@ -67,5 +67,8 @@ void *colvec_get_vec(struct SelvaTypeEntry *te, node_id_t node_id, const struct
 SELVA_EXPORT
 void colvec_set_vec(struct SelvaTypeEntry *te, node_id_t node_id, const struct SelvaFieldSchema *fs, const void *vec);
 
+SELVA_EXPORT
+void colvec_clear_vec(struct SelvaTypeEntry *te, node_id_t node_id, const struct SelvaFieldSchema *fs);
+
 SELVA_EXPORT
 int colvec_foreach(struct SelvaTypeEntry *te, const struct SelvaFieldSchema *fs, node_id_t start, uint32_t len, void (*cb)(node_id_t node_id, void *vec, void *arg), void *arg);