tiny.sql.Search

1pub const Search = struct {2    space: space_mod.Space,3    documents: table_mod.Table,4    terms: index_mod.Index,5    index_prefixes: bool,6    index_phrase_pairs: bool,7    omit_phrase_pair_singletons: bool,8    field_names: []const []const u8,910    pub fn open(database: *file.Database, options: Options) Error!Search {11        const roots = [_]space_mod.RootSpec{12            .{ .root_page = options.documents_root },13            .{ .root_page = options.terms_root },14        };15        const space = try space_mod.Space.open(database, .{16            .meta_page = options.meta_page,17            .roots = &roots,18            .reserved_page_max = options.reserved_page_max,19        });20        return .{21            .space = space,22            .documents = try space.rowidTable(options.documents_root),23            .terms = try space.index(options.terms_root, &.{.{ .collation = .binary }}),24            .index_prefixes = options.index_prefixes,25            .index_phrase_pairs = options.index_phrase_pairs,26            .omit_phrase_pair_singletons = options.omit_phrase_pair_singletons,27            .field_names = options.field_names,28        };29    }3031    pub fn put(self: *Search, allocator: Allocator, rowid: i64, text: []const u8, options: file.CommitOptions) Error!file.Commit {32        const phase = trace.scope("search.put");33        defer phase.end();3435        var write = try self.space.beginWrite();36        defer write.deinit();37        try self.putIn(&write, allocator, rowid, text);38        return try write.commit(options);39    }4041    pub fn putForSource(42        self: *Search,43        allocator: Allocator,44        rowid: i64,45        text: []const u8,46        expected: Source,47        next: Source,48        options: file.CommitOptions,49    ) Error!?file.Commit {50        const phase = trace.scope("search.put_for_source");51        defer phase.end();5253        if (!try self.sourceMatches(allocator, expected)) return null;54        var write = try self.space.beginWrite();55        defer write.deinit();56        try self.putIn(&write, allocator, rowid, text);57        try self.putSourceIn(&write, next);58        return try write.commit(options);59    }6061    pub fn advanceSource(self: *Search, allocator: Allocator, expected: Source, next: Source, options: file.CommitOptions) Error!?file.Commit {62        const phase = trace.scope("search.advance_source");63        defer phase.end();6465        if (!try self.sourceMatches(allocator, expected)) return null;66        var write = try self.space.beginWrite();67        defer write.deinit();68        try self.putSourceIn(&write, next);69        return try write.commit(options);70    }7172    pub fn putAll(self: *Search, allocator: Allocator, documents: []const Document, options: file.CommitOptions) Error!file.Commit {73        const phase = trace.scope("search.put_all");74        defer phase.end();7576        var write = try self.space.beginWrite();77        defer write.deinit();78        var stats = try self.corpusStatsOrEmpty(allocator);79        try self.ensureRequestedCapabilitiesIn(&write, allocator, stats);80        for (documents) |document| {81            const indexed_text = token_mod.documentText(document.text);82            const old = try self.documents.get(allocator, document.rowid);83            defer if (old) |bytes| allocator.free(bytes);84            if (old) |bytes| {85                try self.deletePostingsIn(&write, allocator, document.rowid, try token_mod.textFromRow(bytes));86                const old_length = try self.documentLength(allocator, document.rowid);87                try self.deleteDocumentLengthIn(&write, document.rowid);88                stats = try posting_mod.subtractDocumentStats(stats, old_length);89            }90            try self.putTextIn(&write, allocator, document.rowid, indexed_text);91            try self.putPostingsIn(&write, allocator, document.rowid, indexed_text);92            const length = token_mod.documentTokenLength(indexed_text);93            try self.putDocumentLengthIn(&write, document.rowid, length);94            stats = try posting_mod.addDocumentStats(stats, length);95        }96        try self.putCorpusStatsIn(&write, stats);97        return try write.commit(options);98    }99100    pub fn loadAll(self: *Search, allocator: Allocator, documents: []const Document, options: file.CommitOptions) Error!file.Commit {101        const phase = trace.scope("search.load_all");102        defer phase.end();103104        return try self.loadAllWithSource(allocator, documents, null, options);105    }106107    pub fn loadAllForSource(self: *Search, allocator: Allocator, documents: []const Document, source_value: Source, options: file.CommitOptions) Error!file.Commit {108        const phase = trace.scope("search.load_all_for_source");109        defer phase.end();110111        return try self.loadAllWithSource(allocator, documents, source_value, options);112    }113114    fn loadAllWithSource(self: *Search, allocator: Allocator, documents: []const Document, source_value: ?Source, options: file.CommitOptions) Error!file.Commit {115        var postings = try self.collectPostings(allocator, documents);116        var postings_live = true;117        defer if (postings_live) postings.deinit(allocator);118        std.mem.sort(posting_mod.Posting, postings.items, postings.keys, posting_mod.postingLess);119120        var write = try self.space.beginWrite();121        defer write.deinit();122        try self.clearIn(&write, allocator);123        try self.putRequestedCapabilitiesIn(&write);124        try self.putSortedPostingsIn(&write, allocator, postings.items, postings.keys);125        postings.deinit(allocator);126        postings_live = false;127        var stats: posting_mod.CorpusStats = .{ .documents = 0, .total_tokens = 0 };128        {129            var lengths: std.ArrayList(posting_mod.DocumentLength) = .empty;130            defer lengths.deinit(allocator);131            for (documents) |document| {132                const indexed_text = token_mod.documentText(document.text);133                try self.putTextIn(&write, allocator, document.rowid, indexed_text);134                const length = token_mod.documentTokenLength(indexed_text);135                try lengths.append(allocator, .{ .rowid = document.rowid, .length = length });136                stats = try posting_mod.addDocumentStats(stats, length);137            }138            try self.putSortedDocumentLengthsIn(&write, allocator, lengths.items);139        }140        try self.putCorpusStatsIn(&write, stats);141        if (source_value) |value| try self.putSourceIn(&write, value);142        return try write.commit(options);143    }144145    pub fn loadAllNew(self: *Search, allocator: Allocator, documents: []const Document, options: file.CommitOptions) Error!file.Commit {146        const phase = trace.scope("search.load_all_new");147        defer phase.end();148149        var postings = try self.collectPostings(allocator, documents);150        var postings_live = true;151        defer if (postings_live) postings.deinit(allocator);152        std.mem.sort(posting_mod.Posting, postings.items, postings.keys, posting_mod.postingLess);153154        var write = try self.space.beginWrite();155        defer write.deinit();156        var stats = try self.corpusStatsOrEmpty(allocator);157        try self.ensureRequestedCapabilitiesIn(&write, allocator, stats);158        try self.putSortedPostingsIn(&write, allocator, postings.items, postings.keys);159        postings.deinit(allocator);160        postings_live = false;161        var lengths: std.ArrayList(posting_mod.DocumentLength) = .empty;162        defer lengths.deinit(allocator);163        for (documents) |document| {164            const indexed_text = token_mod.documentText(document.text);165            try self.putTextIn(&write, allocator, document.rowid, indexed_text);166            const length = token_mod.documentTokenLength(indexed_text);167            try lengths.append(allocator, .{ .rowid = document.rowid, .length = length });168            stats = try posting_mod.addDocumentStats(stats, length);169        }170        try self.putSortedDocumentLengthsIn(&write, allocator, lengths.items);171        try self.putCorpusStatsIn(&write, stats);172        return try write.commit(options);173    }174175    pub fn clear(self: *Search, allocator: Allocator, options: file.CommitOptions) Error!file.Commit {176        const phase = trace.scope("search.clear");177        defer phase.end();178179        var write = try self.space.beginWrite();180        defer write.deinit();181        try self.clearIn(&write, allocator);182        try self.putRequestedCapabilitiesIn(&write);183        return try write.commit(options);184    }185186    pub fn delete(self: *Search, allocator: Allocator, rowid: i64, options: file.CommitOptions) Error!file.Commit {187        const phase = trace.scope("search.delete");188        defer phase.end();189190        const old = (try self.documents.get(allocator, rowid)) orelse return error.KeyNotFound;191        defer allocator.free(old);192        var write = try self.space.beginWrite();193        defer write.deinit();194        var stats = try self.corpusStatsOrEmpty(allocator);195        try self.ensureRequestedCapabilitiesIn(&write, allocator, stats);196        try self.deletePostingsIn(&write, allocator, rowid, try token_mod.textFromRow(old));197        const old_length = try self.documentLength(allocator, rowid);198        try self.deleteDocumentLengthIn(&write, rowid);199        stats = try posting_mod.subtractDocumentStats(stats, old_length);200        try self.putCorpusStatsIn(&write, stats);201        try self.documents.deleteIn(&write, rowid);202        return try write.commit(options);203    }204205    fn getDocumentText(self: anytype, allocator: Allocator, rowid: i64) Error!?text_mod.DocumentText {206        const bytes = (try self.documents.get(allocator, rowid)) orelse return null;207        errdefer allocator.free(bytes);208        return .{209            .bytes = bytes,210            .text = try token_mod.textFromRow(bytes),211        };212    }213214    pub fn getText(self: anytype, allocator: Allocator, rowid: i64) Error!?[]u8 {215        var document = (try self.getDocumentText(allocator, rowid)) orelse return null;216        defer document.deinit(allocator);217        return try allocator.dupe(u8, document.text);218    }219220    pub fn capabilities(self: anytype, allocator: Allocator) Error!posting_mod.Capabilities {221        return try self.indexCapabilities(allocator);222    }223224    pub fn indexedSource(self: anytype, allocator: Allocator) Error!?Source {225        var lookup: index_mod.Scan = undefined;226        try self.terms.lookupPayloads(&lookup, allocator, &posting_mod.sourceValues());227        defer lookup.deinit();228        const entry = (try lookup.next()) orelse return null;229        if (entry.rowid != posting_mod.internal_meta_rowid) return error.InvalidSearchIndex;230        const value = try posting_mod.sourcePayloadValue(entry.payload);231        if (try lookup.next() != null) return error.InvalidSearchIndex;232        return value;233    }234235    pub fn sourceMatches(self: anytype, allocator: Allocator, expected: Source) Error!bool {236        const current = (try self.indexedSource(allocator)) orelse return false;237        return current.same(expected);238    }239240    pub fn sourceSchemaMatches(self: anytype, allocator: Allocator, schema: u64) Error!bool {241        const current = (try self.indexedSource(allocator)) orelse return false;242        return current.schema == schema;243    }244245    pub fn postingStats(self: anytype, allocator: Allocator) Error!posting_mod.PostingStats {246        var scan: index_mod.Scan = undefined;247        try self.terms.scanPayloads(&scan, allocator, null, null);248        defer scan.deinit();249        var stats: posting_mod.PostingStats = .{};250        var previous_key: [posting_mod.phrase_pair_posting_key_max_bytes]u8 = undefined;251        var previous_key_len: usize = 0;252        var have_previous_key = false;253        var values: [1]row.Value = undefined;254        var scratch: [page.size]u8 = undefined;255        while (try scan.next()) |entry| {256            stats.term_index_entries += 1;257            stats.payload_bytes += entry.payload.len;258            const decoded = try key_mod.decodeIndex(&values, &scratch, entry.key);259            if (decoded.values.len != 1) return error.InvalidSearchIndex;260            const key_text = switch (decoded.values[0]) {261                .text => |text| text,262                else => return error.InvalidSearchIndex,263            };264            if (std.mem.eql(u8, key_text, posting_mod.document_length_key)) {265                stats.document_length_entries += 1;266                if (posting_mod.lengthSegmentPayloadCount(entry.payload)) |count| {267                    stats.document_length_segment_entries += 1;268                    stats.document_length_segment_postings += count;269                } else {270                    _ = try posting_mod.documentLengthPayloadMaybe(entry.payload);271                    stats.document_length_direct_entries += 1;272                }273                continue;274            }275            if (std.mem.eql(u8, key_text, posting_mod.corpus_stats_key) or276                std.mem.eql(u8, key_text, posting_mod.capabilities_key) or277                std.mem.eql(u8, key_text, posting_mod.source_key))278            {279                stats.metadata_entries += 1;280                continue;281            }282            if (key_text.len == 0 or key_text.len > previous_key.len) return error.InvalidSearchIndex;283            if (!have_previous_key or !std.mem.eql(u8, previous_key[0..previous_key_len], key_text)) {284                stats.posting_term_keys += 1;285                stats.posting_term_key_text_bytes += key_text.len;286                switch (key_text[0]) {287                    '=' => {288                        stats.exact_term_keys += 1;289                        stats.exact_term_key_text_bytes += key_text.len;290                    },291                    '*' => {292                        stats.prefix_term_keys += 1;293                        stats.prefix_term_key_text_bytes += key_text.len;294                    },295                    posting_mod.phrase_pair_posting_kind => {296                        stats.phrase_pair_term_keys += 1;297                        stats.phrase_pair_term_key_text_bytes += key_text.len;298                    },299                    else => return error.InvalidSearchIndex,300                }301                @memcpy(previous_key[0..key_text.len], key_text);302                previous_key_len = key_text.len;303                have_previous_key = true;304            }305            stats.posting_entries += 1;306            stats.posting_payload_bytes += entry.payload.len;307            stats.posting_key_text_bytes += key_text.len;308            const phrase_pair = key_text[0] == posting_mod.phrase_pair_posting_kind;309            switch (key_text[0]) {310                '=' => {311                    stats.exact_posting_key_text_bytes += key_text.len;312                    stats.exact_posting_payload_bytes += entry.payload.len;313                },314                '*' => {315                    stats.prefix_posting_key_text_bytes += key_text.len;316                    stats.prefix_posting_payload_bytes += entry.payload.len;317                },318                posting_mod.phrase_pair_posting_kind => {319                    stats.phrase_pair_posting_key_text_bytes += key_text.len;320                    stats.phrase_pair_posting_payload_bytes += entry.payload.len;321                },322                else => return error.InvalidSearchIndex,323            }324            if (posting_mod.segmentPayloadCount(entry.payload)) |count| {325                stats.segment_entries += 1;326                stats.segment_postings += count;327                if (phrase_pair) {328                    stats.phrase_pair_segment_entries += 1;329                    stats.phrase_pair_segment_postings += count;330                }331            } else {332                const count = try posting_mod.postingPayloadCount(entry.payload);333                if (count == 0) {334                    stats.direct_posting_tombstones += 1;335                    if (phrase_pair) stats.phrase_pair_direct_posting_tombstones += 1;336                } else {337                    stats.direct_posting_entries += 1;338                    if (phrase_pair) stats.phrase_pair_direct_posting_entries += 1;339                }340            }341        }342        return stats;343    }344345    fn putIn(self: *Search, write: *tree.Write, allocator: Allocator, rowid: i64, text: []const u8) Error!void {346        const indexed_text = token_mod.documentText(text);347        const old = try self.documents.get(allocator, rowid);348        defer if (old) |bytes| allocator.free(bytes);349        var stats = try self.corpusStatsOrEmpty(allocator);350        try self.ensureRequestedCapabilitiesIn(write, allocator, stats);351        if (old) |bytes| {352            const old_text = try token_mod.textFromRow(bytes);353            if (std.mem.eql(u8, old_text, indexed_text)) return;354            const old_length = try self.documentLength(allocator, rowid);355            try self.replacePostingsIn(write, allocator, rowid, old_text, indexed_text);356            try self.putTextIn(write, allocator, rowid, indexed_text);357            const length = token_mod.documentTokenLength(indexed_text);358            if (old_length != length) {359                try self.putDocumentLengthIn(write, rowid, length);360                stats = try posting_mod.subtractDocumentStats(stats, old_length);361                stats = try posting_mod.addDocumentStats(stats, length);362                try self.putCorpusStatsIn(write, stats);363            }364            return;365        }366        try self.putTextIn(write, allocator, rowid, indexed_text);367        try self.putPostingsIn(write, allocator, rowid, indexed_text);368        const length = token_mod.documentTokenLength(indexed_text);369        try self.putDocumentLengthIn(write, rowid, length);370        stats = try posting_mod.addDocumentStats(stats, length);371        try self.putCorpusStatsIn(write, stats);372    }373374    fn requestedCapabilities(self: anytype) posting_mod.Capabilities {375        return .{376            .phrase_pair_postings = self.index_phrase_pairs,377            .phrase_pair_singletons_omitted = self.index_phrase_pairs and self.omit_phrase_pair_singletons,378        };379    }380381    fn indexCapabilities(self: anytype, allocator: Allocator) Error!posting_mod.Capabilities {382        var lookup: index_mod.Scan = undefined;383        try self.terms.lookupPayloads(&lookup, allocator, &posting_mod.capabilitiesValues());384        defer lookup.deinit();385        const entry = (try lookup.next()) orelse return .{};386        if (entry.rowid != posting_mod.internal_meta_rowid) return error.InvalidSearchIndex;387        const value = try posting_mod.capabilitiesPayloadValue(entry.payload);388        if (try lookup.next() != null) return error.InvalidSearchIndex;389        return value;390    }391392    fn canUsePhrasePairPostings(self: anytype, allocator: Allocator) Error!bool {393        if (!self.index_phrase_pairs) return false;394        return (try self.indexCapabilities(allocator)).phrase_pair_postings;395    }396397    fn phrasePairPostingsArePartial(self: anytype, allocator: Allocator) Error!bool {398        if (!self.index_phrase_pairs) return false;399        return (try self.indexCapabilities(allocator)).phrase_pair_singletons_omitted;400    }401402    fn ensureRequestedCapabilitiesIn(self: *Search, write: *tree.Write, allocator: Allocator, stats: posting_mod.CorpusStats) Error!void {403        const requested = self.requestedCapabilities();404        if (posting_mod.capabilitiesEmpty(requested)) return;405        const current = try self.indexCapabilities(allocator);406        if (posting_mod.capabilitiesInclude(current, requested)) return;407        if (stats.documents != 0) return error.SearchIndexRebuildRequired;408        try self.putCapabilitiesIn(write, posting_mod.mergeCapabilities(current, requested));409    }410411    fn putRequestedCapabilitiesIn(self: *Search, write: *tree.Write) Error!void {412        const requested = self.requestedCapabilities();413        if (posting_mod.capabilitiesEmpty(requested)) return;414        try self.putCapabilitiesIn(write, requested);415    }416417    fn putCapabilitiesIn(self: *Search, write: *tree.Write, capabilities_value: posting_mod.Capabilities) Error!void {418        var payload: [posting_mod.capabilities_payload_size]u8 = undefined;419        try self.terms.putPayloadIn(write, posting_mod.internal_meta_rowid, &posting_mod.capabilitiesValues(), try posting_mod.capabilitiesPayload(&payload, capabilities_value));420    }421422    fn putSourceIn(self: *Search, write: *tree.Write, source_value: Source) Error!void {423        var payload: [posting_mod.source_payload_size]u8 = undefined;424        try self.terms.putPayloadIn(write, posting_mod.internal_meta_rowid, &posting_mod.sourceValues(), try posting_mod.sourcePayload(&payload, source_value));425    }426427    pub fn query(self: anytype, allocator: Allocator, text: []const u8, limit: usize) Error!Results {428        const phase = trace.scope("search.query");429        defer phase.end();430431        var parsed = try query_mod.parseQuery(allocator, text, self.field_names);432        defer parsed.deinit(allocator);433        return try self.queryParsed(allocator, parsed, limit);434    }435436    pub fn queryScoreBand(self: anytype, allocator: Allocator, text: []const u8, limit: usize) Error!Results {437        const phase = trace.scope("search.query_score_band");438        defer phase.end();439440        var parsed = try query_mod.parseQuery(allocator, text, self.field_names);441        defer parsed.deinit(allocator);442        return try self.queryParsedScoreBand(allocator, parsed, limit);443    }444445    pub fn queryRanked(self: anytype, allocator: Allocator, text: []const u8, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {446        const phase = trace.scope("search.query_ranked");447        defer phase.end();448449        var parsed = try query_mod.parseQuery(allocator, text, self.field_names);450        defer parsed.deinit(allocator);451        return try self.queryParsedRanked(allocator, parsed, limit, options);452    }453454    pub fn prepare(self: anytype, allocator: Allocator, text: []const u8) Error!Prepared {455        const phase = trace.scope("search.prepare");456        defer phase.end();457458        return .{ .parsed = try query_mod.parseQuery(allocator, text, self.field_names) };459    }460461    fn queryParsed(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize) Error!Results {462        if (parsed.clauses.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };463464        if (parsed.clauses.len == 1) {465            if (limit != 0) {466                if (try self.clauseBoundedIndexHits(allocator, parsed.clauses[0], limit)) |bounded_hits| {467                    std.mem.sort(hit_mod.Hit, bounded_hits.hits, {}, hit_mod.hitLess);468                    return .{ .allocator = allocator, .hits = bounded_hits.hits, .total = bounded_hits.total };469                }470            }471            if (try self.clauseIndexHits(allocator, parsed.clauses[0])) |index_hits| {472                const total = index_hits.len;473                return .{ .allocator = allocator, .hits = try hit_mod.sortAndLimitOwnedHits(allocator, index_hits, limit), .total = total };474            }475        }476477        if (limit != 0) {478            if (try self.queryBoundedExactOrHits(allocator, parsed, limit)) |bounded_hits| {479                std.mem.sort(hit_mod.Hit, bounded_hits.hits, {}, hit_mod.hitLess);480                return .{ .allocator = allocator, .hits = bounded_hits.hits, .total = bounded_hits.total };481            }482        }483484        var hits: []hit_mod.Hit = &.{};485        var have_hits = false;486        errdefer if (have_hits) allocator.free(hits);487        for (parsed.clauses) |clause| {488            const clause_hits = (try self.clauseIndexHits(allocator, clause)) orelse try self.scoredClauseHits(allocator, clause);489            var clause_hits_owned = true;490            errdefer if (clause_hits_owned) allocator.free(clause_hits);491            if (!have_hits) {492                hits = clause_hits;493                have_hits = true;494                clause_hits_owned = false;495                continue;496            }497            const merged = try hit_mod.unionHits(allocator, hits, clause_hits);498            allocator.free(hits);499            allocator.free(clause_hits);500            clause_hits_owned = false;501            hits = merged;502        }503        const total = hits.len;504        const owned = try hit_mod.sortAndLimitOwnedHits(allocator, hits, limit);505        return .{ .allocator = allocator, .hits = owned, .total = total };506    }507508    fn queryParsedScoreBand(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize) Error!Results {509        if (limit == 0) return try self.queryParsed(allocator, parsed, 0);510        if (parsed.clauses.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };511512        if (parsed.clauses.len == 1) {513            if (try self.clauseScoreBandIndexHits(allocator, parsed.clauses[0], limit)) |band_hits| {514                std.mem.sort(hit_mod.Hit, band_hits.hits, {}, hit_mod.hitLess);515                return .{ .allocator = allocator, .hits = band_hits.hits, .total = band_hits.total };516            }517            if (try self.clauseIndexHits(allocator, parsed.clauses[0])) |index_hits| {518                const total = index_hits.len;519                return .{ .allocator = allocator, .hits = try hit_mod.sortAndScoreBandOwnedHits(allocator, index_hits, limit), .total = total };520            }521        }522523        if (try self.queryScoreBandExactOrHits(allocator, parsed, limit)) |band_hits| {524            std.mem.sort(hit_mod.Hit, band_hits.hits, {}, hit_mod.hitLess);525            return .{ .allocator = allocator, .hits = band_hits.hits, .total = band_hits.total };526        }527528        var full = try self.queryParsed(allocator, parsed, 0);529        errdefer full.deinit();530        full.hits = try hit_mod.sortAndScoreBandOwnedHits(allocator, full.hits, limit);531        return full;532    }533534    fn queryParsedRanked(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {535        if (try self.queryParsedRankedExactOr(allocator, parsed, limit, options)) |ranked| return ranked;536537        if (query_mod.singlePositivePrefixRankingAtom(parsed)) |atom| {538            return try self.rankPrefixAtom(allocator, atom, limit, options);539        }540541        if (query_mod.singlePositivePhrasePairRankingAtom(parsed)) |atom| {542            return try self.rankPhrasePairAtom(allocator, atom, limit, options);543        }544545        const rows = try self.queryParsedCandidateRows(allocator, parsed);546        defer if (rows.len != 0) allocator.free(rows);547        if (rows.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };548549        const stats = try self.corpusStats(allocator);550        if (query_mod.singlePositiveNonExactRankingAtom(parsed)) |atom| {551            return try self.rankSingleAtomCandidateRows(allocator, rows, atom, stats, limit, options);552        }553        const terms = try self.collectRankingTerms(allocator, parsed, stats.documents);554        defer rank_mod.deinitRankingTerms(allocator, terms);555        return try self.rankCandidateRows(allocator, rows, terms, stats, limit, options);556    }557558    fn queryParsedCandidateRows(self: anytype, allocator: Allocator, parsed: query_mod.Query) Error![]i64 {559        var rows: []i64 = &.{};560        var have_rows = false;561        errdefer if (have_rows) allocator.free(rows);562        for (parsed.clauses) |clause| {563            const clause_rows = try self.clauseCandidates(allocator, clause);564            var clause_rows_owned = true;565            errdefer if (clause_rows_owned) allocator.free(clause_rows);566            if (!have_rows) {567                rows = clause_rows;568                have_rows = true;569                clause_rows_owned = false;570                continue;571            }572            const merged = try hit_mod.unionRows(allocator, rows, clause_rows);573            allocator.free(rows);574            allocator.free(clause_rows);575            clause_rows_owned = false;576            rows = merged;577        }578        return if (have_rows) rows else &.{};579    }580581    fn rankSingleAtomCandidateRows(self: anytype, allocator: Allocator, rows: []const i64, atom: *const query_mod.Atom, stats: posting_mod.CorpusStats, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {582        var lengths = try rank_mod.DocumentLengthCursor.init(self, allocator);583        defer lengths.deinit();584585        var candidates: std.ArrayList(rank_mod.SingleAtomCandidate) = .empty;586        defer candidates.deinit(allocator);587588        var document_frequency: usize = 0;589        if (text_mod.useDocumentTextScanRows(rows)) {590            var documents: text_mod.DocumentTextCursor = undefined;591            try documents.init(self, allocator, rows[0]);592            defer documents.deinit();593            for (rows) |rowid| {594                const frequency = (try documents.atomFrequencyFor(rowid, atom.*)) orelse continue;595                try rank_mod.appendSingleAtomCandidate(allocator, &candidates, &lengths, &document_frequency, rowid, frequency);596            }597        } else {598            for (rows) |rowid| {599                var document = (try self.getDocumentText(allocator, rowid)) orelse continue;600                const frequency = text_mod.atomFrequency(document.text, atom.*);601                document.deinit(allocator);602                try rank_mod.appendSingleAtomCandidate(allocator, &candidates, &lengths, &document_frequency, rowid, frequency);603            }604        }605606        const idf = try rank_mod.bm25Idf(stats.documents, document_frequency);607        var hits: std.ArrayList(hit_mod.RankedHit) = .empty;608        errdefer hits.deinit(allocator);609        for (candidates.items) |candidate| {610            try hit_mod.appendRankedHit(allocator, &hits, limit, .{611                .rowid = candidate.rowid,612                .rank = -rank_mod.bm25Score(idf, candidate.frequency, candidate.length, stats, options),613            });614        }615616        std.mem.sort(hit_mod.RankedHit, hits.items, {}, hit_mod.rankedHitLess);617        return .{618            .allocator = allocator,619            .hits = try hits.toOwnedSlice(allocator),620            .total = document_frequency,621        };622    }623624    fn rankPrefixAtom(self: anytype, allocator: Allocator, atom: *const query_mod.Atom, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {625        const hits = try self.prefixHits(allocator, atom.tokens[0]);626        defer if (hits.len != 0) allocator.free(hits);627        if (hits.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };628629        const stats = try self.corpusStats(allocator);630        const idf = try rank_mod.bm25Idf(stats.documents, hits.len);631        var lengths = try rank_mod.DocumentLengthCursor.init(self, allocator);632        defer lengths.deinit();633634        var ranked: std.ArrayList(hit_mod.RankedHit) = .empty;635        errdefer ranked.deinit(allocator);636        if (text_mod.useDocumentTextScanHits(hits)) {637            var documents: text_mod.DocumentTextCursor = undefined;638            try documents.init(self, allocator, hits[0].rowid);639            defer documents.deinit();640            for (hits) |hit| {641                const frequency = (try documents.atomFrequencyFor(hit.rowid, atom.*)) orelse continue;642                try rank_mod.appendPrefixRankedHit(allocator, &ranked, &lengths, hit.rowid, frequency, idf, stats, options, limit);643            }644        } else {645            for (hits) |hit| {646                var document = (try self.getDocumentText(allocator, hit.rowid)) orelse continue;647                const frequency = text_mod.atomFrequency(document.text, atom.*);648                document.deinit(allocator);649                try rank_mod.appendPrefixRankedHit(allocator, &ranked, &lengths, hit.rowid, frequency, idf, stats, options, limit);650            }651        }652653        std.mem.sort(hit_mod.RankedHit, ranked.items, {}, hit_mod.rankedHitLess);654        return .{655            .allocator = allocator,656            .hits = try ranked.toOwnedSlice(allocator),657            .total = hits.len,658        };659    }660661    fn rankPhrasePairAtom(self: anytype, allocator: Allocator, atom: *const query_mod.Atom, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {662        std.debug.assert(query_mod.isPhrasePairAtom(atom.*));663        const hits = if (try self.canUsePhrasePairPostings(allocator) and !try self.phrasePairPostingsArePartial(allocator))664            try self.phrasePairHits(allocator, atom.tokens[0], atom.tokens[1])665        else666            try self.phrasePairVerifiedHits(allocator, atom.*, 1);667        defer if (hits.len != 0) allocator.free(hits);668        if (hits.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };669670        const stats = try self.corpusStats(allocator);671        const idf = try rank_mod.bm25Idf(stats.documents, hits.len);672        var lengths = try rank_mod.DocumentLengthCursor.init(self, allocator);673        defer lengths.deinit();674675        var ranked: std.ArrayList(hit_mod.RankedHit) = .empty;676        errdefer ranked.deinit(allocator);677        for (hits) |hit| {678            try hit_mod.appendRankedHit(allocator, &ranked, limit, .{679                .rowid = hit.rowid,680                .rank = -rank_mod.bm25Score(idf, hit.score, try lengths.lengthFor(hit.rowid), stats, options),681            });682        }683684        std.mem.sort(hit_mod.RankedHit, ranked.items, {}, hit_mod.rankedHitLess);685        return .{686            .allocator = allocator,687            .hits = try ranked.toOwnedSlice(allocator),688            .total = hits.len,689        };690    }691692    fn queryParsedRankedExactOr(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize, options: rank_mod.RankingOptions) Error!?RankedResults {693        if (parsed.clauses.len == 0) return .{ .allocator = allocator, .hits = &.{}, .total = 0 };694        for (parsed.clauses) |clause| _ = query_mod.exactClauseTerm(clause) orelse return null;695696        const stats = try self.corpusStats(allocator);697        const cursors = try allocator.alloc(rank_mod.ExactRankingCursor, parsed.clauses.len);698        var cursor_count: usize = 0;699        defer {700            for (cursors[0..cursor_count]) |*cursor| cursor.deinit();701            allocator.free(cursors);702        }703        for (parsed.clauses) |clause| {704            const term_text = query_mod.exactClauseTerm(clause).?;705            cursors[cursor_count] = .{706                .cursor = try rank_mod.ExactTermCursor.init(self, allocator, term_text),707                .idf = 0.0,708            };709            cursor_count += 1;710            const document_frequency = try cursors[cursor_count - 1].cursor.documentFrequency();711            cursors[cursor_count - 1].idf = try rank_mod.bm25Idf(stats.documents, document_frequency);712            try cursors[cursor_count - 1].cursor.advance();713        }714715        var lengths = try rank_mod.DocumentLengthCursor.init(self, allocator);716        defer lengths.deinit();717718        var hits: std.ArrayList(hit_mod.RankedHit) = .empty;719        errdefer hits.deinit(allocator);720        var total: usize = 0;721        while (try rank_mod.nextExactRankedOrHit(cursors[0..cursor_count], &lengths, stats, options)) |hit| {722            total += 1;723            try hit_mod.appendRankedHit(allocator, &hits, limit, hit);724        }725        std.mem.sort(hit_mod.RankedHit, hits.items, {}, hit_mod.rankedHitLess);726        return .{727            .allocator = allocator,728            .hits = try hits.toOwnedSlice(allocator),729            .total = total,730        };731    }732733    fn rankCandidateRows(self: anytype, allocator: Allocator, rows: []const i64, terms: []const rank_mod.RankingTerm, stats: posting_mod.CorpusStats, limit: usize, options: rank_mod.RankingOptions) Error!RankedResults {734        var lengths = try rank_mod.DocumentLengthCursor.init(self, allocator);735        defer lengths.deinit();736737        var hits: std.ArrayList(hit_mod.RankedHit) = .empty;738        errdefer hits.deinit(allocator);739740        var document_text: ?text_mod.DocumentText = null;741        defer text_mod.deinitDocumentText(allocator, &document_text);742        var document_text_rowid: ?i64 = null;743744        var total: usize = 0;745        for (rows) |rowid| {746            const length = try lengths.lengthFor(rowid);747            var score: f64 = 0.0;748            for (terms) |term| {749                const frequency = if (term.posting_hits.len != 0)750                    hit_mod.postingHitFrequency(term.posting_hits, rowid)751                else frequency: {752                    if (document_text_rowid == null or document_text_rowid.? != rowid) {753                        text_mod.deinitDocumentText(allocator, &document_text);754                        document_text_rowid = null;755                        document_text = (try self.getDocumentText(allocator, rowid)) orelse break :frequency 0;756                        document_text_rowid = rowid;757                    }758                    break :frequency text_mod.atomFrequency(document_text.?.text, term.atom.*);759                };760                if (frequency == 0) continue;761                score += rank_mod.bm25Score(term.idf, frequency, length, stats, options);762            }763            total += 1;764            try hit_mod.appendRankedHit(allocator, &hits, limit, .{ .rowid = rowid, .rank = -score });765        }766767        std.mem.sort(hit_mod.RankedHit, hits.items, {}, hit_mod.rankedHitLess);768        return .{769            .allocator = allocator,770            .hits = try hits.toOwnedSlice(allocator),771            .total = total,772        };773    }774775    fn putPostingsIn(self: *Search, write: *tree.Write, allocator: Allocator, rowid: i64, text: []const u8) Error!void {776        const counts = try posting_mod.documentTermCounts(allocator, text, self.index_prefixes, self.index_phrase_pairs and !self.omit_phrase_pair_singletons);777        defer posting_mod.freeTermCounts(allocator, counts);778        for (counts) |term_count| try self.putPostingIn(write, rowid, term_count);779    }780781    fn replacePostingsIn(self: *Search, write: *tree.Write, allocator: Allocator, rowid: i64, old_text: []const u8, new_text: []const u8) Error!void {782        const old_counts = try posting_mod.documentTermCounts(allocator, old_text, self.index_prefixes, self.index_phrase_pairs);783        defer posting_mod.freeTermCounts(allocator, old_counts);784        const new_counts = try posting_mod.documentTermCounts(allocator, new_text, self.index_prefixes, self.index_phrase_pairs and !self.omit_phrase_pair_singletons);785        defer posting_mod.freeTermCounts(allocator, new_counts);786        for (old_counts) |old_count| {787            const new_count = termCount(new_counts, old_count.key) orelse {788                try self.deletePostingIn(write, rowid, old_count.key);789                continue;790            };791            if (old_count.count != new_count.count) try self.putPostingIn(write, rowid, new_count);792        }793        for (new_counts) |new_count| {794            if (termCount(old_counts, new_count.key) == null) try self.putPostingIn(write, rowid, new_count);795        }796    }797798    fn putPostingIn(self: *Search, write: *tree.Write, rowid: i64, term_count: posting_mod.TermCount) Error!void {799        var payload: [page.size]u8 = undefined;800        try self.terms.putPayloadIn(write, rowid, &posting_mod.postingValues(term_count.key), try posting_mod.postingPayload(&payload, term_count.count));801    }802803    fn deletePostingIn(self: *Search, write: *tree.Write, rowid: i64, key: []const u8) Error!void {804        self.terms.deleteIn(write, rowid, &posting_mod.postingValues(key)) catch |err| switch (err) {805            error.KeyNotFound => {},806            else => return err,807        };808        var payload: [page.size]u8 = undefined;809        try self.terms.putPayloadIn(write, rowid, &posting_mod.postingValues(key), try posting_mod.postingPayload(&payload, 0));810    }811812    fn putDocumentLengthIn(self: *Search, write: *tree.Write, rowid: i64, length: usize) Error!void {813        var payload: [posting_mod.document_length_payload_size]u8 = undefined;814        try self.terms.putPayloadIn(write, rowid, &posting_mod.documentLengthValues(), try posting_mod.documentLengthPayload(&payload, length));815    }816817    fn deleteDocumentLengthIn(self: *Search, write: *tree.Write, rowid: i64) Error!void {818        var payload: [posting_mod.document_length_payload_size]u8 = undefined;819        try self.terms.putPayloadIn(write, rowid, &posting_mod.documentLengthValues(), posting_mod.documentLengthTombstonePayload(&payload));820    }821822    fn putCorpusStatsIn(self: *Search, write: *tree.Write, stats: posting_mod.CorpusStats) Error!void {823        var payload: [posting_mod.corpus_stats_payload_size]u8 = undefined;824        try self.terms.putPayloadIn(write, posting_mod.internal_meta_rowid, &posting_mod.corpusStatsValues(), try posting_mod.corpusStatsPayload(&payload, stats));825    }826827    fn putSortedDocumentLengthsIn(self: *Search, write: *tree.Write, allocator: Allocator, lengths: []posting_mod.DocumentLength) Error!void {828        std.mem.sort(posting_mod.DocumentLength, lengths, {}, posting_mod.documentLengthLess);829        if (posting_mod.canSegmentDocumentLengths(lengths)) {830            const payload = try posting_mod.documentLengthSegmentPayload(allocator, lengths);831            defer allocator.free(payload);832            try self.terms.putPayloadIn(write, try posting_mod.segmentRowid(lengths[0].rowid), &posting_mod.documentLengthValues(), payload);833            return;834        }835        for (lengths) |document_length| try self.putDocumentLengthIn(write, document_length.rowid, document_length.length);836    }837838    fn putSortedPostingsIn(self: *Search, write: *tree.Write, allocator: Allocator, postings: []const posting_mod.Posting, keys: []const []const u8) Error!void {839        var start: usize = 0;840        while (start < postings.len) {841            var end = start + 1;842            while (end < postings.len and postings[start].key_index == postings[end].key_index) : (end += 1) {}843            const group = postings[start..end];844            if (group[0].key_index >= keys.len) return error.InvalidSearchIndex;845            const key = keys[group[0].key_index];846            if (posting_mod.canSegmentPostings(group)) {847                const payload = try posting_mod.postingSegmentPayload(allocator, group);848                defer allocator.free(payload);849                try self.terms.putPayloadIn(write, try posting_mod.segmentRowid(group[0].rowid), &posting_mod.postingValues(key), payload);850            } else if (self.omit_phrase_pair_singletons and posting_mod.isPhrasePairPostingKey(key)) {851                start = end;852                continue;853            } else {854                for (group) |posting| {855                    var payload: [page.size]u8 = undefined;856                    try self.terms.putPayloadIn(write, posting.rowid, &posting_mod.postingValues(key), try posting_mod.postingPayload(&payload, posting.count));857                }858            }859            start = end;860        }861    }862863    fn putTextIn(self: *Search, write: *tree.Write, allocator: Allocator, rowid: i64, text: []const u8) Error!void {864        const values = [_]row.Value{.{ .text = text }};865        const size = try row.encodedSize(&values);866        if (size <= page.size) {867            var row_bytes: [page.size]u8 = undefined;868            try self.documents.putEncodedIn(write, rowid, try row.encode(&row_bytes, &values));869            return;870        }871        const row_bytes = try allocator.alloc(u8, size);872        defer allocator.free(row_bytes);873        try self.documents.putEncodedIn(write, rowid, try row.encode(row_bytes, &values));874    }875876    fn deletePostingsIn(self: *Search, write: *tree.Write, allocator: Allocator, rowid: i64, text: []const u8) Error!void {877        const counts = try posting_mod.documentTermCounts(allocator, text, self.index_prefixes, self.index_phrase_pairs);878        defer posting_mod.freeTermCounts(allocator, counts);879        for (counts) |term_count| try self.deletePostingIn(write, rowid, term_count.key);880    }881882    fn clauseIndexHits(self: anytype, allocator: Allocator, clause: query_mod.Clause) Error!?[]hit_mod.Hit {883        if (clause.positive.len == 0) return null;884        const first = try self.atomIndexHits(allocator, clause.positive[0]);885        var current = first orelse return null;886        errdefer allocator.free(current);887        var index: usize = 1;888        while (index < clause.positive.len) : (index += 1) {889            const next_maybe = try self.atomIndexHits(allocator, clause.positive[index]);890            const next = next_maybe orelse {891                allocator.free(current);892                return null;893            };894            defer allocator.free(next);895            const merged = try hit_mod.intersectHits(allocator, current, next);896            allocator.free(current);897            current = merged;898        }899        for (clause.negative) |atom| {900            const excluded = try self.atomDocuments(allocator, atom);901            defer allocator.free(excluded);902            const filtered = try hit_mod.subtractHits(allocator, current, excluded);903            allocator.free(current);904            current = filtered;905        }906        return current;907    }908909    fn clauseBoundedIndexHits(self: anytype, allocator: Allocator, clause: query_mod.Clause, limit: usize) Error!?hit_mod.HitSet {910        if (clause.negative.len != 0 or clause.positive.len != 1) return null;911        return try self.atomBoundedIndexHits(allocator, clause.positive[0], limit);912    }913914    fn clauseScoreBandIndexHits(self: anytype, allocator: Allocator, clause: query_mod.Clause, limit: usize) Error!?hit_mod.HitSet {915        if (clause.negative.len != 0 or clause.positive.len != 1) return null;916        return try self.atomScoreBandIndexHits(allocator, clause.positive[0], limit);917    }918919    fn queryBoundedExactOrHits(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize) Error!?hit_mod.HitSet {920        if (parsed.clauses.len < 2) return null;921        for (parsed.clauses) |clause| _ = query_mod.exactClauseTerm(clause) orelse return null;922923        const cursors = try allocator.alloc(rank_mod.ExactTermCursor, parsed.clauses.len);924        var cursor_count: usize = 0;925        defer {926            for (cursors[0..cursor_count]) |*cursor| cursor.deinit();927            allocator.free(cursors);928        }929930        for (parsed.clauses) |clause| {931            const term = query_mod.exactClauseTerm(clause).?;932            cursors[cursor_count] = try rank_mod.ExactTermCursor.init(self, allocator, term);933            cursor_count += 1;934            try cursors[cursor_count - 1].advance();935        }936937        var hits: std.ArrayList(hit_mod.Hit) = .empty;938        errdefer hits.deinit(allocator);939        var total: usize = 0;940        while (try rank_mod.nextExactOrHit(cursors)) |hit| {941            total += 1;942            try hit_mod.appendBoundedHit(allocator, &hits, limit, hit);943        }944        return .{ .hits = try hits.toOwnedSlice(allocator), .total = total };945    }946947    fn queryScoreBandExactOrHits(self: anytype, allocator: Allocator, parsed: query_mod.Query, limit: usize) Error!?hit_mod.HitSet {948        var bounded_hits = (try self.queryBoundedExactOrHits(allocator, parsed, limit)) orelse return null;949        errdefer if (bounded_hits.hits.len != 0) allocator.free(bounded_hits.hits);950        if (bounded_hits.total <= limit) return bounded_hits;951        const cutoff = hit_mod.minHitScore(bounded_hits.hits);952        allocator.free(bounded_hits.hits);953        bounded_hits.hits = &.{};954        bounded_hits.hits = try self.queryExactOrHitsAtLeastScore(allocator, parsed, cutoff);955        return bounded_hits;956    }957958    fn queryExactOrHitsAtLeastScore(self: anytype, allocator: Allocator, parsed: query_mod.Query, cutoff: usize) Error![]hit_mod.Hit {959        if (parsed.clauses.len < 2) return &.{};960961        const cursors = try allocator.alloc(rank_mod.ExactTermCursor, parsed.clauses.len);962        var cursor_count: usize = 0;963        defer {964            for (cursors[0..cursor_count]) |*cursor| cursor.deinit();965            allocator.free(cursors);966        }967968        for (parsed.clauses) |clause| {969            const term = query_mod.exactClauseTerm(clause).?;970            cursors[cursor_count] = try rank_mod.ExactTermCursor.init(self, allocator, term);971            cursor_count += 1;972            try cursors[cursor_count - 1].advance();973        }974975        var hits: std.ArrayList(hit_mod.Hit) = .empty;976        errdefer hits.deinit(allocator);977        while (try rank_mod.nextExactOrHit(cursors)) |hit| {978            if (hit.score >= cutoff) try hits.append(allocator, hit);979        }980        return try hits.toOwnedSlice(allocator);981    }982983    fn atomIndexHits(self: anytype, allocator: Allocator, atom: query_mod.Atom) Error!?[]hit_mod.Hit {984        if (atom.tokens.len == 0 or atom.prefix or atom.near_window != null or atom.field != null) return null;985        if (atom.phrase) {986            if (!query_mod.isPhrasePairAtom(atom)) return null;987            const hits = if (try self.canUsePhrasePairPostings(allocator) and !try self.phrasePairPostingsArePartial(allocator))988                try self.phrasePairHits(allocator, atom.tokens[0], atom.tokens[1])989            else990                try self.phrasePairVerifiedHits(allocator, atom, 1);991            errdefer if (hits.len != 0) allocator.free(hits);992            for (hits) |*hit| hit.score = std.math.mul(usize, hit.score, atom.tokens.len) catch return error.InvalidSearchIndex;993            return hits;994        }995        var current = try self.termHits(allocator, atom.tokens[0]);996        errdefer allocator.free(current);997        var index: usize = 1;998        while (index < atom.tokens.len) : (index += 1) {999            const next = try self.termHits(allocator, atom.tokens[index]);1000            defer allocator.free(next);1001            const merged = try hit_mod.intersectHits(allocator, current, next);1002            allocator.free(current);1003            current = merged;1004        }1005        return current;1006    }10071008    fn atomBoundedIndexHits(self: anytype, allocator: Allocator, atom: query_mod.Atom, limit: usize) Error!?hit_mod.HitSet {1009        if (atom.tokens.len != 1 or atom.prefix or atom.phrase or atom.near_window != null or atom.field != null) return null;1010        return try self.termHitsBounded(allocator, atom.tokens[0], limit);1011    }10121013    fn atomScoreBandIndexHits(self: anytype, allocator: Allocator, atom: query_mod.Atom, limit: usize) Error!?hit_mod.HitSet {1014        if (atom.tokens.len != 1 or atom.prefix or atom.phrase or atom.near_window != null or atom.field != null) return null;1015        return try self.termHitsScoreBand(allocator, atom.tokens[0], limit);1016    }10171018    fn clauseCandidates(self: anytype, allocator: Allocator, clause: query_mod.Clause) Error![]i64 {1019        var current = if (clause.positive.len == 0) try self.allDocuments(allocator) else try self.atomDocuments(allocator, clause.positive[0]);1020        errdefer allocator.free(current);1021        var index: usize = if (clause.positive.len == 0) 0 else 1;1022        while (index < clause.positive.len) : (index += 1) {1023            const next = try self.atomDocuments(allocator, clause.positive[index]);1024            defer allocator.free(next);1025            const merged = try hit_mod.intersectRows(allocator, current, next);1026            allocator.free(current);1027            current = merged;1028        }1029        for (clause.negative) |atom| {1030            const excluded = try self.atomDocuments(allocator, atom);1031            defer allocator.free(excluded);1032            const filtered = try hit_mod.subtractRows(allocator, current, excluded);1033            allocator.free(current);1034            current = filtered;1035        }1036        return current;1037    }10381039    fn scoredClauseHits(self: anytype, allocator: Allocator, clause: query_mod.Clause) Error![]hit_mod.Hit {1040        const candidates = try self.clauseCandidates(allocator, clause);1041        defer allocator.free(candidates);1042        var hits: std.ArrayList(hit_mod.Hit) = .empty;1043        errdefer hits.deinit(allocator);1044        for (candidates) |rowid| {1045            const doc = (try self.documents.get(allocator, rowid)) orelse continue;1046            defer allocator.free(doc);1047            const score = text_mod.clauseScore(try token_mod.textFromRow(doc), clause);1048            if (score == 0) continue;1049            try hits.append(allocator, .{ .rowid = rowid, .score = score });1050        }1051        return try hits.toOwnedSlice(allocator);1052    }10531054    fn atomDocuments(self: anytype, allocator: Allocator, atom: query_mod.Atom) Error![]i64 {1055        if (atom.tokens.len == 0) return &.{};1056        if (query_mod.isPhrasePairAtom(atom)) {1057            const hits = if (try self.canUsePhrasePairPostings(allocator) and !try self.phrasePairPostingsArePartial(allocator))1058                try self.phrasePairHits(allocator, atom.tokens[0], atom.tokens[1])1059            else1060                try self.phrasePairVerifiedHits(allocator, atom, 1);1061            defer if (hits.len != 0) allocator.free(hits);1062            var rows: std.ArrayList(i64) = .empty;1063            errdefer rows.deinit(allocator);1064            try rows.ensureUnusedCapacity(allocator, hits.len);1065            for (hits) |hit| rows.appendAssumeCapacity(hit.rowid);1066            return try rows.toOwnedSlice(allocator);1067        }1068        var current = try self.termDocuments(allocator, atom.tokens[0], atom.prefix);1069        errdefer allocator.free(current);1070        if (atom.prefix) {1071            if (atom.field == null) return current;1072            const filtered = try self.verifiedRowsFromCandidates(allocator, current, atom);1073            allocator.free(current);1074            return filtered;1075        }1076        var index: usize = 1;1077        while (index < atom.tokens.len) : (index += 1) {1078            const next = try self.termDocuments(allocator, atom.tokens[index], false);1079            defer allocator.free(next);1080            const merged = try hit_mod.intersectRows(allocator, current, next);1081            allocator.free(current);1082            current = merged;1083        }1084        if (atom.phrase or atom.near_window != null or atom.field != null) {1085            const filtered = try self.verifiedRowsFromCandidates(allocator, current, atom);1086            allocator.free(current);1087            return filtered;1088        }1089        return current;1090    }10911092    fn verifiedRowsFromCandidates(self: anytype, allocator: Allocator, rows: []const i64, atom: query_mod.Atom) Error![]i64 {1093        var out: std.ArrayList(i64) = .empty;1094        errdefer out.deinit(allocator);1095        for (rows) |rowid| {1096            var document = (try self.getDocumentText(allocator, rowid)) orelse continue;1097            const frequency = text_mod.atomFrequency(document.text, atom);1098            document.deinit(allocator);1099            if (frequency != 0) try out.append(allocator, rowid);1100        }1101        return try out.toOwnedSlice(allocator);1102    }11031104    fn phrasePairVerifiedHits(self: anytype, allocator: Allocator, atom: query_mod.Atom, score_multiplier: usize) Error![]hit_mod.Hit {1105        std.debug.assert(query_mod.isPhrasePairAtom(atom));1106        var left = try rank_mod.ExactTermCursor.init(self, allocator, atom.tokens[0]);1107        defer left.deinit();1108        try left.advance();1109        var right = try rank_mod.ExactTermCursor.init(self, allocator, atom.tokens[1]);1110        defer right.deinit();1111        try right.advance();1112        var indexed: ?rank_mod.ExactTermCursor = if (try self.canUsePhrasePairPostings(allocator))1113            try rank_mod.ExactTermCursor.initPhrasePair(self, allocator, atom.tokens[0], atom.tokens[1])1114        else1115            null;1116        defer if (indexed) |*cursor| cursor.deinit();1117        if (indexed) |*cursor| try cursor.advance();1118        var hits: std.ArrayList(hit_mod.Hit) = .empty;1119        errdefer hits.deinit(allocator);1120        var documents: ?text_mod.DocumentTextCursor = null;1121        defer if (documents) |*cursor| cursor.deinit();1122        while (try rank_mod.nextPhrasePairCandidateRow(&left, &right)) |rowid| {1123            const indexed_frequency = if (indexed) |*cursor| try rank_mod.postingCursorFrequencyAt(cursor, rowid) else 0;1124            const frequency = if (indexed_frequency != 0) indexed_frequency else frequency: {1125                if (documents == null) {1126                    documents = @as(text_mod.DocumentTextCursor, undefined);1127                    errdefer documents = null;1128                    try documents.?.init(self, allocator, rowid);1129                }1130                if (documents) |*cursor| break :frequency (try cursor.atomFrequencyFor(rowid, atom)) orelse 0;1131                unreachable;1132            };1133            if (frequency != 0) try hits.append(allocator, .{1134                .rowid = rowid,1135                .score = std.math.mul(usize, frequency, score_multiplier) catch return error.InvalidSearchIndex,1136            });1137        }1138        return try hits.toOwnedSlice(allocator);1139    }11401141    fn termDocuments(self: anytype, allocator: Allocator, term: []const u8, prefix: bool) Error![]i64 {1142        if (prefix and !self.index_prefixes) return try self.prefixDocuments(allocator, term);1143        const hits = try self.termHitsForKind(allocator, if (prefix) '*' else '=', term);1144        defer allocator.free(hits);1145        var rows: std.ArrayList(i64) = .empty;1146        errdefer rows.deinit(allocator);1147        try rows.ensureUnusedCapacity(allocator, hits.len);1148        for (hits) |hit| rows.appendAssumeCapacity(hit.rowid);1149        return try hit_mod.sortedUniqueRows(allocator, &rows);1150    }11511152    fn termHits(self: anytype, allocator: Allocator, term: []const u8) Error![]hit_mod.Hit {1153        return try self.termHitsForKind(allocator, '=', term);1154    }11551156    fn termHitsForKind(self: anytype, allocator: Allocator, kind: u8, term: []const u8) Error![]hit_mod.Hit {1157        var key_buffer: [token_mod.max_token_bytes + 1]u8 = undefined;1158        const key_text = posting_mod.postingKeyBuffer(&key_buffer, kind, term);1159        return try self.postingHits(allocator, key_text);1160    }11611162    fn postingHits(self: anytype, allocator: Allocator, key_text: []const u8) Error![]hit_mod.Hit {1163        var lookup: index_mod.Scan = undefined;1164        try self.terms.lookupPayloads(&lookup, allocator, &.{.{ .text = key_text }});1165        defer lookup.deinit();1166        var raw: std.ArrayList(hit_mod.RawHit) = .empty;1167        errdefer raw.deinit(allocator);1168        while (try lookup.next()) |entry| try hit_mod.appendRawHits(allocator, &raw, entry.rowid, entry.payload);1169        return try hit_mod.coalescedHits(allocator, &raw);1170    }11711172    fn phrasePairHits(self: anytype, allocator: Allocator, first: []const u8, second: []const u8) Error![]hit_mod.Hit {1173        var key_buffer: [posting_mod.phrase_pair_posting_key_max_bytes]u8 = undefined;1174        const key_text = posting_mod.phrasePairPostingKeyBuffer(&key_buffer, first, second);1175        return try self.postingHits(allocator, key_text);1176    }11771178    fn termHitsBounded(self: anytype, allocator: Allocator, term: []const u8, limit: usize) Error!hit_mod.HitSet {1179        const hits = try self.termHits(allocator, term);1180        errdefer if (hits.len != 0) allocator.free(hits);1181        const total = hits.len;1182        return .{ .hits = try hit_mod.sortAndLimitOwnedHits(allocator, hits, limit), .total = total };1183    }11841185    fn termHitsScoreBand(self: anytype, allocator: Allocator, term: []const u8, limit: usize) Error!hit_mod.HitSet {1186        if (limit == 0) {1187            const hits = try self.termHits(allocator, term);1188            return .{ .hits = hits, .total = hits.len };1189        }1190        var cursor = try rank_mod.ExactTermCursor.init(self, allocator, term);1191        defer cursor.deinit();1192        var hits: std.ArrayList(hit_mod.Hit) = .empty;1193        errdefer hits.deinit(allocator);1194        var total: usize = 0;1195        while (true) {1196            try cursor.advance();1197            const hit = cursor.current orelse break;1198            total += 1;1199            try hit_mod.appendBoundedHit(allocator, &hits, limit, hit);1200        }1201        if (total <= limit) {1202            const owned = try hits.toOwnedSlice(allocator);1203            std.mem.sort(hit_mod.Hit, owned, {}, hit_mod.hitLess);1204            return .{ .hits = owned, .total = total };1205        }1206        const cutoff = hit_mod.minHitScore(hits.items);1207        hits.clearRetainingCapacity();1208        cursor.reset();1209        while (true) {1210            try cursor.advance();1211            const hit = cursor.current orelse break;1212            if (hit.score >= cutoff) try hits.append(allocator, hit);1213        }1214        const owned = try hits.toOwnedSlice(allocator);1215        std.mem.sort(hit_mod.Hit, owned, {}, hit_mod.hitLess);1216        return .{ .hits = owned, .total = total };1217    }12181219    fn termHitsAtLeastScore(self: anytype, allocator: Allocator, term: []const u8, cutoff: usize) Error![]hit_mod.Hit {1220        const source = try self.termHits(allocator, term);1221        defer allocator.free(source);1222        var hits: std.ArrayList(hit_mod.Hit) = .empty;1223        errdefer hits.deinit(allocator);1224        for (source) |hit| {1225            const score = hit.score;1226            if (score < cutoff) continue;1227            try hits.append(allocator, hit);1228        }1229        return try hits.toOwnedSlice(allocator);1230    }12311232    fn prefixHits(self: anytype, allocator: Allocator, term: []const u8) Error![]hit_mod.Hit {1233        if (self.index_prefixes) return try self.termHitsForKind(allocator, '*', term);1234        var start_buffer: [token_mod.max_token_bytes + 1]u8 = undefined;1235        const start = posting_mod.postingKeyBuffer(&start_buffer, '=', term);1236        var end_buffer: [token_mod.max_token_bytes + 2]u8 = undefined;1237        const end = posting_mod.prefixEndBuffer(&end_buffer, start);1238        var lookup: index_mod.Scan = undefined;1239        try self.terms.scanPayloads(1240            &lookup,1241            allocator,1242            &.{.{ .text = start }},1243            &.{.{ .text = end }},1244        );1245        defer lookup.deinit();1246        var raw: std.ArrayList(hit_mod.RawHit) = .empty;1247        errdefer raw.deinit(allocator);1248        while (try lookup.next()) |entry| try hit_mod.appendRawHits(allocator, &raw, entry.rowid, entry.payload);1249        const hits = try hit_mod.coalescedHits(allocator, &raw);1250        return hits;1251    }12521253    fn prefixDocuments(self: anytype, allocator: Allocator, term: []const u8) Error![]i64 {1254        const hits = try self.prefixHits(allocator, term);1255        defer allocator.free(hits);1256        var rows: std.ArrayList(i64) = .empty;1257        errdefer rows.deinit(allocator);1258        try rows.ensureUnusedCapacity(allocator, hits.len);1259        for (hits) |hit| rows.appendAssumeCapacity(hit.rowid);1260        return try hit_mod.sortedUniqueRows(allocator, &rows);1261    }12621263    fn allDocuments(self: anytype, allocator: Allocator) Error![]i64 {1264        var scan: table_mod.Scan = undefined;1265        try self.documents.scan(&scan, allocator, null, null);1266        defer scan.deinit();1267        var rows: std.ArrayList(i64) = .empty;1268        errdefer rows.deinit(allocator);1269        while (try scan.next()) |entry| try rows.append(allocator, entry.rowid);1270        return try hit_mod.sortedUniqueRows(allocator, &rows);1271    }12721273    fn corpusStats(self: anytype, allocator: Allocator) Error!posting_mod.CorpusStats {1274        var lookup: index_mod.Scan = undefined;1275        try self.terms.lookupPayloads(&lookup, allocator, &posting_mod.corpusStatsValues());1276        defer lookup.deinit();1277        const entry = (try lookup.next()) orelse return error.InvalidSearchIndex;1278        if (entry.rowid != posting_mod.internal_meta_rowid) return error.InvalidSearchIndex;1279        const stats = try posting_mod.corpusStatsPayloadValue(entry.payload);1280        if (try lookup.next() != null) return error.InvalidSearchIndex;1281        return stats;1282    }12831284    fn corpusStatsOrEmpty(self: anytype, allocator: Allocator) Error!posting_mod.CorpusStats {1285        return self.corpusStats(allocator) catch |err| switch (err) {1286            error.InvalidSearchIndex => stats: {1287                var scan: table_mod.Scan = undefined;1288                try self.documents.scan(&scan, allocator, null, null);1289                defer scan.deinit();1290                if (try scan.next() != null) return error.InvalidSearchIndex;1291                break :stats .{ .documents = 0, .total_tokens = 0 };1292            },1293            else => return err,1294        };1295    }12961297    fn documentLength(self: anytype, allocator: Allocator, rowid: i64) Error!usize {1298        var cursor = try rank_mod.DocumentLengthCursor.init(self, allocator);1299        defer cursor.deinit();1300        return try cursor.lengthFor(rowid);1301    }13021303    fn documentLengths(self: anytype, allocator: Allocator) Error![]posting_mod.DocumentLength {1304        var cursor = try rank_mod.DocumentLengthCursor.init(self, allocator);1305        defer cursor.deinit();1306        var lengths: std.ArrayList(posting_mod.DocumentLength) = .empty;1307        errdefer lengths.deinit(allocator);1308        while (cursor.rowid) |rowid| {1309            try lengths.append(allocator, .{1310                .rowid = rowid,1311                .length = cursor.length,1312            });1313            try cursor.advance();1314        }1315        return try lengths.toOwnedSlice(allocator);1316    }13171318    fn collectRankingTerms(self: anytype, allocator: Allocator, parsed: query_mod.Query, document_count: usize) Error![]rank_mod.RankingTerm {1319        var terms: std.ArrayList(rank_mod.RankingTerm) = .empty;1320        errdefer {1321            for (terms.items) |*term| term.deinit(allocator);1322            terms.deinit(allocator);1323        }1324        for (parsed.clauses) |*clause| {1325            for (clause.positive) |*atom| {1326                if (atom.tokens.len == 0) continue;1327                if (query_mod.isExactRankingAtom(atom.*)) {1328                    const hits = try self.termHits(allocator, atom.tokens[0]);1329                    const idf = rank_mod.bm25Idf(document_count, hits.len) catch |err| {1330                        if (hits.len != 0) allocator.free(hits);1331                        return err;1332                    };1333                    terms.append(allocator, .{1334                        .atom = atom,1335                        .posting_hits = hits,1336                        .document_frequency = hits.len,1337                        .idf = idf,1338                    }) catch |err| {1339                        if (hits.len != 0) allocator.free(hits);1340                        return err;1341                    };1342                } else if (query_mod.isPhrasePairAtom(atom.*)) {1343                    const hits = if (try self.canUsePhrasePairPostings(allocator) and !try self.phrasePairPostingsArePartial(allocator))1344                        try self.phrasePairHits(allocator, atom.tokens[0], atom.tokens[1])1345                    else1346                        try self.phrasePairVerifiedHits(allocator, atom.*, 1);1347                    const idf = rank_mod.bm25Idf(document_count, hits.len) catch |err| {1348                        if (hits.len != 0) allocator.free(hits);1349                        return err;1350                    };1351                    terms.append(allocator, .{1352                        .atom = atom,1353                        .posting_hits = hits,1354                        .document_frequency = hits.len,1355                        .idf = idf,1356                    }) catch |err| {1357                        if (hits.len != 0) allocator.free(hits);1358                        return err;1359                    };1360                } else {1361                    const frequency = try self.atomDocumentFrequency(allocator, atom.*);1362                    try terms.append(allocator, .{1363                        .atom = atom,1364                        .posting_hits = &.{},1365                        .document_frequency = frequency,1366                        .idf = try rank_mod.bm25Idf(document_count, frequency),1367                    });1368                }1369            }1370        }1371        return try terms.toOwnedSlice(allocator);1372    }13731374    fn atomDocumentFrequency(self: anytype, allocator: Allocator, atom: query_mod.Atom) Error!usize {1375        const rows = try self.atomDocuments(allocator, atom);1376        defer allocator.free(rows);1377        if (!atom.phrase) return rows.len;1378        var count: usize = 0;1379        for (rows) |rowid| {1380            var document = (try self.getDocumentText(allocator, rowid)) orelse continue;1381            const frequency = text_mod.atomFrequency(document.text, atom);1382            document.deinit(allocator);1383            if (frequency != 0) count += 1;1384        }1385        return count;1386    }13871388    fn clearIn(self: *Search, write: *tree.Write, allocator: Allocator) Error!void {1389        _ = allocator;1390        try write.clear(&self.terms.entries);1391        try write.clear(&self.documents.rows);1392    }13931394    fn collectTermKeys(self: anytype, allocator: Allocator) Error![]const []const u8 {1395        var scan: index_mod.Scan = undefined;1396        try self.terms.scan(&scan, allocator, null, null);1397        defer scan.deinit();1398        var keys: std.ArrayList([]const u8) = .empty;1399        errdefer posting_mod.freeStringSlice(allocator, keys.items);1400        while (try scan.next()) |entry| try keys.append(allocator, try allocator.dupe(u8, entry.key));1401        return try keys.toOwnedSlice(allocator);1402    }14031404    fn collectPostings(self: anytype, allocator: Allocator, documents: []const Document) Error!posting_mod.PostingSet {1405        var postings: std.ArrayList(posting_mod.Posting) = .empty;1406        errdefer postings.deinit(allocator);1407        var keys: std.ArrayList([]const u8) = .empty;1408        errdefer posting_mod.deinitStringList(allocator, &keys);1409        var key_map = posting_mod.PostingKeyMap.init(allocator);1410        defer key_map.deinit();1411        const phrase_pairs = self.index_phrase_pairs and !self.omit_phrase_pair_singletons;1412        if (!self.index_prefixes) {1413            const postings_capacity = bulkCapacity(documents.len, if (phrase_pairs) 32 else 16, 0);1414            try postings.ensureTotalCapacity(allocator, postings_capacity);1415            const key_capacity = bulkCapacity(documents.len, if (phrase_pairs) 2 else 1, 64);1416            try keys.ensureTotalCapacity(allocator, key_capacity);1417            try key_map.ensureTotalCapacity(hashCapacityHint(key_capacity));1418        }1419        const term_count_capacity = try documentTermCountScratchCapacity(documents, self.index_prefixes, phrase_pairs);1420        const term_counts: []posting_mod.TermCount = if (term_count_capacity == 0)1421            &.{}1422        else1423            try allocator.alloc(posting_mod.TermCount, term_count_capacity);1424        defer if (term_counts.len != 0) allocator.free(term_counts);1425        for (documents) |document| {1426            const counts = try posting_mod.documentInternedTermCounts(allocator, token_mod.documentText(document.text), self.index_prefixes, phrase_pairs, &key_map, &keys, term_counts);1427            try postings.ensureUnusedCapacity(allocator, counts.len);1428            for (counts) |term_count| {1429                const key_index = key_map.get(term_count.key) orelse return error.InvalidSearchIndex;1430                const count = std.math.cast(u32, term_count.count) orelse return error.InvalidSearchIndex;1431                postings.appendAssumeCapacity(.{ .rowid = document.rowid, .key_index = key_index, .count = count });1432            }1433        }1434        if (self.index_phrase_pairs and self.omit_phrase_pair_singletons) try posting_mod.collectPartialPhrasePairPostings(allocator, documents, &postings, &keys);1435        const items = try postings.toOwnedSlice(allocator);1436        errdefer if (items.len != 0) allocator.free(items);1437        return .{1438            .items = items,1439            .keys = try keys.toOwnedSlice(allocator),1440        };1441    }1442};

1pub const Search = search.Search;