dzql 0.9.0 → 0.11.0

package/src/sql/001e-delta-ops.sql

@@ -27,71 +27,13 @@ RETURNS TABLE(version BIGINT, ops JSONB, applied JSONB) AS $$
 $$ LANGUAGE sql STABLE;
 
 -- ---------------------------------------------------------------------------
--- delta_open_at: time-travel — load a doc as it existed at a point in time
+-- delta_open_at: time-travel -- a document as it stood at a point in time.
+-- generateSql sends each document to its own read as it stood
+-- (compileLookups, dzql_open_at__<slug>); before it is applied there is none.
 -- ---------------------------------------------------------------------------
 
 CREATE OR REPLACE FUNCTION delta_open_at(p_doc_name TEXT, p_at TIMESTAMPTZ)
-RETURNS JSONB AS $$
-DECLARE
-  v_def       _delta_docs;
-  v_resolved  JSONB;
-  v_mode      TEXT;
-  v_doc_id    BIGINT;
-  v_root_coll RECORD;
-  v_root_row  JSONB;
-  v_result    JSONB;
-  v_coll_key  TEXT;
-BEGIN
-  v_def := _delta_find_doc(p_doc_name);
-  IF v_def.prefix IS NULL THEN
-    RAISE EXCEPTION 'no doc def for: %', p_doc_name
-      USING ERRCODE = 'P0001';
-  END IF;
-
-  v_resolved := _delta_resolve_scope(v_def, p_doc_name);
-  v_mode     := v_resolved->>'mode';
-
-  SELECT * INTO v_root_coll FROM _delta_collections
-   WHERE collection_key = v_def.root_collection;
-  IF NOT FOUND THEN
-    RAISE EXCEPTION 'doc "%" references unknown root collection: %',
-      p_doc_name, v_def.root_collection
-      USING ERRCODE = 'P0001';
-  END IF;
-
-  -- List mode (todo #74): as delta_open reads a list, at p_at -- each row as it shows (todo #70).
-  IF v_mode = 'list' THEN RETURN _delta_show_doc(v_def, _delta_read_list(v_def, v_resolved->>'where', p_at), FALSE); END IF;
-
-  v_doc_id := (v_resolved->'values'->>'id')::BIGINT;
-
-  -- the root as it stood, where it met the whole of its name's scope then
-  -- (a column beside its id), as delta_open reads it now
-  IF v_root_coll.temporal THEN
-    EXECUTE format(
-      'SELECT to_jsonb(t.*) FROM %I t WHERE t.id = $1 AND %s AND %s',
-      v_root_coll.table_name, _delta_temporal_where(p_at), v_resolved->>'where'
-    ) INTO v_root_row USING v_doc_id;
-    v_root_row := _delta_strip_temporal(v_root_row);
-  ELSE
-    EXECUTE format('SELECT to_jsonb(t.*) FROM %I t WHERE t.id = $1 AND %s', v_root_coll.table_name, v_resolved->>'where')
-      INTO v_root_row USING v_doc_id;
-  END IF;
-
-  IF v_root_row IS NULL THEN RETURN NULL; END IF;
-
-  v_result := jsonb_build_object(v_def.root_collection, v_root_row);
-
-  FOREACH v_coll_key IN ARRAY v_def.include
-  LOOP
-    v_result := v_result || jsonb_build_object(
-      v_coll_key,
-      _delta_load_collection(v_coll_key, v_def.root_collection, v_doc_id, p_at)
-    );
-  END LOOP;
-
-  RETURN _delta_show_doc(v_def, v_result, TRUE);
-END;
-$$ LANGUAGE plpgsql STABLE;
+RETURNS JSONB LANGUAGE plpgsql STABLE AS $$ BEGIN RAISE EXCEPTION 'no doc def for: %', p_doc_name USING ERRCODE = 'P0001'; END $$;
 
 -- ---------------------------------------------------------------------------
 -- delta_prune_ops: clean up old log entries -- and the names nobody holds

package/src/sql/001g-delta-ledger.sql

@@ -29,6 +29,8 @@ CREATE TABLE IF NOT EXISTS _delta_ledger (
 CREATE INDEX IF NOT EXISTS idx_delta_ledger_doc ON _delta_ledger (doc_name, version);
 CREATE INDEX IF NOT EXISTS idx_delta_ledger_cursor ON _delta_ledger (cursor);
 CREATE INDEX IF NOT EXISTS idx_delta_ledger_undoes ON _delta_ledger (undoes);
+-- a cursor's entries newest first: where an undo or a redo looks for its tip (_delta_ledger_tip)
+CREATE INDEX IF NOT EXISTS idx_delta_ledger_cursor_id ON _delta_ledger (cursor, id);
 
 -- ---------------------------------------------------------------------------
 -- _delta_row_at: the row a document holds at a row's path, split -- the twin
@@ -204,25 +206,44 @@ $$ LANGUAGE plpgsql;
 -- what could be redone; an entry not undoable (a fact) starts no chain.
 -- ---------------------------------------------------------------------------
 
+-- _delta_ledger_tip: the entry an undo (p_back) or a redo of a cursor takes --
+-- the newest tip of the cursor's chains that goes the way asked: back, a tip at
+-- an even depth (a write, or a redo); forward, one at an odd depth (an undo that
+-- changed something) newer than the cursor's last write. Found newest first,
+-- among the cursor's own entries, so it costs what was written since the
+-- answer, not the cursor's whole history (todo #28): every entry of a chain
+-- carries its write's cursor, as delta_walk records it (an entry recorded by
+-- hand as walking another cursor's chain is not one of this cursor's tips).
 CREATE OR REPLACE FUNCTION _delta_ledger_tip(p_cursor TEXT, p_back BOOLEAN)
 RETURNS _delta_ledger AS $$
-  WITH RECURSIVE chain(id, depth) AS (
-    SELECT id, 0 FROM _delta_ledger WHERE cursor = p_cursor AND undoes IS NULL AND undoable
-    UNION ALL
-    SELECT l.id, c.depth + 1 FROM _delta_ledger l JOIN chain c ON l.undoes = c.id
-  ),
-  tips AS (
-    SELECT c.id, c.depth FROM chain c
-    WHERE NOT EXISTS (SELECT 1 FROM _delta_ledger w WHERE w.undoes = c.id)
-  )
-  SELECT l.* FROM _delta_ledger l JOIN tips t ON t.id = l.id
-  WHERE CASE WHEN p_back THEN t.depth % 2 = 0
-        ELSE t.depth % 2 = 1 AND l.undoable   -- a walk recorded as changing nothing is never redone
-          AND l.id > COALESCE((SELECT MAX(id) FROM _delta_ledger WHERE cursor = p_cursor AND undoes IS NULL AND undoable), 0)
-        END
-  ORDER BY l.id DESC
-  LIMIT 1;
-$$ LANGUAGE sql STABLE;
+DECLARE
+  v_entry _delta_ledger;
+  v_up    _delta_ledger;
+  v_depth INT;
+BEGIN
+  -- a step at a time, each the next older entry (LIMIT 1 on the cursor's index): it reads as far as it goes
+  SELECT * INTO v_entry FROM _delta_ledger WHERE cursor = p_cursor ORDER BY id DESC LIMIT 1;
+  WHILE v_entry.id IS NOT NULL LOOP
+    -- the cursor's last write, met newest first: a redo is of nothing older (a fresh write ends what could be redone)
+    IF NOT p_back AND v_entry.undoes IS NULL AND v_entry.undoable THEN RETURN NULL; END IF;
+    IF NOT EXISTS (SELECT 1 FROM _delta_ledger w WHERE w.undoes = v_entry.id) THEN   -- a tip: nothing has walked it
+      -- its depth along its chain, up to the write that began it
+      v_depth := 0;
+      v_up := v_entry;
+      WHILE v_up.undoes IS NOT NULL LOOP
+        SELECT * INTO v_up FROM _delta_ledger WHERE id = v_up.undoes;
+        v_depth := v_depth + 1;
+      END LOOP;
+      IF v_up.cursor IS NOT DISTINCT FROM p_cursor AND v_up.undoable THEN   -- a chain this cursor's undoable write began
+        IF p_back AND v_depth % 2 = 0 THEN RETURN v_entry; END IF;
+        IF NOT p_back AND v_depth % 2 = 1 AND v_entry.undoable THEN RETURN v_entry; END IF;   -- a walk recorded as changing nothing is never redone
+      END IF;
+    END IF;
+    SELECT * INTO v_entry FROM _delta_ledger WHERE cursor = p_cursor AND id < v_entry.id ORDER BY id DESC LIMIT 1;
+  END LOOP;
+  RETURN NULL;
+END;
+$$ LANGUAGE plpgsql STABLE;
 
 -- JSON values the same, with JSON null and a missing value the same.
 CREATE OR REPLACE FUNCTION _delta_same(a JSONB, b JSONB)
@@ -233,15 +254,17 @@ $$;
 -- A field of a collection's row the same in two values: a timestamptz by the
 -- instant it names, whatever zone its text was written in (a ledger's entry
 -- keeps the session's TimeZone of its write), anything else as _delta_same.
+-- generateSql writes each collection's time fields in (compileLedger); before
+-- it is applied there is no collection, and values are the same as JSON.
 CREATE OR REPLACE FUNCTION _delta_same(p_coll TEXT, p_field TEXT, a JSONB, b JSONB)
-RETURNS BOOLEAN LANGUAGE sql STABLE AS $$
-  SELECT CASE
-    WHEN jsonb_typeof(a) = 'string' AND jsonb_typeof(b) = 'string'
-         AND (SELECT _delta_cols(collection_key, columns_def)->p_field->>'type' FROM _delta_collections WHERE collection_key = p_coll) = 'timestamptz'
-      THEN (a #>> '{}')::timestamptz = (b #>> '{}')::timestamptz
-    ELSE _delta_same(a, b)
-  END;
-$$;
+RETURNS BOOLEAN LANGUAGE sql STABLE AS $$ SELECT _delta_same(a, b); $$;
+
+-- _delta_row_standing: row `p_id` of a collection as it stands, without its
+-- validity, as {row} (row null: not there); NULL for a collection there is not.
+-- What a walk guards a row beyond its document by. generateSql writes one for
+-- each collection (compileLedger).
+CREATE OR REPLACE FUNCTION _delta_row_standing(p_coll TEXT, p_id BIGINT)
+RETURNS JSONB LANGUAGE sql STABLE AS $$ SELECT NULL::jsonb; $$;
 
 -- _delta_walk_key: a row's key in a walk -- the keyOf of planWalk in
 -- src/server/ledger.ts. A single document's root is one row at two paths,
@@ -306,11 +329,9 @@ BEGIN
   FOR v_parts IN SELECT DISTINCT _delta_split_path(o->>'path') FROM jsonb_array_elements(p_entry.ops || p_entry.inverse) AS o LOOP
     CONTINUE WHEN array_length(v_parts, 1) <> 2 OR v_parts[2] !~ '^[0-9]+$' OR v_parts[2]::numeric > 9007199254740991
       OR v_parts[1] = v_def.root_collection OR v_parts[1] = ANY(COALESCE(v_def.include, ARRAY[]::text[]));
-    SELECT * INTO v_coll FROM _delta_collections WHERE collection_key = v_parts[1];
-    CONTINUE WHEN NOT FOUND;
-    EXECUTE format('SELECT _delta_strip_temporal(to_jsonb(t.*)) FROM %I t WHERE t.id = $1', _delta_source_view(v_coll.table_name, v_coll.temporal))
-      INTO v_row USING v_parts[2]::bigint;
-    v_beyond := v_beyond || jsonb_build_array(jsonb_build_object('coll', v_parts[1], 'id', v_parts[2]::bigint, 'row', v_row));
+    v_row := _delta_row_standing(v_parts[1], v_parts[2]::bigint);
+    CONTINUE WHEN v_row IS NULL;   -- a collection there is not
+    v_beyond := v_beyond || jsonb_build_array(jsonb_build_object('coll', v_parts[1], 'id', v_parts[2]::bigint, 'row', v_row->'row'));
   END LOOP;
   v_doc := _delta_beside(v_doc, v_def, v_beyond);
 

package/src/sql/auth-jwt.sql

@@ -2,7 +2,7 @@
 -- auth-jwt — reference users schema + login / register stored functions.
 -- =========================================================================
 --
--- Apply this alongside the @blueshed/delta/auth-jwt module. Consumers who
+-- Apply this alongside the dzql/auth-jwt module. Consumers who
 -- want a different identity schema (sessions, OAuth, custom tables) can
 -- substitute their own `login` / `register` functions and pass the SQL
 -- strings via `jwtAuth({ loginSql, registerSql })`.