@rip-lang/db 1.3.80 → 1.3.81

package/lib/duckdb-binary.rip

@@ -32,17 +32,20 @@ export LogicalTypeId =
   UBIGINT:       31
   TIMESTAMP_TZ:  32
   TIME_TZ:       34
+  TIME_NS:       35
   BIT:           36
   BIGNUM:        39
   UHUGEINT:      49
   HUGEINT:       50
   UUID:          54
+  GEOMETRY:      60
   STRUCT:       100
   LIST:         101
   MAP:          102
   ENUM:         104
   UNION:        107
   ARRAY:        108
+  VARIANT:      109
 
 # Shared TextEncoder instance (avoid allocating per call)
 textEncoder = new TextEncoder()
@@ -233,7 +236,7 @@ serializeVector = (s, column, values) ->
 
   switch typeId
     when LogicalTypeId.VARCHAR, LogicalTypeId.CHAR
-      s.writeList 102, values, (s, v) -> s.writeString String(v ?? '')
+      s.writeList 102, values, (s, v) -> s.writeString stringify(v)
 
     when LogicalTypeId.BOOLEAN
       s.writeFieldId 102
@@ -341,8 +344,87 @@ serializeVector = (s, column, values) ->
         dv.setBigInt64 i * 16 + 8, hi, true
       s.writeData bytes
 
+    when LogicalTypeId.TIME
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigInt64 i * 8, (if v? then timeToMicros v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.TIME_TZ
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigUint64 i * 8, (if v? then timeToPackedTZ v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.TIME_NS
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigInt64 i * 8, (if v? then timeToNanos v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.TIMESTAMP_SEC
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigInt64 i * 8, (if v? then timestampToSecs v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.TIMESTAMP_MS
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigInt64 i * 8, (if v? then timestampToMillis v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.TIMESTAMP_NS
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 8
+      dv = new DataView bytes.buffer
+      for v, i in values
+        dv.setBigInt64 i * 8, (if v? then timestampToNanos v else 0n), true
+      s.writeData bytes
+
+    when LogicalTypeId.INTERVAL
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 16
+      dv = new DataView bytes.buffer
+      for v, i in values
+        { months, days, micros } = if v? then parseInterval v else { months: 0, days: 0, micros: 0n }
+        dv.setInt32 i * 16, months, true
+        dv.setInt32 i * 16 + 4, days, true
+        dv.setBigInt64 i * 16 + 8, micros, true
+      s.writeData bytes
+
+    when LogicalTypeId.HUGEINT
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 16
+      dv = new DataView bytes.buffer
+      for v, i in values
+        { lo, hi } = stringToHugeint v
+        dv.setBigUint64 i * 16, lo, true
+        dv.setBigInt64 i * 16 + 8, hi, true
+      s.writeData bytes
+
+    when LogicalTypeId.UHUGEINT
+      s.writeFieldId 102
+      bytes = new Uint8Array values.length * 16
+      dv = new DataView bytes.buffer
+      for v, i in values
+        { lo, hi } = stringToUhugeint v
+        dv.setBigUint64 i * 16, lo, true
+        dv.setBigUint64 i * 16 + 8, hi, true
+      s.writeData bytes
+
     else
-      s.writeList 102, values, (s, v) -> s.writeString String(v ?? '')
+      s.writeList 102, values, (s, v) -> s.writeString stringify(v)
 
   s.writeEndMarker()
 
@@ -350,6 +432,10 @@ serializeVector = (s, column, values) ->
 # Helper functions
 # ==============================================================================
 
+stringify = (v) ->
+  return '' unless v?
+  if typeof v is 'object' then JSON.stringify(v) else String(v)
+
 createValidityBitmap = (values) ->
   # Must be uint64-aligned (8-byte chunks) — the UI reads validity with getBigUint64
   byteCount = Math.ceil(values.length / 64) * 8
@@ -391,6 +477,95 @@ uuidToHugeint = (uuid) ->
   lo = full & ((1n << 64n) - 1n)
   { lo, hi }
 
+timeToMicros = (value) ->
+  return 0n unless value
+  match = String(value).match /^(\d+):(\d+):(\d+)(?:\.(\d+))?/
+  return 0n unless match
+  h = parseInt match[1], 10
+  m = parseInt match[2], 10
+  s = parseInt match[3], 10
+  frac = match[4] or ''
+  fracUs = parseInt frac.padEnd(6, '0').slice(0, 6), 10
+  BigInt(h * 3600 + m * 60 + s) * 1000000n + BigInt(fracUs)
+
+timeToPackedTZ = (value) ->
+  return 0n unless value
+  match = String(value).match /^(\d+):(\d+):(\d+)(?:\.(\d+))?([+-])(\d+):(\d+)$/
+  return 0n unless match
+  h = parseInt match[1], 10
+  m = parseInt match[2], 10
+  s = parseInt match[3], 10
+  frac = match[4] or ''
+  fracUs = parseInt frac.padEnd(6, '0').slice(0, 6), 10
+  sign = if match[5] is '+' then 1 else -1
+  offH = parseInt match[6], 10
+  offM = parseInt match[7], 10
+  micros = BigInt(h * 3600 + m * 60 + s) * 1000000n + BigInt(fracUs)
+  offsetSec = sign * (offH * 3600 + offM * 60)
+  (micros << 24n) | BigInt(offsetSec + 86399)
+
+timeToNanos = (value) ->
+  return 0n unless value
+  match = String(value).match /^(\d+):(\d+):(\d+)(?:\.(\d+))?/
+  return 0n unless match
+  h = parseInt match[1], 10
+  m = parseInt match[2], 10
+  s = parseInt match[3], 10
+  frac = match[4] or ''
+  fracNs = parseInt frac.padEnd(9, '0').slice(0, 9), 10
+  BigInt(h * 3600 + m * 60 + s) * 1000000000n + BigInt(fracNs)
+
+timestampToSecs = (value) ->
+  if value instanceof Date then BigInt Math.floor value.getTime() / 1000
+  else if typeof value is 'string' then BigInt Math.floor new Date(value).getTime() / 1000
+  else if typeof value is 'number' then BigInt value
+  else if typeof value is 'bigint' then value
+  else 0n
+
+timestampToMillis = (value) ->
+  if value instanceof Date then BigInt value.getTime()
+  else if typeof value is 'string' then BigInt new Date(value).getTime()
+  else if typeof value is 'number' then BigInt(value) * 1000n
+  else if typeof value is 'bigint' then value
+  else 0n
+
+timestampToNanos = (value) ->
+  if value instanceof Date then BigInt(value.getTime()) * 1000000n
+  else if typeof value is 'string' then BigInt(new Date(value).getTime()) * 1000000n
+  else if typeof value is 'number' then BigInt(value) * 1000000000n
+  else if typeof value is 'bigint' then value
+  else 0n
+
+parseInterval = (value) ->
+  return { months: 0, days: 0, micros: 0n } unless value
+  str = String value
+  months = 0
+  days = 0
+  micros = 0n
+  if m = str.match /(-?\d+)\s+month/
+    months = parseInt m[1], 10
+  if m = str.match /(-?\d+)\s+day/
+    days = parseInt m[1], 10
+  if m = str.match /(-?[\d.]+)\s+second/
+    micros = BigInt Math.round parseFloat(m[1]) * 1000000
+  { months, days, micros }
+
+stringToHugeint = (value) ->
+  return { lo: 0n, hi: 0n } unless value?
+  big = BigInt value
+  mask64 = (1n << 64n) - 1n
+  lo = big & mask64
+  hi = big >> 64n
+  { lo, hi }
+
+stringToUhugeint = (value) ->
+  return { lo: 0n, hi: 0n } unless value?
+  big = BigInt value
+  mask64 = (1n << 64n) - 1n
+  lo = big & mask64
+  hi = (big >> 64n) & mask64
+  { lo, hi }
+
 mapDuckDBType = (typeName) ->
   return LogicalTypeId.VARCHAR unless typeName
   upper = String(typeName).toUpperCase()
@@ -412,14 +587,26 @@ mapDuckDBType = (typeName) ->
     when 'DATE' then LogicalTypeId.DATE
     when 'TIME' then LogicalTypeId.TIME
     when 'TIMESTAMP', 'DATETIME' then LogicalTypeId.TIMESTAMP
-    when 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMPTZ' then LogicalTypeId.TIMESTAMP_TZ
+    when 'TIMESTAMP_S', 'TIMESTAMP_SEC' then LogicalTypeId.TIMESTAMP_SEC
+    when 'TIMESTAMP_MS' then LogicalTypeId.TIMESTAMP_MS
+    when 'TIMESTAMP_NS' then LogicalTypeId.TIMESTAMP_NS
+    when 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMPTZ', 'TIMESTAMP_TZ' then LogicalTypeId.TIMESTAMP_TZ
+    when 'TIME WITH TIME ZONE', 'TIMETZ', 'TIME_TZ' then LogicalTypeId.TIME_TZ
+    when 'TIME_NS' then LogicalTypeId.TIME_NS
     when 'VARCHAR', 'TEXT', 'STRING', 'CHAR', 'BPCHAR' then LogicalTypeId.VARCHAR
-    when 'BLOB', 'BYTEA', 'BINARY', 'VARBINARY' then LogicalTypeId.BLOB
     when 'UUID' then LogicalTypeId.UUID
     when 'INTERVAL' then LogicalTypeId.INTERVAL
-    when 'JSON' then LogicalTypeId.VARCHAR
+    when 'BLOB', 'BYTEA', 'BINARY', 'VARBINARY' then LogicalTypeId.VARCHAR
+    when 'BIT', 'BITSTRING' then LogicalTypeId.VARCHAR
+    when 'ENUM' then LogicalTypeId.VARCHAR
+    when 'LIST' then LogicalTypeId.VARCHAR
+    when 'STRUCT' then LogicalTypeId.VARCHAR
+    when 'MAP' then LogicalTypeId.VARCHAR
+    when 'UNION' then LogicalTypeId.VARCHAR
+    when 'ARRAY' then LogicalTypeId.VARCHAR
+    when 'JSON', 'VARIANT' then LogicalTypeId.VARCHAR
     else
-      if upper.startsWith 'DECIMAL' then LogicalTypeId.VARCHAR  # Serialize as string to preserve exact precision
+      if upper.startsWith 'DECIMAL' then LogicalTypeId.VARCHAR
       else if upper.startsWith 'VARCHAR' then LogicalTypeId.VARCHAR
       else if upper.startsWith 'CHAR' then LogicalTypeId.CHAR
       else LogicalTypeId.VARCHAR

package/lib/duckdb.mjs

@@ -121,7 +121,7 @@ const lib = dlopen(libPath, {
   duckdb_vector_get_validity:     { args: ['ptr'], returns: 'ptr' },
   duckdb_destroy_data_chunk:      { args: ['ptr'], returns: 'void' },
 
-  // Logical type introspection (for DECIMAL, ENUM, LIST, STRUCT)
+  // Logical type introspection (for DECIMAL, ENUM, LIST, STRUCT, ARRAY)
   duckdb_column_logical_type:     { args: ['ptr', 'u64'], returns: 'ptr' },
   duckdb_destroy_logical_type:    { args: ['ptr'], returns: 'void' },
   duckdb_get_type_id:             { args: ['ptr'], returns: 'i32' },
@@ -132,14 +132,17 @@ const lib = dlopen(libPath, {
   duckdb_enum_dictionary_size:    { args: ['ptr'], returns: 'u32' },
   duckdb_enum_dictionary_value:   { args: ['ptr', 'u64'], returns: 'ptr' },
 
-  // Nested type vector access (LIST, STRUCT)
+  // Nested type vector access (LIST, STRUCT, ARRAY)
   duckdb_list_vector_get_child:   { args: ['ptr'], returns: 'ptr' },
-  duckdb_list_vector_get_size:    { args: ['ptr'], returns: 'u64' },  // Not yet used; available for LIST size checks
+  duckdb_list_vector_get_size:    { args: ['ptr'], returns: 'u64' },
   duckdb_struct_vector_get_child: { args: ['ptr', 'u64'], returns: 'ptr' },
   duckdb_struct_type_child_count: { args: ['ptr'], returns: 'u64' },
   duckdb_struct_type_child_name:  { args: ['ptr', 'u64'], returns: 'ptr' },
   duckdb_struct_type_child_type:  { args: ['ptr', 'u64'], returns: 'ptr' },
   duckdb_list_type_child_type:    { args: ['ptr'], returns: 'ptr' },
+  duckdb_array_vector_get_child:  { args: ['ptr'], returns: 'ptr' },
+  duckdb_array_type_child_type:   { args: ['ptr'], returns: 'ptr' },
+  duckdb_array_type_array_size:   { args: ['ptr'], returns: 'u64' },
 
   // Memory
   duckdb_free: { args: ['ptr'], returns: 'void' },
@@ -183,7 +186,11 @@ const DUCKDB_TYPE = {
   UUID: 27,
   UNION: 28,
   BIT: 29,
-  TIMESTAMP_TZ: 32,
+  TIME_TZ: 30,
+  TIMESTAMP_TZ: 31,
+  UHUGEINT: 32,
+  ARRAY: 33,
+  TIME_NS: 39,
 };
 
 export { DUCKDB_TYPE };
@@ -406,12 +413,13 @@ class Connection {
   //
   // Contract:
   //   BIGINT/UBIGINT → number (lossy above 2^53, JSON-safe)
-  //   DECIMAL/HUGEINT → string (preserves precision)
+  //   DECIMAL/HUGEINT/UHUGEINT → string (preserves precision)
   //   All timestamps → Date (UTC)
   //   UUID → string (formatted)
   //   VARCHAR/BLOB → string
   //   ENUM → string (dictionary lookup)
-  //   LIST → array, STRUCT → object, MAP → object
+  //   TIME/TIME_NS/TIME_TZ → string (formatted)
+  //   LIST/ARRAY → array, STRUCT → object, MAP → object
   // ---------------------------------------------------------------------------
 
   #extractChunks(resultPtr) {
@@ -431,7 +439,8 @@ class Connection {
 
       // Get logical type metadata for complex types
       if (type === DUCKDB_TYPE.DECIMAL || type === DUCKDB_TYPE.ENUM ||
-          type === DUCKDB_TYPE.LIST || type === DUCKDB_TYPE.STRUCT || type === DUCKDB_TYPE.MAP) {
+          type === DUCKDB_TYPE.LIST || type === DUCKDB_TYPE.STRUCT ||
+          type === DUCKDB_TYPE.MAP || type === DUCKDB_TYPE.ARRAY) {
         const logType = lib.duckdb_column_logical_type(rp, BigInt(c));
         if (logType) {
           if (type === DUCKDB_TYPE.DECIMAL) {
@@ -488,6 +497,15 @@ class Connection {
               const b = allocPtr(); new DataView(b.buffer).setBigUint64(0, BigInt(keyLogType), true);
               lib.duckdb_destroy_logical_type(ptr(b));
             }
+          } else if (type === DUCKDB_TYPE.ARRAY) {
+            col.arraySize = Number(lib.duckdb_array_type_array_size(logType));
+            const childLogType = lib.duckdb_array_type_child_type(logType);
+            if (childLogType) {
+              col.childType = lib.duckdb_get_type_id(childLogType);
+              const ltBuf2 = allocPtr();
+              new DataView(ltBuf2.buffer).setBigUint64(0, BigInt(childLogType), true);
+              lib.duckdb_destroy_logical_type(ptr(ltBuf2));
+            }
           }
           const ltBuf = allocPtr();
           new DataView(ltBuf.buffer).setBigUint64(0, BigInt(logType), true);
@@ -592,6 +610,13 @@ class Connection {
         return value.toString();
       }
 
+      case DUCKDB_TYPE.UHUGEINT: {
+        const lo = ffiRead.u64(dataPtr, row * 16);
+        const hi = ffiRead.u64(dataPtr, row * 16 + 8);
+        const value = (BigInt(hi) << 64n) | BigInt(lo);
+        return value.toString();
+      }
+
       case DUCKDB_TYPE.DECIMAL: {
         // Read based on internal type, divide by 10^scale, return as string
         const scale = col?.decimalScale || 0;
@@ -649,6 +674,39 @@ class Connection {
                (frac > 0 ? `.${String(frac).padStart(6,'0').replace(/0+$/, '')}` : '');
       }
 
+      case DUCKDB_TYPE.TIME_NS: {
+        const ns = ffiRead.i64(dataPtr, row * 8);
+        const totalUs = Number(ns / 1000n);
+        const subUs = Number(ns % 1000n);
+        const totalSec = Math.floor(totalUs / 1000000);
+        const h = Math.floor(totalSec / 3600);
+        const m = Math.floor((totalSec % 3600) / 60);
+        const s = totalSec % 60;
+        const fracUs = totalUs % 1000000;
+        const fracNs = fracUs * 1000 + subUs;
+        return `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}` +
+               (fracNs > 0 ? `.${String(fracNs).padStart(9,'0').replace(/0+$/, '')}` : '');
+      }
+
+      case DUCKDB_TYPE.TIME_TZ: {
+        // Stored as uint64: upper 40 bits = microseconds, lower 24 bits = offset + 86399
+        const bits = ffiRead.u64(dataPtr, row * 8);
+        const us = Number(bits >> 24n);
+        const offsetSec = Number(bits & 0xFFFFFFn) - 86399;
+        const totalSec = Math.floor(us / 1000000);
+        const h = Math.floor(totalSec / 3600);
+        const m = Math.floor((totalSec % 3600) / 60);
+        const s = totalSec % 60;
+        const frac = us % 1000000;
+        const absOff = Math.abs(offsetSec);
+        const offH = Math.floor(absOff / 3600);
+        const offM = Math.floor((absOff % 3600) / 60);
+        const sign = offsetSec >= 0 ? '+' : '-';
+        return `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}` +
+               (frac > 0 ? `.${String(frac).padStart(6,'0').replace(/0+$/, '')}` : '') +
+               `${sign}${String(offH).padStart(2,'0')}:${String(offM).padStart(2,'0')}`;
+      }
+
       case DUCKDB_TYPE.UUID:
         return readUUID(dataPtr, row);
 
@@ -755,6 +813,27 @@ class Connection {
         return obj;
       }
 
+      case DUCKDB_TYPE.ARRAY: {
+        // Fixed-size array: child elements are contiguous, arraySize elements per row
+        if (!vec) return null;
+        const arraySize = col?.arraySize || 0;
+        const childVec = lib.duckdb_array_vector_get_child(vec);
+        const childData = lib.duckdb_vector_get_data(childVec);
+        const childValidity = lib.duckdb_vector_get_validity(childVec);
+        const childType = col?.childType || DUCKDB_TYPE.VARCHAR;
+        const baseIdx = row * arraySize;
+        const result = [];
+        for (let i = 0; i < arraySize; i++) {
+          const childRow = baseIdx + i;
+          if (!isValid(childValidity, childRow)) {
+            result.push(null);
+          } else {
+            result.push(this.#readValue(childData, childRow, childType, null, childVec));
+          }
+        }
+        return result;
+      }
+
       case DUCKDB_TYPE.UNION:
       case DUCKDB_TYPE.BIT:
         return null; // Rarely used types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rip-lang/db",
-  "version": "1.3.80",
+  "version": "1.3.81",
   "description": "DuckDB server with official DuckDB UI - pure Bun FFI",
   "type": "module",
   "main": "db.rip",
@@ -13,7 +13,8 @@
   },
   "scripts": {
     "start": "rip db.rip",
-    "dev": "rip db.rip :memory:"
+    "dev": "rip db.rip :memory:",
+    "test": "bun test --preload ../../rip-loader.js test/"
   },
   "keywords": [
     "db",
@@ -38,7 +39,7 @@
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "rip-lang": ">=3.13.92",
+    "rip-lang": ">=3.13.93",
     "@rip-lang/server": ">=1.3.0"
   },
   "files": [