code wiki / (root) / nx_sqlite_rows.nx
`nx_sqlite_rows.nx` source

↩ module page · 1112 lines · 46181 B
1// nx_sqlite_rows.nx -- SOVEREIGN SQLite ROW READER (rung 2) + seg-store PLANE LANDER.
2//
3// RUNG 1 (_hdl_build/_sqlite_read_authored.nx) walks the b-tree and decodes sqlite_master, and declares
4// its own honest limit: "local payload only -- overflow pages not followed yet ... full row/column reads
5// = rung 2". THIS IS RUNG 2: full row+column reads WITH the overflow-page chain, so any row of any size
6// comes out byte-exact.
7//
8// WHY (2026-07-23, F916 re-aimed by the F1010 SOTA reframe): the legacy Elder platform's knowledge lives
9// in SQLite (content.db 390MB: outfits/poses/locations rule mesh + 200k-row batch_history). It is NOT
10// ported as a runtime rule engine (measured: prompt words cap at ~85% semantics / 50% geometry / 0%
11// identity) -- it is MINED AS A DATASET: an L1 semantic prior + a learning corpus + an eval set. This
12// organ is the sovereign read path for that mine. READ-ONLY: it never writes to the SQLite file.
13//
14// VERBS
15//   tables <db>                          list tables: name, rootpage, rows
16//   rows   <db> <table> [max]            dump rows TSV-ish (NULL=\N, tab/nl/backslash escaped)
17//   plane  <db> <table> <store-prefix>   land rows into a seg-store plane, ONE segment per table:
18//                                        key <table>:<rowid> -> canonical NXR1 record (absent field ==
19//                                        SQL NULL, so NULL survives losslessly), plus <table>:meta
20//   selftest                             gate, verdict=GREEN|RED
21//
22// ENVELOPE (declared, never silent): row payload cap 8MiB · <=256 cols · REAL rendered to 3 decimals
23// (out-of-range -> x<hex>, never a wrong number) · BLOBs emitted raw (embedded NUL truncates a plane
24// value -- text/int tables are the target; blob-safe values = a later rung) · a table lands in ONE
25// segment (writer cap 128MiB).
26// NOTE (DRY): sqr_rec_field duplicates mv_rec_field's NXR1 walk (2nd copy; at a 3rd, extract to a lib).
27// license_tier: ORIGINAL   Read-only, no hw writes (Rule 26).
28import "nx_syscalls.nx"
29import "nx_canon_cid.nx"
30import "nx_seg_store.nx"
31const SQR_MAGIC_2047: i64 = 2047
32const SQR_MAGIC_4503599627370495: i64 = 4503599627370495
33const SQR_MAGIC_4503599627370496: i64 = 4503599627370496
34const SQR_MAGIC_1075: i64 = 1075
35const SQR_MAGIC_1048576: i64 = 1048576
36const SQR_MAGIC_65000: i64 = 65000
37const SQR_MAGIC_21329: i64 = 21329
38const SQR_MAGIC_65536: i64 = 65536
39const SQR_MAGIC_1024: i64 = 1024
40const SQR_MAGIC_4096: i64 = 4096
41const SQR_MAGIC_20000: i64 = 20000
42
43const SQR_MAXCOL:   i64 = 256
44const SQR_ROWCAP:   i64 = 8388608
45const SQR_ARENA:    i64 = 8388608
46const SQR_NAMES:    i64 = 65536
47const SQR_WCAP:     i64 = 134217728
48const SQR_LINE:     i64 = 8388608
49
50// ctx slots
51const CX_MODE: i64 = 0
52const CX_ROWS: i64 = 1
53const CX_MAX:  i64 = 2
54const CX_DB:   i64 = 3
55const CX_PS:   i64 = 4
56const CX_USE:  i64 = 5
57const CX_PAY:  i64 = 6
58const CX_OFFS: i64 = 7
59const CX_LENS: i64 = 8
60const CX_TYPS: i64 = 9
61const CX_NCOL: i64 = 10
62const CX_NAMB: i64 = 11
63const CX_NAMO: i64 = 12
64const CX_W:    i64 = 13
65const CX_TAB:  i64 = 14
66const CX_KEYS: i64 = 15
67const CX_VALS: i64 = 16
68const CX_AREN: i64 = 17
69const CX_REC:  i64 = 18
70const CX_KBUF: i64 = 19
71const CX_ERR:  i64 = 20
72const CX_LINE: i64 = 21
73const CX_MINR: i64 = 22
74const CX_MAXR: i64 = 23
75const CX_ALIA: i64 = 24
76// capture mode (3): pull ONE column of ONE rowid out for gate assertions
77const CX_CAPID: i64 = 25
78const CX_CAPCOL: i64 = 26
79const CX_CAPP:  i64 = 27
80const CX_CAPL:  i64 = 28
81const CX_CAPT:  i64 = 29
82const CX_CAPV:  i64 = 30
83// chunked planing: a table larger than the writer must land as MULTIPLE segments, not fail closed
84// (token_position_log is 42.9M rows -- roughly 8GB of records; one segment could never hold it).
85const CX_PFX:   i64 = 31
86const CX_SEGN:  i64 = 32
87// ROW-RANGE planing: `plane <db> <t> <pfx> [skip] [count]`. The sovereign toolchain frees lazily in
88// places (see nx_galx_thumb's header: "a single process MUST NOT decode many images ... FORKS one child
89// per image -- the kernel reclaims every mmap on child exit"). MEASURED here 2026-07-23: one process
90// planing beauty_evaluations (568,944 rows) climbed to 10.09GB RSS and was SIGKILLed by the OOM killer,
91// while 306,266 rows peaked at 6.0GB and survived -- growth tracks ROWS, not DB size. So a big table is
92// planed as N range invocations; each fresh process gives every page back on exit.
93const CX_SKIP:  i64 = 33
94const CX_SEEN:  i64 = 34
95const SQR_FLUSH: i64 = 100663296   // flush a batch past 96MiB (writer cap is 128MiB)
96
97func sqr_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
98func sqr_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
99func sqr_cat(d: *u8, o: i64, s: *u8) -> i64 { var p: i64 = o; var i: i64 = 0; while s[i] != (0 as u8) { d[p] = s[i]; p = p + 1; i = i + 1 } return p }
100func sqr_ch(d: *u8, o: i64, c: i64) -> i64 { d[o] = c as u8; return o + 1 }
101func sqr_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while 1 == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
109}
110func sqr_udec(d: *u8, o: i64, v: i64) -> i64 {
  if v == 0 { d[o] = 48 as u8; return o + 1 }
  var div: i64 = 1
  var m: i64 = v
  while m >= 10 { div = div * 10; m = m / 10 }
  var p: i64 = o
  var rest: i64 = v
  while div > 0 {
      let dg: i64 = rest / div
      d[p] = (48 + dg) as u8
      rest = rest - dg * div
      div = div / 10
      p = p + 1
  }
  return p
125}
126func sqr_sdec(d: *u8, o: i64, v: i64) -> i64 {
  if v < 0 { d[o] = 45 as u8; return sqr_udec(d, o + 1, 0 - v) }
  return sqr_udec(d, o, v)
129}
130func sqr_hex(d: *u8, o: i64, v: i64) -> i64 {
  let h: *u8 = "0123456789abcdef" as *u8
  var p: i64 = o
  var i: i64 = 15
  while i >= 0 {
      let nib: i64 = (v >> (i * 4)) & 15
      d[p] = h[nib]
      p = p + 1
      i = i - 1
  }
  return p
141}
142
143// ---- SQLite primitives ----
144func sqr_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] as i64
      if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } }
      i = i + 1
  }
  return v
153}
154func sqr_be16(p: *u8, o: i64) -> i64 { let a: i64 = p[o]; let b: i64 = p[o + 1]; return (a << 8) | b }
155func sqr_be32(p: *u8, o: i64) -> i64 {
  let a: i64 = p[o]; let b: i64 = p[o + 1]; let c: i64 = p[o + 2]; let d: i64 = p[o + 3]
  return (((((a << 8) | b) << 8) | c) << 8) | d
158}
159func sqr_varint(p: *u8, o: i64, lenout: *i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while i < 8 {
      let b: i64 = p[o + i]
      if b < 128 { v = (v << 7) | b; lenout[0] = i + 1; return v }
      v = (v << 7) | (b - 128)
      i = i + 1
  }
  let b9: i64 = p[o + 8]
  v = (v << 8) | b9
  lenout[0] = 9
  return v
172}
173func sqr_stsize(st: i64) -> i64 {
  if st == 0 { return 0 }
  if st == 1 { return 1 }
  if st == 2 { return 2 }
  if st == 3 { return 3 }
  if st == 4 { return 4 }
  if st == 5 { return 6 }
  if st == 6 { return 8 }
  if st == 7 { return 8 }
  if st == 8 { return 0 }
  if st == 9 { return 0 }
  if st >= 12 {
      let m: i64 = st % 2
      if m == 0 { return (st - 12) / 2 }
      return (st - 13) / 2
  }
  return 0
190}
191// big-endian TWOS-COMPLEMENT integer of n bytes (explicit sign fix -- never relies on >> semantics)
192func sqr_sint(p: *u8, o: i64, n: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while i < n { v = (v << 8) | (p[o + i] as i64); i = i + 1 }
  if n < 8 {
      if n > 0 {
          var sb: i64 = 1
          var k: i64 = 0
          while k < n * 8 - 1 { sb = sb * 2; k = k + 1 }
          if (v & sb) != 0 { v = v - sb * 2 }
      }
  }
  return v
205}
206func sqr_page(db: *u8, ps: i64, pgno: i64) -> *u8 { let base: i64 = db as i64; return (base + (pgno - 1) * ps) as *u8 }
207
208// IEEE754 double -> value*1000 (3 decimals). okbox[0]=1 ok, 0 = out of representable range.
209func sqr_f64_milli(bits: i64, okbox: *i64) -> i64 {
  okbox[0] = 1
  let sign: i64 = (bits >> 63) & 1
  let exp: i64 = (bits >> 52) & SQR_MAGIC_2047
  let man: i64 = bits & SQR_MAGIC_4503599627370495
  if exp == 0 { return 0 }
  if exp == SQR_MAGIC_2047 { okbox[0] = 0; return 0 }
  let m: i64 = man + SQR_MAGIC_4503599627370496
  let e: i64 = exp - SQR_MAGIC_1075
  var r: i64 = 0
  if e >= 0 {
      if e > 9 { okbox[0] = 0; return 0 }
      r = m * 1000
      var i: i64 = 0
      while i < e { r = r * 2; i = i + 1 }
  } else {
      let sh: i64 = 0 - e
      if sh > 62 { return 0 }
      r = (m * 1000) >> sh
  }
  if sign == 1 { r = 0 - r }
  return r
231}
232func sqr_emit_f64(d: *u8, o: i64, bits: i64) -> i64 {
  let ok: *i64 = sys_mmap(16) as *i64
  let mv: i64 = sqr_f64_milli(bits, ok)
  if ok[0] == 0 { var p: i64 = sqr_ch(d, o, 120); return sqr_hex(d, p, bits) }
  var v: i64 = mv
  var p2: i64 = o
  if v < 0 { p2 = sqr_ch(d, p2, 45); v = 0 - v }
  p2 = sqr_udec(d, p2, v / 1000)
  p2 = sqr_ch(d, p2, 46)
  let frac: i64 = v % 1000
  p2 = sqr_ch(d, p2, 48 + (frac / 100))
  p2 = sqr_ch(d, p2, 48 + ((frac / 10) % 10))
  p2 = sqr_ch(d, p2, 48 + (frac % 10))
  return p2
246}
247
248// ---- payload assembly (LOCAL + OVERFLOW CHAIN) = the rung-2 keystone ----
249// returns payload length, or -1 on cap/format failure; ridbox[0] = rowid
250func sqr_assemble(db: *u8, ps: i64, usable: i64, pg: *u8, coff: i64, out: *u8, cap: i64, ridbox: *i64) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  var o: i64 = coff
  let plen: i64 = sqr_varint(pg, o, lp)
  o = o + lp[0]
  let rid: i64 = sqr_varint(pg, o, lp)
  o = o + lp[0]
  ridbox[0] = rid
  sys_munmap(lp as *u8, 16)
  if plen < 0 { return 0 - 1 }
  if plen > cap { return 0 - 1 }
  // SQLite table-leaf local-payload formula (file-format spec section 1.6)
  let x: i64 = usable - 35
  var local: i64 = plen
  if plen > x {
      let mmin: i64 = ((usable - 12) * 32 / 255) - 23
      let k: i64 = mmin + ((plen - mmin) % (usable - 4))
      if k <= x { local = k } else { local = mmin }
  }
  var w: i64 = 0
  var i: i64 = 0
  while i < local { out[w] = pg[o + i]; w = w + 1; i = i + 1 }
  if local < plen {
      var nxt: i64 = sqr_be32(pg, o + local)
      while nxt != 0 {
          if w >= plen { nxt = 0 } else {
              let op: *u8 = sqr_page(db, ps, nxt)
              let nn: i64 = sqr_be32(op, 0)
              let avail: i64 = usable - 4
              var j: i64 = 0
              while j < avail {
                  if w < plen { out[w] = op[4 + j]; w = w + 1 }
                  j = j + 1
              }
              nxt = nn
          }
      }
  }
  if w != plen { return 0 - 1 }
  return plen
290}
291
292// record header -> per-column serial type + data offset/len. returns ncols, -1 on overflow of MAXCOL.
293func sqr_decode(pay: *u8, plen: i64, offs: *i64, lens: *i64, typs: *i64) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  var o: i64 = 0
  let hlen: i64 = sqr_varint(pay, o, lp)
  o = o + lp[0]
  var n: i64 = 0
  var dat: i64 = hlen
  var bad: i64 = 0
  while o < hlen {
      if n >= SQR_MAXCOL { bad = 1; o = hlen } else {
          let st: i64 = sqr_varint(pay, o, lp)
          o = o + lp[0]
          typs[n] = st
          offs[n] = dat
          let sz: i64 = sqr_stsize(st)
          lens[n] = sz
          dat = dat + sz
          n = n + 1
      }
  }
  sys_munmap(lp as *u8, 16)
  if bad == 1 { return 0 - 1 }
  if dat > plen { return 0 - 1 }
  return n
317}
318
319// ---- sqlite_master: name -> rootpage + CREATE sql (5 columns) ----
320// finds table `want`; returns rootpage (0 = not found). sqlbox/sqllen receive the CREATE TABLE text.
321func sqr_master_find(db: *u8, ps: i64, usable: i64, pgno: i64, want: *u8, sqlbuf: *u8, sqllen: *i64) -> i64 {
  let pg: *u8 = sqr_page(db, ps, pgno)
  var hdr: i64 = 0
  if pgno == 1 { hdr = 100 }
  let pt: i64 = pg[hdr]
  let ncell: i64 = sqr_be16(pg, hdr + 3)
  if pt == 5 {
      var i: i64 = 0
      var found: i64 = 0
      while i < ncell {
          if found == 0 {
              let cp: i64 = sqr_be16(pg, hdr + 12 + 2 * i)
              let r: i64 = sqr_master_find(db, ps, usable, sqr_be32(pg, cp), want, sqlbuf, sqllen)
              if r > 0 { found = r }
          }
          i = i + 1
      }
      if found == 0 { found = sqr_master_find(db, ps, usable, sqr_be32(pg, hdr + 8), want, sqlbuf, sqllen) }
      return found
  }
  if pt != 13 { return 0 }
  let pay: *u8 = sys_mmap(SQR_MAGIC_1048576)
  let offs: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let lens: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let typs: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let rid: *i64 = sys_mmap(16) as *i64
  var res: i64 = 0
  var i2: i64 = 0
  while i2 < ncell {
      if res == 0 {
          let cp2: i64 = sqr_be16(pg, hdr + 8 + 2 * i2)
          let plen: i64 = sqr_assemble(db, ps, usable, pg, cp2, pay, SQR_MAGIC_1048576, rid)
          if plen > 0 {
              let nc: i64 = sqr_decode(pay, plen, offs, lens, typs)
              if nc >= 5 {
                  // col0 type ('table'), col1 name, col3 rootpage, col4 sql
                  var istab: i64 = 0
                  if lens[0] == 5 {
                      let t0: i64 = offs[0]
                      if pay[t0] == (116 as u8) { if pay[t0+1] == (97 as u8) { if pay[t0+2] == (98 as u8) { if pay[t0+3] == (108 as u8) { if pay[t0+4] == (101 as u8) { istab = 1 } } } } }
                  }
                  if istab == 1 {
                      var nameeq: i64 = 1
                      let wl: i64 = sqr_len(want)
                      if lens[1] != wl { nameeq = 0 } else {
                          var k: i64 = 0
                          while k < wl { if pay[offs[1] + k] != want[k] { nameeq = 0 } k = k + 1 }
                      }
                      if nameeq == 1 {
                          var rp: i64 = 0
                          if typs[3] == 9 { rp = 1 }
                          if typs[3] >= 1 { if typs[3] <= 6 { rp = sqr_sint(pay, offs[3], lens[3]) } }
                          var sl: i64 = lens[4]
                          if sl > SQR_MAGIC_65000 { sl = SQR_MAGIC_65000 }
                          var j: i64 = 0
                          while j < sl { sqlbuf[j] = pay[offs[4] + j]; j = j + 1 }
                          sqlbuf[sl] = 0 as u8
                          sqllen[0] = sl
                          res = rp
                      }
                  }
              }
          }
      }
      i2 = i2 + 1
  }
  sys_munmap(pay, SQR_MAGIC_1048576)
  sys_munmap(offs as *u8, 8 * SQR_MAXCOL)
  sys_munmap(lens as *u8, 8 * SQR_MAXCOL)
  sys_munmap(typs as *u8, 8 * SQR_MAXCOL)
  sys_munmap(rid as *u8, 16)
  return res
393}
394
395// list every table (name + rootpage) -- for the `tables` verb
396func sqr_master_list(db: *u8, ps: i64, usable: i64, pgno: i64, names: *u8, npos: *i64, noff: *i64, roots: *i64, cnt: *i64) -> i64 {
  let pg: *u8 = sqr_page(db, ps, pgno)
  var hdr: i64 = 0
  if pgno == 1 { hdr = 100 }
  let pt: i64 = pg[hdr]
  let ncell: i64 = sqr_be16(pg, hdr + 3)
  if pt == 5 {
      var i: i64 = 0
      while i < ncell {
          let cp: i64 = sqr_be16(pg, hdr + 12 + 2 * i)
          sqr_master_list(db, ps, usable, sqr_be32(pg, cp), names, npos, noff, roots, cnt)
          i = i + 1
      }
      sqr_master_list(db, ps, usable, sqr_be32(pg, hdr + 8), names, npos, noff, roots, cnt)
      return 0
  }
  if pt != 13 { return 0 }
  let pay: *u8 = sys_mmap(SQR_MAGIC_1048576)
  let offs: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let lens: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let typs: *i64 = sys_mmap(8 * SQR_MAXCOL) as *i64
  let rid: *i64 = sys_mmap(16) as *i64
  var i2: i64 = 0
  while i2 < ncell {
      let cp2: i64 = sqr_be16(pg, hdr + 8 + 2 * i2)
      let plen: i64 = sqr_assemble(db, ps, usable, pg, cp2, pay, SQR_MAGIC_1048576, rid)
      if plen > 0 {
          let nc: i64 = sqr_decode(pay, plen, offs, lens, typs)
          if nc >= 4 {
              var istab: i64 = 0
              if lens[0] == 5 {
                  let t0: i64 = offs[0]
                  if pay[t0] == (116 as u8) { if pay[t0+1] == (97 as u8) { if pay[t0+2] == (98 as u8) { if pay[t0+3] == (108 as u8) { if pay[t0+4] == (101 as u8) { istab = 1 } } } } }
              }
              if istab == 1 {
                  let k: i64 = cnt[0]
                  noff[k] = npos[0]
                  var j: i64 = 0
                  while j < lens[1] { names[npos[0] + j] = pay[offs[1] + j]; j = j + 1 }
                  names[npos[0] + lens[1]] = 0 as u8
                  npos[0] = npos[0] + lens[1] + 1
                  var rp: i64 = 0
                  if typs[3] == 9 { rp = 1 }
                  if typs[3] >= 1 { if typs[3] <= 6 { rp = sqr_sint(pay, offs[3], lens[3]) } }
                  roots[k] = rp
                  cnt[0] = k + 1
              }
          }
      }
      i2 = i2 + 1
  }
  sys_munmap(pay, SQR_MAGIC_1048576)
  sys_munmap(offs as *u8, 8 * SQR_MAXCOL)
  sys_munmap(lens as *u8, 8 * SQR_MAXCOL)
  sys_munmap(typs as *u8, 8 * SQR_MAXCOL)
  sys_munmap(rid as *u8, 16)
  return 0
453}
454
455// ---- CREATE TABLE sql -> column names (+ which column is the INTEGER PRIMARY KEY rowid alias) ----
456func sqr_upch(c: i64) -> i64 { if c >= 97 { if c <= 122 { return c - 32 } } return c }
457// does seg[s..e) contain the uppercase word w?
458func sqr_hasword(sql: *u8, s: i64, e: i64, w: *u8) -> i64 {
  let wl: i64 = sqr_len(w)
  var i: i64 = s
  while i + wl <= e {
      var m: i64 = 1
      var j: i64 = 0
      while j < wl { if sqr_upch(sql[i + j] as i64) != (w[j] as i64) { m = 0 } j = j + 1 }
      if m == 1 { return 1 }
      i = i + 1
  }
  return 0
469}
470func sqr_isname(c: i64) -> i64 {
  if c >= 48 { if c <= 57 { return 1 } }
  if c >= 65 { if c <= 90 { return 1 } }
  if c >= 97 { if c <= 122 { return 1 } }
  if c == 95 { return 1 }
  return 0
476}
477// returns ncols; names -> nul-separated, noff -> offsets; aliasbox[0] = rowid-alias col index (-1 none)
478func sqr_parse_cols(sql: *u8, sqllen: i64, names: *u8, noff: *i64, aliasbox: *i64) -> i64 {
  aliasbox[0] = 0 - 1
  var i: i64 = 0
  var open: i64 = 0 - 1
  while i < sqllen {
      if open < 0 { if sql[i] == (40 as u8) { open = i } }
      i = i + 1
  }
  if open < 0 { return 0 }
  var n: i64 = 0
  var npos: i64 = 0
  var depth: i64 = 0
  var segs: i64 = open + 1
  var p: i64 = open + 1
  var go: i64 = 1
  while go == 1 {
      if p >= sqllen { go = 0 }
      if go == 1 {
          let c: i64 = sql[p] as i64
          var cut: i64 = 0
          if c == 40 { depth = depth + 1 }
          if c == 41 {
              if depth == 0 { cut = 1; go = 0 } else { depth = depth - 1 }
          }
          if depth == 0 { if c == 44 { cut = 1 } }
          if cut == 1 {
              // segment [segs, p) -- first identifier token is the column name
              // NOTE: exit these scans with a FLAG, never by clobbering the index (the
              // "s = p + 999" trick lost the real position -> every column name came out
              // empty; caught by gate T2 on first run).
              var s: i64 = segs
              var sd: i64 = 0
              while sd == 0 {
                  if s >= p { sd = 1 } else {
                      let cc: i64 = sql[s] as i64
                      var sk: i64 = 0
                      if cc == 32 { sk = 1 }
                      if cc == 10 { sk = 1 }
                      if cc == 9 { sk = 1 }
                      if cc == 13 { sk = 1 }
                      if cc == 34 { sk = 1 }
                      if cc == 96 { sk = 1 }
                      if cc == 91 { sk = 1 }
                      if sk == 1 { s = s + 1 } else { sd = 1 }
                  }
              }
              var e: i64 = s
              var ed: i64 = 0
              while ed == 0 {
                  if e >= p { ed = 1 } else {
                      if sqr_isname(sql[e] as i64) == 1 { e = e + 1 } else { ed = 1 }
                  }
              }
              var kw: i64 = 0
              if sqr_hasword(sql, s, e, "CONSTRAINT" as *u8) == 1 { kw = 1 }
              if sqr_hasword(sql, s, e, "PRIMARY" as *u8) == 1 { kw = 1 }
              if sqr_hasword(sql, s, e, "UNIQUE" as *u8) == 1 { kw = 1 }
              if sqr_hasword(sql, s, e, "CHECK" as *u8) == 1 { kw = 1 }
              if sqr_hasword(sql, s, e, "FOREIGN" as *u8) == 1 { kw = 1 }
              if e > s { if kw == 0 { if n < SQR_MAXCOL {
                  noff[n] = npos
                  var j: i64 = s
                  while j < e { names[npos] = sql[j]; npos = npos + 1; j = j + 1 }
                  names[npos] = 0 as u8
                  npos = npos + 1
                  // INTEGER PRIMARY KEY in this segment == the rowid alias (stored NULL in the record)
                  if sqr_hasword(sql, s, p, "INTEGER" as *u8) == 1 {
                      if sqr_hasword(sql, s, p, "PRIMARY" as *u8) == 1 { aliasbox[0] = n }
                  }
                  n = n + 1
              } } }
              segs = p + 1
          }
          p = p + 1
      }
  }
  return n
555}
556
557// NXR1 field read (DRY note in header: 2nd copy of mv_rec_field's walk)
558func sqr_r32(p: *u8, o: i64) -> i64 {
  let a: i64 = p[o]; let b: i64 = p[o+1]; let c: i64 = p[o+2]; let d: i64 = p[o+3]
  return (((((a << 8) | b) << 8) | c) << 8) | d
561}
562func sqr_rec_field(rec: *u8, reclen: i64, key: *u8, outp: *i64, outl: *i64) -> i64 {
  if reclen < 8 { return 0 }
  if rec[0] != (78 as u8) { return 0 }
  let klen: i64 = sqr_len(key)
  let n: i64 = sqr_r32(rec, 4)
  var off: i64 = 8
  var i: i64 = 0
  while i < n {
      let kl: i64 = sqr_r32(rec, off); off = off + 4
      let kp: i64 = off; off = off + kl
      let vl: i64 = sqr_r32(rec, off); off = off + 4
      let vp: i64 = off; off = off + vl
      if kl == klen {
          var m: i64 = 1
          var c: i64 = 0
          while c < kl { if rec[kp + c] != key[c] { m = 0 } c = c + 1 }
          if m == 1 { outp[0] = (rec as i64) + vp; outl[0] = vl; return 1 }
      }
      i = i + 1
  }
  return 0
583}
584
585// dump every field of an NXR1 record (the `get` verb's printer)
586func sqr_rec_dump(rec: *u8, reclen: i64) -> i64 {
  if reclen < 8 { return 0 }
  if rec[0] != (78 as u8) { sqr_puts("NX-SQR NOT-NXR1\n" as *u8); return 0 }
  let n: i64 = sqr_r32(rec, 4)
  let line: *u8 = sys_mmap(SQR_LINE)
  var off: i64 = 8
  var i: i64 = 0
  while i < n {
      let kl: i64 = sqr_r32(rec, off); off = off + 4
      let kp: i64 = off; off = off + kl
      let vl: i64 = sqr_r32(rec, off); off = off + 4
      let vp: i64 = off; off = off + vl
      var o: i64 = 0
      var j: i64 = 0
      while j < kl { line[o] = rec[kp + j]; o = o + 1; j = j + 1 }
      o = sqr_ch(line, o, 61)
      j = 0
      while j < vl {
          let b: i64 = rec[vp + j] as i64
          if b == 10 { o = sqr_cat(line, o, "\\n" as *u8) } else { o = sqr_ch(line, o, b) }
          j = j + 1
      }
      o = sqr_ch(line, o, 10)
      sys_write(1, line, o)
      i = i + 1
  }
  sys_munmap(line, SQR_LINE)
  return n
614}
615
616// ---- per-row handler (dump / plane) ----
617func sqr_row(ctx: *i64, rowid: i64, nrec: i64) -> i64 {
  let mode: i64 = ctx[CX_MODE]
  // range window: SEEN counts every row the walk reaches; ROWS counts only emitted ones, so the
  // walk's max-rows stop still means "emitted", and skip+count carve a clean, resumable slice.
  ctx[CX_SEEN] = ctx[CX_SEEN] + 1
  if ctx[CX_SEEN] <= ctx[CX_SKIP] { return 0 }
  ctx[CX_ROWS] = ctx[CX_ROWS] + 1
  if ctx[CX_MINR] == 0 { ctx[CX_MINR] = rowid }
  ctx[CX_MAXR] = rowid
  if mode == 0 { return 0 }
  let pay: *u8 = ctx[CX_PAY] as *u8
  let offs: *i64 = ctx[CX_OFFS] as *i64
  let lens: *i64 = ctx[CX_LENS] as *i64
  let typs: *i64 = ctx[CX_TYPS] as *i64
  let names: *u8 = ctx[CX_NAMB] as *u8
  let noff: *i64 = ctx[CX_NAMO] as *i64
  let ncol: i64 = ctx[CX_NCOL]
  let alias: i64 = ctx[CX_ALIA]
  var nc: i64 = nrec
  if ncol > 0 { if ncol < nc { nc = ncol } }
  if mode == 3 {
      if rowid == ctx[CX_CAPID] {
          let cc: i64 = ctx[CX_CAPCOL]
          if cc < nrec {
              ctx[CX_CAPT] = typs[cc]
              ctx[CX_CAPL] = lens[cc]
              ctx[CX_CAPV] = 0
              if typs[cc] >= 1 { if typs[cc] <= 6 { ctx[CX_CAPV] = sqr_sint(pay, offs[cc], lens[cc]) } }
              let cb: *u8 = ctx[CX_CAPP] as *u8
              var j3: i64 = 0
              while j3 < lens[cc] { cb[j3] = pay[offs[cc] + j3]; j3 = j3 + 1 }
          }
      }
      return 0
  }
  if mode == 1 {
      let line: *u8 = ctx[CX_LINE] as *u8
      var o: i64 = sqr_udec(line, 0, rowid)
      var c: i64 = 0
      while c < nc {
          o = sqr_ch(line, o, 9)
          let st: i64 = typs[c]
          var handled: i64 = 0
          if st == 0 {
              if c == alias { o = sqr_udec(line, o, rowid) } else { o = sqr_cat(line, o, "\\N" as *u8) }
              handled = 1
          }
          if handled == 0 { if st == 8 { o = sqr_ch(line, o, 48); handled = 1 } }
          if handled == 0 { if st == 9 { o = sqr_ch(line, o, 49); handled = 1 } }
          if handled == 0 { if st <= 6 { o = sqr_sdec(line, o, sqr_sint(pay, offs[c], lens[c])); handled = 1 } }
          if handled == 0 { if st == 7 { o = sqr_emit_f64(line, o, sqr_sint(pay, offs[c], 8)); handled = 1 } }
          if handled == 0 {
              var j: i64 = 0
              while j < lens[c] {
                  let b: i64 = pay[offs[c] + j] as i64
                  if b == 9 { o = sqr_cat(line, o, "\\t" as *u8) } else {
                      if b == 10 { o = sqr_cat(line, o, "\\n" as *u8) } else {
                          if b == 92 { o = sqr_cat(line, o, "\\\\" as *u8) } else { o = sqr_ch(line, o, b) }
                      }
                  }
                  j = j + 1
              }
          }
          c = c + 1
      }
      o = sqr_ch(line, o, 10)
      sys_write(1, line, o)
      return 0
  }
  // mode 2 -- land one NXR1 record (absent field == SQL NULL, lossless)
  let keys: *i64 = ctx[CX_KEYS] as *i64
  let vals: *i64 = ctx[CX_VALS] as *i64
  let arena: *u8 = ctx[CX_AREN] as *u8
  var ap: i64 = 0
  var nf: i64 = 0
  var c2: i64 = 0
  while c2 < nc {
      let st: i64 = typs[c2]
      var skip: i64 = 0
      if st == 0 { if c2 != alias { skip = 1 } }
      if skip == 0 {
          let vstart: i64 = ap
          if st == 0 { ap = sqr_udec(arena, ap, rowid) } else {
              if st == 8 { ap = sqr_ch(arena, ap, 48) } else {
                  if st == 9 { ap = sqr_ch(arena, ap, 49) } else {
                      if st <= 6 { ap = sqr_sdec(arena, ap, sqr_sint(pay, offs[c2], lens[c2])) } else {
                          if st == 7 { ap = sqr_emit_f64(arena, ap, sqr_sint(pay, offs[c2], 8)) } else {
                              var j2: i64 = 0
                              while j2 < lens[c2] { arena[ap] = pay[offs[c2] + j2]; ap = ap + 1; j2 = j2 + 1 }
                          }
                      }
                  }
              }
          }
          arena[ap] = 0 as u8
          ap = ap + 1
          keys[nf] = ((names as i64) + noff[c2])
          vals[nf] = (arena as i64) + vstart
          nf = nf + 1
      }
      c2 = c2 + 1
  }
  let rec: *u8 = ctx[CX_REC] as *u8
  let rl: i64 = canon_encode(keys, vals, nf, rec)
  let kbuf: *u8 = ctx[CX_KBUF] as *u8
  var ko: i64 = sqr_cat(kbuf, 0, ctx[CX_TAB] as *u8)
  ko = sqr_ch(kbuf, ko, 58)
  ko = sqr_udec(kbuf, ko, rowid)
  kbuf[ko] = 0 as u8
  let w: *i64 = ctx[CX_W] as *i64
  if ss_add(w, 1, kbuf, rec, rl) < 0 { ctx[CX_ERR] = 1 }
  // chunked planing: commit + start a fresh writer once the batch is large, so an arbitrarily
  // large table lands as N segments instead of hitting the writer cap and failing closed.
  // Keys are unique per row, so splitting across segments stays correct for readers.
  if ctx[CX_ERR] == 0 {
      if w[1] > SQR_FLUSH {
          let pfx: *u8 = ctx[CX_PFX] as *u8
          if ss_commit(pfx, w, ss_next_segid(pfx)) != 0 { ctx[CX_ERR] = 4 } else {
              sys_munmap(w[0] as *u8, w[2])
              sys_munmap(w as *u8, 32)
              ctx[CX_W] = (ss_begin_cap(SQR_WCAP)) as i64
              ctx[CX_SEGN] = ctx[CX_SEGN] + 1
          }
      }
  }
  return 0
743}
744
745// ---- b-tree walk ----
746func sqr_walk(ctx: *i64, pgno: i64) -> i64 {
  if ctx[CX_ERR] != 0 { return 0 }
  let db: *u8 = ctx[CX_DB] as *u8
  let ps: i64 = ctx[CX_PS]
  let usable: i64 = ctx[CX_USE]
  let pg: *u8 = sqr_page(db, ps, pgno)
  var hdr: i64 = 0
  if pgno == 1 { hdr = 100 }
  let pt: i64 = pg[hdr]
  let ncell: i64 = sqr_be16(pg, hdr + 3)
  if pt == 5 {
      var i: i64 = 0
      while i < ncell {
          let cp: i64 = sqr_be16(pg, hdr + 12 + 2 * i)
          sqr_walk(ctx, sqr_be32(pg, cp))
          i = i + 1
      }
      sqr_walk(ctx, sqr_be32(pg, hdr + 8))
      return 0
  }
  if pt != 13 { return 0 }
  let pay: *u8 = ctx[CX_PAY] as *u8
  let offs: *i64 = ctx[CX_OFFS] as *i64
  let lens: *i64 = ctx[CX_LENS] as *i64
  let typs: *i64 = ctx[CX_TYPS] as *i64
  let rid: *i64 = sys_mmap(16) as *i64
  var i2: i64 = 0
  while i2 < ncell {
      var stop: i64 = 0
      if ctx[CX_MAX] > 0 { if ctx[CX_ROWS] >= ctx[CX_MAX] { stop = 1 } }
      if ctx[CX_ERR] != 0 { stop = 1 }
      if stop == 0 {
          let cp2: i64 = sqr_be16(pg, hdr + 8 + 2 * i2)
          let plen: i64 = sqr_assemble(db, ps, usable, pg, cp2, pay, SQR_ROWCAP, rid)
          if plen < 0 { ctx[CX_ERR] = 2 } else {
              let nc: i64 = sqr_decode(pay, plen, offs, lens, typs)
              if nc < 0 { ctx[CX_ERR] = 3 } else { sqr_row(ctx, rid[0], nc) }
          }
      }
      i2 = i2 + 1
  }
  sys_munmap(rid as *u8, 16)
  return 0
789}
790
791// ---- open + prep ----
792// OPEN = READ-ONLY FILE-BACKED MMAP (sys_map_file: PROT_READ, MAP_PRIVATE, zero-copy, lazy pages).
793// ★MEASURED, AND IT REFUTED HALF MY REASON FOR THE SWAP (2026-07-23, tracking.db 6.3GB over WSL /mnt/c):
794//   sys_read_file  525s / 6,184,448KB RSS      sys_map_file  694s / 5,394,176KB RSS
795// So mapping is ~32% SLOWER for a FULL scan and only ~13% lighter -- because `tables` counts rows in
796// every table, i.e. it touches essentially every page, so lazy paging buys nothing and page-fault
797// overhead over the 9p mount costs real time. Kept anyway, for two reasons that DO hold:
798//   (1) SELECTIVE access (one table, or `get` by key) touches a tiny fraction of pages -- that is where
799//       mapping wins, and it is the shape the F942 mine will actually use;
800//   (2) PROT_READ makes "never mutate the source DB" true BY CONSTRUCTION (a write faults).
801// If a full-corpus scan ever becomes the hot path, offer read-file as an opt-in flag rather than
802// re-litigating this -- the numbers above are the record.
803func sqr_open(path: *u8, dbbox: *i64, psbox: *i64, usebox: *i64) -> i64 {
  let lenp: *i64 = sys_mmap(16) as *i64
  let db: *u8 = sys_map_file(path, lenp)
  if (db as i64) == 0 { return 0 - 1 }
  if lenp[0] < 512 { return 0 - 2 }
  if sqr_be16(db, 0) != SQR_MAGIC_21329 { return 0 - 3 }
  var ps: i64 = sqr_be16(db, 16)
  if ps == 1 { ps = SQR_MAGIC_65536 }
  dbbox[0] = db as i64
  psbox[0] = ps
  usebox[0] = ps - (db[20] as i64)
  return lenp[0]
815}
816func sqr_ctx_new() -> *i64 {
  let ctx: *i64 = sys_mmap(8 * 40) as *i64
  var i: i64 = 0
  while i < 40 { ctx[i] = 0; i = i + 1 }
  ctx[CX_PAY]  = (sys_mmap(SQR_ROWCAP)) as i64
  ctx[CX_OFFS] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_LENS] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_TYPS] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_NAMB] = (sys_mmap(SQR_NAMES)) as i64
  ctx[CX_NAMO] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_KEYS] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_VALS] = (sys_mmap(8 * SQR_MAXCOL)) as i64
  ctx[CX_AREN] = (sys_mmap(SQR_ARENA)) as i64
  ctx[CX_REC]  = (sys_mmap(SQR_ARENA)) as i64
  ctx[CX_KBUF] = (sys_mmap(SQR_MAGIC_1024)) as i64
  ctx[CX_LINE] = (sys_mmap(SQR_LINE)) as i64
  ctx[CX_CAPP] = (sys_mmap(SQR_MAGIC_1048576)) as i64
  ctx[CX_ALIA] = 0 - 1
  return ctx
835}
836
837// ---- selftest ----
838func sqr_tooth(name: *u8, ok: i64, pass: *i64) -> i64 {
  sqr_puts(name)
  if ok == 1 { sqr_puts(": PASS\n" as *u8); pass[0] = pass[0] + 1 } else { sqr_puts(": FAIL\n" as *u8) }
  return 0
842}
843func sqr_selftest() -> i64 {
  let pass: *i64 = sys_mmap(16) as *i64
  pass[0] = 0
  // deterministic re-runs: drop the T8 scratch plane (data files, never a lock file)
  let nb0: *u8 = sys_mmap(256)
  sys_unlinkat("sqrgate-manifest.txt" as *u8)
  var sg: i64 = 0
  while sg < 4 {
      var no: i64 = sqr_cat(nb0, 0, "sqrgate-seg-" as *u8)
      no = sqr_udec(nb0, no, sg)
      let base: i64 = no
      no = sqr_cat(nb0, base, ".docs" as *u8); nb0[no] = 0 as u8; sys_unlinkat(nb0)
      no = sqr_cat(nb0, base, ".idx" as *u8);  nb0[no] = 0 as u8; sys_unlinkat(nb0)
      no = sqr_cat(nb0, base, ".pos" as *u8);  nb0[no] = 0 as u8; sys_unlinkat(nb0)
      sg = sg + 1
  }
  let dbb: *i64 = sys_mmap(16) as *i64
  let psb: *i64 = sys_mmap(16) as *i64
  let usb: *i64 = sys_mmap(16) as *i64
  let fx: *u8 = "sqr_fixture.db" as *u8
  let sz: i64 = sqr_open(fx, dbb, psb, usb)
  var t0: i64 = 0
  if sz > 0 { if psb[0] == SQR_MAGIC_4096 { t0 = 1 } }
  sqr_tooth("T0 open+magic+pagesize" as *u8, t0, pass)
  // FAIL LOUD, never SIGSEGV: without the fixture every later tooth would deref a null db
  // (hit live 2026-07-23 running the gate from a cwd with no fixture -> exit 139).
  if t0 == 0 {
      sqr_puts("nx_sqlite_rows selftest T=8 PASS=0 verdict=RED (fixture sqr_fixture.db absent in cwd)\n" as *u8)
      return 1
  }
  let db: *u8 = dbb[0] as *u8
  let ps: i64 = psb[0]
  let usable: i64 = usb[0]
  let sqlbuf: *u8 = sys_mmap(SQR_MAGIC_65536)
  let sqll: *i64 = sys_mmap(16) as *i64
  let rootS: i64 = sqr_master_find(db, ps, usable, 1, "t_small" as *u8, sqlbuf, sqll)
  var t1: i64 = 0
  if rootS > 0 { if sqll[0] > 10 { t1 = 1 } }
  sqr_tooth("T1 master_find t_small root+sql" as *u8, t1, pass)
  // T2 columns parsed + rowid alias detected
  let ctx: *i64 = sqr_ctx_new()
  let alias: *i64 = sys_mmap(16) as *i64
  let nco: i64 = sqr_parse_cols(sqlbuf, sqll[0], ctx[CX_NAMB] as *u8, ctx[CX_NAMO] as *i64, alias)
  var t2: i64 = 0
  if nco == 4 { if alias[0] == 0 {
      let nb: *u8 = ctx[CX_NAMB] as *u8
      let no: *i64 = ctx[CX_NAMO] as *i64
      if sqr_eq(((nb as i64) + no[1]) as *u8, "name" as *u8) == 1 {
          if sqr_eq(((nb as i64) + no[3]) as *u8, "note" as *u8) == 1 { t2 = 1 }
      }
  } }
  sqr_tooth("T2 parse_cols 4 + rowid-alias" as *u8, t2, pass)
  // T3 count t_small == 3
  ctx[CX_DB] = db as i64; ctx[CX_PS] = ps; ctx[CX_USE] = usable
  ctx[CX_MODE] = 0; ctx[CX_ROWS] = 0; ctx[CX_MAX] = 0; ctx[CX_ERR] = 0
  sqr_walk(ctx, rootS)
  var t3: i64 = 0
  if ctx[CX_ROWS] == 3 { if ctx[CX_ERR] == 0 { t3 = 1 } }
  sqr_tooth("T3 count t_small == 3" as *u8, t3, pass)
  // T4 count t_many == 1000 (exercises INTERIOR-page recursion)
  let rootM: i64 = sqr_master_find(db, ps, usable, 1, "t_many" as *u8, sqlbuf, sqll)
  ctx[CX_MODE] = 0; ctx[CX_ROWS] = 0; ctx[CX_ERR] = 0
  sqr_walk(ctx, rootM)
  var t4: i64 = 0
  if ctx[CX_ROWS] == 1000 { if ctx[CX_ERR] == 0 { t4 = 1 } }
  sqr_tooth("T4 count t_many == 1000 (interior)" as *u8, t4, pass)
  // T5 = THE RUNG-2 KEYSTONE: a 20000-byte value spanning OVERFLOW PAGES comes back byte-exact.
  // Rule-verified (char i == 'a' + i%26) so the tooth cannot drift against a baked constant.
  ctx[CX_MODE] = 3; ctx[CX_ROWS] = 0; ctx[CX_ERR] = 0; ctx[CX_MAX] = 0
  ctx[CX_CAPID] = 3; ctx[CX_CAPCOL] = 3; ctx[CX_CAPL] = 0 - 1
  sqr_walk(ctx, rootS)
  var t5: i64 = 0
  if ctx[CX_CAPL] == SQR_MAGIC_20000 {
      let cb: *u8 = ctx[CX_CAPP] as *u8
      var bad: i64 = 0
      var i5: i64 = 0
      while i5 < SQR_MAGIC_20000 {
          if (cb[i5] as i64) != (97 + (i5 % 26)) { bad = 1 }
          i5 = i5 + 1
      }
      if bad == 0 { t5 = 1 }
  }
  sqr_tooth("T5 OVERFLOW 20000B byte-exact" as *u8, t5, pass)
  // T6 two's-complement sign extension (qty == -42, stored as a 1-byte int)
  ctx[CX_MODE] = 3; ctx[CX_ROWS] = 0; ctx[CX_CAPID] = 2; ctx[CX_CAPCOL] = 2; ctx[CX_CAPV] = 0
  sqr_walk(ctx, rootS)
  var t6: i64 = 0
  if ctx[CX_CAPV] == (0 - 42) { t6 = 1 }
  sqr_tooth("T6 negative int == -42" as *u8, t6, pass)
  // T7 SQL NULL survives as serial-type 0 (so the plane can omit the field = lossless NULL)
  ctx[CX_MODE] = 3; ctx[CX_ROWS] = 0; ctx[CX_CAPID] = 1; ctx[CX_CAPCOL] = 3; ctx[CX_CAPT] = 0 - 1
  sqr_walk(ctx, rootS)
  var t7: i64 = 0
  if ctx[CX_CAPT] == 0 { t7 = 1 }
  sqr_tooth("T7 NULL serial-type 0" as *u8, t7, pass)
  // T8 PLANE ROUND-TRIP: land t_small, then ss_get it back -- the overflow value must survive
  // INTO the plane and come back byte-exact, and a NULL column must be ABSENT (lossless NULL).
  let pfx: *u8 = "sqrgate-" as *u8
  ctx[CX_MODE] = 2; ctx[CX_ROWS] = 0; ctx[CX_ERR] = 0; ctx[CX_MAX] = 0
  ctx[CX_NCOL] = nco; ctx[CX_ALIA] = alias[0]; ctx[CX_TAB] = "t_small" as *u8 as i64
  ctx[CX_PFX] = pfx as i64   // chunk-flush needs the prefix even when it will not fire
  ctx[CX_W] = (ss_begin_cap(SQR_WCAP)) as i64
  sqr_walk(ctx, rootS)
  var t8: i64 = 0
  if ctx[CX_ERR] == 0 {
      let wg: *i64 = ctx[CX_W] as *i64
      if ss_commit(pfx, wg, ss_next_segid(pfx)) == 0 {
          let po: *i64 = sys_mmap(16) as *i64
          let lo: *i64 = sys_mmap(16) as *i64
          if ss_get(pfx, "t_small:3" as *u8, po, lo) == 1 {
              let fp: *i64 = sys_mmap(16) as *i64
              let fl: *i64 = sys_mmap(16) as *i64
              if sqr_rec_field(po[0] as *u8, lo[0], "note" as *u8, fp, fl) == 1 {
                  if fl[0] == SQR_MAGIC_20000 {
                      let nb: *u8 = fp[0] as *u8
                      var bad8: i64 = 0
                      var i8: i64 = 0
                      while i8 < SQR_MAGIC_20000 {
                          if (nb[i8] as i64) != (97 + (i8 % 26)) { bad8 = 1 }
                          i8 = i8 + 1
                      }
                      // NULL note on rowid 1 must be ABSENT from that record
                      if ss_get(pfx, "t_small:1" as *u8, po, lo) == 1 {
                          if sqr_rec_field(po[0] as *u8, lo[0], "note" as *u8, fp, fl) == 0 {
                              if bad8 == 0 { t8 = 1 }
                          }
                      }
                  }
              }
          }
      }
  }
  sqr_tooth("T8 plane round-trip 20000B + NULL-absent" as *u8, t8, pass)
  let vb: *u8 = sys_mmap(256)
  var vo: i64 = sqr_cat(vb, 0, "nx_sqlite_rows selftest T=9 PASS=" as *u8)
  vo = sqr_udec(vb, vo, pass[0])
  if pass[0] == 9 { vo = sqr_cat(vb, vo, " verdict=GREEN" as *u8) } else { vo = sqr_cat(vb, vo, " verdict=RED" as *u8) }
  vo = sqr_ch(vb, vo, 10)
  sys_write(1, vb, vo)
  if pass[0] == 9 { return 0 }
  return 1
984}
985
986func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 {
      sqr_puts("usage: nx_sqlite_rows tables <db> | rows <db> <table> [max] | plane <db> <table> <prefix> | selftest\n" as *u8)
      return 2
  }
  let verb: *u8 = (argv[1]) as *u8
  if sqr_eq(verb, "selftest" as *u8) == 1 { return sqr_selftest() }
  // get <prefix> <key> -- read one planed record back (a plane you cannot read is not a deliverable)
  if sqr_eq(verb, "get" as *u8) == 1 {
      if argc < 4 { sqr_puts("usage: get <prefix> <key>\n" as *u8); return 2 }
      let po: *i64 = sys_mmap(16) as *i64
      let lo: *i64 = sys_mmap(16) as *i64
      let rc: i64 = ss_get((argv[2]) as *u8, (argv[3]) as *u8, po, lo)
      if rc < 0 { sqr_puts("NX-SQR NO-SUCH-KEY\n" as *u8); return 4 }
      if rc == 0 { sqr_puts("NX-SQR TOMBSTONED\n" as *u8); return 0 }
      sqr_rec_dump(po[0] as *u8, lo[0])
      return 0
  }
  if argc < 3 { sqr_puts("missing <db>\n" as *u8); return 2 }
  let path: *u8 = (argv[2]) as *u8
  let dbb: *i64 = sys_mmap(16) as *i64
  let psb: *i64 = sys_mmap(16) as *i64
  let usb: *i64 = sys_mmap(16) as *i64
  let sz: i64 = sqr_open(path, dbb, psb, usb)
  if sz < 0 { sqr_puts("NX-SQR OPEN-FAIL (unreadable or not a sqlite file)\n" as *u8); return 3 }
  let db: *u8 = dbb[0] as *u8
  let ps: i64 = psb[0]
  let usable: i64 = usb[0]
  let ctx: *i64 = sqr_ctx_new()
  ctx[CX_DB] = db as i64; ctx[CX_PS] = ps; ctx[CX_USE] = usable
  let sqlbuf: *u8 = sys_mmap(SQR_MAGIC_65536)
  let sqll: *i64 = sys_mmap(16) as *i64
  if sqr_eq(verb, "tables" as *u8) == 1 {
      let names: *u8 = sys_mmap(SQR_NAMES)
      let noff: *i64 = sys_mmap(8 * SQR_MAGIC_4096) as *i64
      let roots: *i64 = sys_mmap(8 * SQR_MAGIC_4096) as *i64
      let cnt: *i64 = sys_mmap(16) as *i64
      let npos: *i64 = sys_mmap(16) as *i64
      cnt[0] = 0; npos[0] = 0
      sqr_master_list(db, ps, usable, 1, names, npos, noff, roots, cnt)
      let line: *u8 = sys_mmap(SQR_MAGIC_4096)
      var i: i64 = 0
      while i < cnt[0] {
          ctx[CX_MODE] = 0; ctx[CX_ROWS] = 0; ctx[CX_MAX] = 0; ctx[CX_ERR] = 0
          if roots[i] > 0 { sqr_walk(ctx, roots[i]) }
          var o: i64 = sqr_cat(line, 0, ((names as i64) + noff[i]) as *u8)
          o = sqr_ch(line, o, 9)
          o = sqr_udec(line, o, roots[i])
          o = sqr_ch(line, o, 9)
          o = sqr_udec(line, o, ctx[CX_ROWS])
          o = sqr_ch(line, o, 10)
          sys_write(1, line, o)
          i = i + 1
      }
      return 0
  }
  if argc < 4 { sqr_puts("missing <table>\n" as *u8); return 2 }
  let table: *u8 = (argv[3]) as *u8
  let root: i64 = sqr_master_find(db, ps, usable, 1, table, sqlbuf, sqll)
  if root <= 0 { sqr_puts("NX-SQR NO-SUCH-TABLE\n" as *u8); return 4 }
  let alias: *i64 = sys_mmap(16) as *i64
  let nco: i64 = sqr_parse_cols(sqlbuf, sqll[0], ctx[CX_NAMB] as *u8, ctx[CX_NAMO] as *i64, alias)
  ctx[CX_NCOL] = nco
  ctx[CX_ALIA] = alias[0]
  ctx[CX_TAB] = table as i64
  if sqr_eq(verb, "rows" as *u8) == 1 {
      ctx[CX_MODE] = 1
      if argc >= 5 {
          var mx: i64 = 0
          let a4: *u8 = (argv[4]) as *u8
          var k: i64 = 0
          while a4[k] != (0 as u8) { mx = mx * 10 + ((a4[k] as i64) - 48); k = k + 1 }
          ctx[CX_MAX] = mx
      }
      sqr_walk(ctx, root)
      return 0
  }
  if sqr_eq(verb, "plane" as *u8) == 1 {
      if argc < 5 { sqr_puts("missing <prefix>\n" as *u8); return 2 }
      let prefix: *u8 = (argv[4]) as *u8
      ctx[CX_MODE] = 2
      ctx[CX_PFX] = prefix as i64
      if argc >= 6 { ctx[CX_SKIP] = sqr_atoi((argv[5]) as *u8) }
      if argc >= 7 { ctx[CX_MAX]  = sqr_atoi((argv[6]) as *u8) }
      ctx[CX_W] = (ss_begin_cap(SQR_WCAP)) as i64
      sqr_walk(ctx, root)
      if ctx[CX_ERR] != 0 { sqr_puts("NX-SQR PLANE-ABORT (walk error, nothing committed)\n" as *u8); return 5 }
      // meta record: only on a FULL run -- a ranged slice must never overwrite <table>:meta with
      // partial counts (the driver logs slice counts instead). Declared, not silent.
      var fullrun: i64 = 0
      if ctx[CX_SKIP] == 0 { if ctx[CX_MAX] == 0 { fullrun = 1 } }
      let keys: *i64 = ctx[CX_KEYS] as *i64
      let vals: *i64 = ctx[CX_VALS] as *i64
      let arena: *u8 = ctx[CX_AREN] as *u8
      var ap: i64 = 0
      let v0: i64 = ap; ap = sqr_udec(arena, ap, ctx[CX_ROWS]); arena[ap] = 0 as u8; ap = ap + 1
      let v1: i64 = ap; ap = sqr_udec(arena, ap, nco); arena[ap] = 0 as u8; ap = ap + 1
      let v2: i64 = ap; ap = sqr_udec(arena, ap, ctx[CX_MINR]); arena[ap] = 0 as u8; ap = ap + 1
      let v3: i64 = ap; ap = sqr_udec(arena, ap, ctx[CX_MAXR]); arena[ap] = 0 as u8; ap = ap + 1
      keys[0] = "rows" as *u8 as i64;   vals[0] = (arena as i64) + v0
      keys[1] = "cols" as *u8 as i64;   vals[1] = (arena as i64) + v1
      keys[2] = "minrow" as *u8 as i64; vals[2] = (arena as i64) + v2
      keys[3] = "maxrow" as *u8 as i64; vals[3] = (arena as i64) + v3
      let rec: *u8 = ctx[CX_REC] as *u8
      let rl: i64 = canon_encode(keys, vals, 4, rec)
      let kbuf: *u8 = ctx[CX_KBUF] as *u8
      var ko: i64 = sqr_cat(kbuf, 0, table)
      ko = sqr_cat(kbuf, ko, ":meta" as *u8)
      kbuf[ko] = 0 as u8
      let w: *i64 = ctx[CX_W] as *i64
      if fullrun == 1 { if ss_add(w, 1, kbuf, rec, rl) < 0 { sqr_puts("NX-SQR META-ADD-FAIL\n" as *u8); return 6 } }
      let segid: i64 = ss_next_segid(prefix)
      if ss_commit(prefix, w, segid) != 0 { sqr_puts("NX-SQR COMMIT-FAIL\n" as *u8); return 7 }
      let line: *u8 = sys_mmap(SQR_MAGIC_1024)
      var o: i64 = sqr_cat(line, 0, "NX-SQR PLANED table=" as *u8)
      o = sqr_cat(line, o, table)
      o = sqr_cat(line, o, " rows=" as *u8); o = sqr_udec(line, o, ctx[CX_ROWS])
      o = sqr_cat(line, o, " cols=" as *u8); o = sqr_udec(line, o, nco)
      o = sqr_cat(line, o, " segs=" as *u8); o = sqr_udec(line, o, ctx[CX_SEGN] + 1)
      o = sqr_cat(line, o, " lastseg=" as *u8); o = sqr_udec(line, o, segid)
      o = sqr_ch(line, o, 10)
      sys_write(1, line, o)
      return 0
  }
  sqr_puts("unknown verb\n" as *u8)
  return 2
1112}
nx_sqlite_rows.nx source

`nx_sqlite_rows.nx` source
