From 5020d7e9825e561dde5afa8b429538be4443ccac Mon Sep 17 00:00:00 2001 From: wkh Date: Fri, 30 Oct 2026 10:13:59 +0100 Subject: [PATCH] Version 0.8.0: gefaltete Indizes markiert, Review abgeschlossen index -x schreibt Offset-x in den Kopf der .i-Datei, search bisektiert in der Ordnung des Index. Beim Umstieg .h- und mit -x gebaute .i-Indizes neu bauen. --- CHANGELOG.md | 5 ++++- README.md | 7 ++++--- demo/testall.old | 2 +- doc/review.md | 8 +++++--- lib/rdb/fast.rb | 35 +++++++++++++++++++++++++++-------- lib/rdb/version.rb | 2 +- test/rdb_test.rb | 40 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 82 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5435af8..13d9a03 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,9 @@ Alle wichtigen Änderungen stehen hier. Das Format folgt folgen [Semantic Versioning](https://semver.org/lang/de/). Die Version steht in `lib/rdb/version.rb`; `rdb --version` zeigt sie an. -## [Unveröffentlicht] +## [0.8.0] - 2026-10-30 + +**Beim Umstieg:** Hashindizes (`.h`) und mit `index -x` gebaute Indizes (`.i`) neu bauen. ### Hinzugefügt - `doc/handbuch.txt`: der Text des gedruckten Handbuchs „COHERENT /rdb Relational Database Manager“ (346 Seiten), per OCR aus dem Scan, mit PDF- und Buchseiten. @@ -42,6 +44,7 @@ folgen [Semantic Versioning](https://semver.org/lang/de/). Die Version steht in - Tabellen, Indexdateien und `substitute` werden über eine temporäre Datei mit `rename` geschrieben; ein Abbruch lässt die alte Datei statt einer halben neuen. - `index -mb` und `-mi` sortieren nach dem Schlüssel ohne umgebende Leerzeichen, so wie `search` vergleicht. - `sorttable -r` kehrte auch die Reihenfolge gleicher Schlüssel um; sie bleibt jetzt erhalten. +- `index -x` vermerkt die Faltung im Kopf der `.i`-Datei (`Offset-x`). `search` bisektiert in der Ordnung des Index: ohne `-x` in einem gefalteten Index wurden Sätze übersehen, mit `-x` in einem ungefalteten ebenso (dort und bei `-mb` liest die Teilsuche jetzt alle Einträge). `append` hält einen gefalteten Index in seiner Ordnung. - `jointable -n` wurde stillschweigend ignoriert. Wie in der Man-Page vergleicht es die Schlüssel jetzt als Zahlen (`01`, `1` und ` 1.0` passen zusammen). - Spaltennamen, die `justify` mit Leerzeichen aufgefüllt hat, wurden nicht mehr gefunden: `column Name` lieferte eine leere Spalte, `index` brach ab. Leerraum um die Namen im Kopf zählt jetzt nicht mehr. diff --git a/README.md b/README.md index 7057110..d4268dd 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ sind nach dem Handbuch neu geschrieben. mise trust # einmal nach dem Clone: mise.toml freigeben mise install # Ruby 3.4 mise run install # legt die Symlinks row, column, total ... in bin/ an -mise run test # 132 Tests und die Beispiele aus dem Handbuch +mise run test # 136 Tests und die Beispiele aus dem Handbuch ``` Ohne `mise trust` brechen in einem frisch geklonten Ordner alle `mise`-Befehle ab. @@ -244,8 +244,9 @@ er nicht mehr passt (außer mit `-a`). Beide halten die Indizes aktuell. dem Lehrbuch in `demo/handbuch/` (`test/handbuch_test.rb`). - Die Indexdateien sind dem Original nachgebaut, aber nicht gleich (Handbuch S. 103–108): die Hashtabelle `.h` hat 2n statt 2n+1 Plätze (Hashfunktion FNV-1a), und in `.i` steht der - Schlüssel vor dem Offset statt dahinter. Alte /rdb-Indizes und `.h`-Dateien früherer - Versionen dieses Nachbaus muss man neu bauen. + Schlüssel vor dem Offset statt dahinter. Ein mit `index -x` gebauter `.i` + heißt in der zweiten Spalte `Offset-x`. Alte /rdb-Indizes sowie `.h`- und mit `-x` gebaute + `.i`-Dateien von Versionen vor 0.8.0 muss man neu bauen. - Summen, Mittelwerte und /act-Beträge sind Dezimalzahlen (`Rational`), gerundet wird halb auf. - Dateien, die kein UTF-8 sind, liest `rdb` als Latin-1 und schreibt sie als UTF-8. Fehler erscheinen als eine Zeile; mit `RDB_DEBUG=1` kommt der Ruby-Backtrace. Werte mit Tab oder diff --git a/demo/testall.old b/demo/testall.old index 6cbf9b3..9970a69 100644 --- a/demo/testall.old +++ b/demo/testall.old @@ -880,7 +880,7 @@ Item Amount Cost Value Description ## tabletom4 / tabletosed / tabletostruct were shown above ## ===== Help and the terminal ===== $ rdb --version -rdb 0.7.0 +rdb 0.8.0 $ howmany 136 $ whatis row diff --git a/doc/review.md b/doc/review.md index 3ecd55e..f3b72d1 100644 --- a/doc/review.md +++ b/doc/review.md @@ -75,8 +75,9 @@ Man-Page) behoben. Bleibt so (Entscheidung 2026-10-30): - `1e3` ist keine Zahl: sonst würden Spalten mit Codes wie `2E5` numerisch. - Eine Zeile aus lauter leeren Zellen gilt als gelöscht: so arbeitet `delete` im Format. -Offen bei 8: `index -x` (gefaltet) hat in `search` ohne `-x` kein Gegenstück, weil die -`.i`-Datei die Faltung nicht vermerkt. Das bräuchte eine Markierung im Indexkopf. +Bei 8 ist auch die Faltung behoben: `index -x` schreibt `Offset-x` in den Kopf der `.i`-Datei, +`search` bisektiert in der Ordnung des Index und liest bei einer Teilsuche in einem +ungefalteten Index (und bei `-mb`) alle Einträge. ## Verbesserungspotential @@ -109,4 +110,5 @@ Offen bei 8: `index -x` (gefaltet) hat in `search` ohne `-x` kein Gegenstück, w ## Empfohlene Reihenfolge Schwachstellen, Fehler und Verbesserungen 1–3 und 5–7 sind erledigt. -Die awk-Brücke (4) und das Repo (8) bleiben auf Entscheidung des Autors so. Das Review ist damit abgeschlossen. +Die awk-Brücke (4) und das Repo (8) bleiben auf Entscheidung des Autors so. Das Review ist +damit abgeschlossen; alle Änderungen sind in Version 0.8.0. diff --git a/lib/rdb/fast.rb b/lib/rdb/fast.rb index 0c0dc56..3f7c405 100644 --- a/lib/rdb/fast.rb +++ b/lib/rdb/fast.rb @@ -14,6 +14,9 @@ module Rdb ENTRY_WIDTH = 9 SUFFIX = { 'h' => '.h', 'i' => '.i', 'r' => '.r' }.freeze FIXED_HEAD = "Offset\n------\n" + # Second head column of an inverted index built with index -x: its keys are + # sorted without regard to case, for search -x (like look). + FOLDED = 'Offset-x' Row = Struct.new(:from, :to, :line) do def cells @@ -119,7 +122,8 @@ module Rdb k = data.column(keycol) ents = rows.map { |r| [r.cells[k].to_s, r.from] } ents = ents.sort_by { |key, off| [fold ? key.strip.downcase : key.strip, off] } - Rdb.write_file(path + '.i', "#{keycol}\tOffset\n#{'-' * keycol.size}\t------\n" + ents.map { |key, off| "#{key}\t#{off}\n" }.join) + off_col = fold ? FOLDED : 'Offset' + Rdb.write_file(path + '.i', Table.head_text([keycol, off_col]) + ents.map { |key, off| "#{key}\t#{off}\n" }.join) when 'h' k = data.column(keycol) slots = [rows.size * 2, 2].max @@ -151,6 +155,10 @@ module Rdb io.read(ENTRY_WIDTH).to_i end + def folded?(ipath) + File.open(ipath, 'rb') { |f| f.gets.to_s.chomp("\n").split("\t")[1] == FOLDED } + end + # Entries of an inverted index (.i) from the first key that is not below # target, found by bisecting on byte positions. Yields hashes like # read_inverted does. @@ -225,10 +233,13 @@ module Rdb when 'b' rows = live_rows(data) k = idxs[0] - lo = rows.bsearch_index { |r| (partial ? norm(r.cells[k], true)[0, keyvals[0].strip.size] : r.cells[k].strip) >= (partial ? norm(keyvals[0], true) : keyvals[0].strip) } + # The table is sorted by the key as it is (case counts), so a partial, + # case-blind search cannot bisect; it reads the rows in order. + lo = partial ? 0 : rows.bsearch_index { |r| r.cells[k].strip >= keyvals[0].strip } if lo rows[lo..].each do |r| - break unless matches?(r.cells[k], keyvals[0], partial, exact) + break if !partial && r.cells[k].strip != keyvals[0].strip + next unless matches?(r.cells[k], keyvals[0], partial, exact) hits << Hit.new(r, 0, 8) break if first @@ -242,10 +253,17 @@ module Rdb r = data.row_at(off) and hits << Hit.new(r, FIXED_HEAD.bytesize + ENTRY_WIDTH * (n - 1), FIXED_HEAD.bytesize + ENTRY_WIDTH * n) end when 'i' - target = partial ? norm(keyvals[0], true) : keyvals[0].strip - below = ->(key) { (partial ? norm(key, true)[0, keyvals[0].strip.size] : key.strip) < target } - each_inverted_from(path + '.i', below) do |e| - break unless matches?(e[:key], keyvals[0], partial, exact) + # The index is in folded order (index -x) or not. Bisect in that order, + # then keep the entries that match. A partial (case-blind) search in an + # unfolded index has no order to use and reads the whole index. + ip = path + '.i' + fold = folded?(ip) + target = norm(keyvals[0], fold || partial) + cut = ->(key) { norm(key, fold || partial).then { |k| partial ? k[0, target.size] : k } } + below = fold || !partial ? ->(key) { cut.(key) < target } : ->(_key) { false } + each_inverted_from(ip, below) do |e| + break if (fold || !partial) && cut.(e[:key]) != target + next unless matches?(e[:key], keyvals[0], partial, exact) r = data.row_at(e[:offset]) hits << Hit.new(r, e[:from], e[:to]) if r @@ -318,7 +336,8 @@ module Rdb name = File.binread(ip).lines.first.split("\t")[0] key = cells[data_head.index(name)].to_s ents = read_inverted(ip) - pos = ents.find { |e| e[:key].strip > key.strip } + fold = folded?(ip) + pos = ents.find { |e| norm(e[:key], fold) > norm(key, fold) } line = "#{key}\t#{row_from}\n" if pos then splice(ip, pos[:from], pos[:from], line) else Rdb.write_file(ip, File.binread(ip) + line) diff --git a/lib/rdb/version.rb b/lib/rdb/version.rb index 6b07dd5..dbea09b 100644 --- a/lib/rdb/version.rb +++ b/lib/rdb/version.rb @@ -1,5 +1,5 @@ # frozen_string_literal: true module Rdb - VERSION = '0.7.0' + VERSION = '0.8.0' end diff --git a/test/rdb_test.rb b/test/rdb_test.rb index ae3b316..de97f62 100644 --- a/test/rdb_test.rb +++ b/test/rdb_test.rb @@ -971,3 +971,43 @@ class JoinNumericTest < RdbCase assert_equal 3, data(rdb('jointable', '-n', '-a1', 'j1', 'j2')).size end end + +class FoldedIndexTest < RdbCase + def setup + super + write('fold', "K\tV\n-\t-\nb\t1\nApple\t2\nc\t3\napricot\t4\nB\t5\n") + end + + def keys(out) + data(out).map(&:first).sort + end + + def test_folded_index_is_marked_and_found_both_ways + rdb('index', '-mi', '-x', 'fold', 'K') + assert_equal "K\tOffset-x", read('fold.i').lines.first.chomp + assert_equal %w[Apple apricot], keys(rdb('search', '-mi', '-x', 'fold', 'K', stdin: "ap\n")) + assert_equal %w[c], keys(rdb('search', '-mi', 'fold', 'K', stdin: "c\n")) + assert_equal %w[B], keys(rdb('search', '-mi', 'fold', 'K', stdin: "B\n")) + end + + def test_partial_search_in_a_plain_index_finds_every_case + rdb('index', '-mi', 'fold', 'K') + assert_equal "K\tOffset", read('fold.i').lines.first.chomp + assert_equal %w[B b], keys(rdb('search', '-mi', '-x', 'fold', 'K', stdin: "b\n")) + assert_equal %w[Apple apricot], keys(rdb('search', '-mi', '-x', 'fold', 'K', stdin: "AP\n")) + end + + def test_append_keeps_a_folded_index_in_order + rdb('index', '-mi', '-x', 'fold', 'K') + rdb('append', '-mi', 'fold', 'K', stdin: "K\tV\n-\t-\nAzure\t6\n") + folded = read('fold.i').lines.drop(2).map { |l| l.split("\t").first.downcase } + assert_equal folded.sort, folded + assert_equal %w[Apple Azure apricot], keys(rdb('search', '-mi', '-x', 'fold', 'K', stdin: "a\n")) + end + + def test_partial_search_on_a_sorted_table + rdb('index', '-mb', 'fold', 'K') + assert_equal %w[B b], keys(rdb('search', '-mb', '-x', 'fold', 'K', stdin: "b\n")) + assert_equal %w[b], keys(rdb('search', '-mb', 'fold', 'K', stdin: "b\n")) + end +end