diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e5f7cb..752b8e5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Changelog +## 3.12.7 + +- A feed of more than about a million distinct object keys keeps every record + over a stop and a start. Stream frames were verified with FlatBuffers' + default limit of 1,000,000 tables, and a checkpoint's dictionary segment is + one table per key, so a larger segment was refused: the checkpoint at stop + failed with status -4, and the next open replayed the stream and cut it at + the refused segment, losing every record after it. Frames are now verified + with a table limit sized to the frame (a table takes at least 4 bytes), + never below the default. A store written by an earlier version still holds + those records in its stream and keeps them when this version opens it. + ## 3.12.6 - Full-text search finds records that were stored with their FlatBuffer size diff --git a/cpp/src/p4/car.cpp b/cpp/src/p4/car.cpp index 5e3cbf7..4068c74 100644 --- a/cpp/src/p4/car.cpp +++ b/cpp/src/p4/car.cpp @@ -112,7 +112,7 @@ FmbEntry decodeEntry(const ::FMBEntry* d) { FmbEntry e; e.kind=uint8_t(d->KIND() struct Batch { uint64_t oldOffset=0; FmbCommit commit; }; struct Record { std::array digest{},bytesDigest{}; std::string cid; uint32_t length=0; }; bool decodeBatch(const std::string& bytes,Batch* batch,std::map* records) { - Aligned a(bytes); flatbuffers::Verifier v(a.data(),a.size); if(!VerifyFMBBuffer(v)) return false; const auto* m=GetFMB(a.data()); + Aligned a(bytes); flatbuffers::Verifier v(a.data(),a.size,frameVerifierOptions(a.size)); if(!VerifyFMBBuffer(v)) return false; const auto* m=GetFMB(a.data()); batch->oldOffset=m->SELF_OFFSET(); auto& out=batch->commit; out.committedAt=m->COMMITTED_AT(); out.typeSeqHigh=m->TYPE_SEQ_HIGH(); if(m->GROUPS()) for(const auto* g:*m->GROUPS()) out.groups.push_back({g->DELIVERED_AT(),g->NODE_ID(),g->BATCH_ID(),g->CONTENT_KEY_ID(),g->URL_ID()}); if(m->DICTIONARY()) for(const auto* d:*m->DICTIONARY()) out.dictionary.push_back(decodeEntry(d)); @@ -162,7 +162,7 @@ flatbuffers::Offset<::FMBEntry> encodeEntry(flatbuffers::FlatBufferBuilder& b,co int32_t appendSegments(Feed* f,Stream* stream,const std::vector& segmentBytes,const FCK* ck, const std::map& refs,const std::string& previousRoot,uint64_t applied,int64_t* end,uint64_t* previous) { std::map source; - for(const auto& bytes:segmentBytes) { Aligned a(bytes); flatbuffers::Verifier v(a.data(),a.size); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; source.emplace(GetFSG(a.data())->SELF_OFFSET(),bytes); } + for(const auto& bytes:segmentBytes) { Aligned a(bytes); flatbuffers::Verifier v(a.data(),a.size,frameVerifierOptions(a.size)); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; source.emplace(GetFSG(a.data())->SELF_OFFSET(),bytes); } std::vector<::FCKSegment> desc; std::vector digests; if(ck->SEGMENTS()) for(const auto* old:*ck->SEGMENTS()) { auto i=source.find(old->OFFSET()); if(i==source.end()) return FLATSQL_E_CORRUPT; @@ -221,7 +221,7 @@ static int32_t carRestoreOnWriter(Type* type,const std::string& path,Feed** rest if(!archive.block(archive.root,&root) || !ipldLinks(root,&links)) return FLATSQL_E_CORRUPT; std::string checkpoint; for(const auto& link:links) if(link.name=="checkpoint" && !archive.block(link.cid,&checkpoint)) return FLATSQL_E_CORRUPT; if(checkpoint.empty()) return FLATSQL_E_CORRUPT; - Aligned ckBytes(checkpoint); flatbuffers::Verifier verifier(ckBytes.data(),ckBytes.size); if(!VerifyFCKBuffer(verifier)) return FLATSQL_E_CORRUPT; const auto* ck=GetFCK(ckBytes.data()); + Aligned ckBytes(checkpoint); flatbuffers::Verifier verifier(ckBytes.data(),ckBytes.size,frameVerifierOptions(ckBytes.size)); if(!VerifyFCKBuffer(verifier)) return FLATSQL_E_CORRUPT; const auto* ck=GetFCK(ckBytes.data()); if(!ck->FEED_ID() || ck->FEED_ID()>1000000 || !ck->TYPE() || ck->TYPE()->str()!=type->name || !ck->PROVIDER() || !ck->SOURCE() || !ck->COUNTERS()) return FLATSQL_E_CORRUPT; std::vector batches; std::vector segments; std::map records; for(const auto& cid:archive.order) { diff --git a/cpp/src/p4/checkpoint.cpp b/cpp/src/p4/checkpoint.cpp index 4373622..3c42a7b 100644 --- a/cpp/src/p4/checkpoint.cpp +++ b/cpp/src/p4/checkpoint.cpp @@ -45,7 +45,7 @@ int32_t appliedEnd(Stream* stream,uint64_t previous,uint64_t* end) { while(at!=UINT64_MAX) { std::vector storage; uint32_t n=0; const int32_t rc=frame(stream,at,&storage,&n); if(rc!=FLATSQL_OK) return rc; - const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n); + const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); if(flatbuffers::BufferHasIdentifier(p,"$FMB")) { if(!VerifyFMBBuffer(v)) return FLATSQL_E_CORRUPT; *end=at+4+n; return FLATSQL_OK; } if(flatbuffers::BufferHasIdentifier(p,"$FCK")) { if(!VerifyFCKBuffer(v)) return FLATSQL_E_CORRUPT; *end=GetFCK(p)->APPLIED_THROUGH(); return FLATSQL_OK; } if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; @@ -102,7 +102,7 @@ int32_t readSegment(Feed* f,Stream* stream,const CheckpointSegment& desc,Segment int32_t rc=frame(stream,desc.offset,&storage,&n); if(rc!=FLATSQL_OK || n!=desc.length) return FLATSQL_E_CORRUPT; const auto* p=reinterpret_cast(storage.data()); std::array digest{}; ps::sha256(p,n,digest.data()); if(digest!=desc.digest) return FLATSQL_E_CORRUPT; - flatbuffers::Verifier v(p,n); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; + flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; const auto* s=GetFSG(p); if(s->SELF_OFFSET()!=desc.offset || s->FEED_ID()!=f->fid || s->KIND()!=desc.kind || s->LEVEL()!=desc.level || s->COVERS_THROUGH()!=desc.coversThrough || s->MIN_SEQ()!=desc.minSeq || s->MAX_SEQ()!=desc.maxSeq || desc.kind>kFsgMaxKind) return FLATSQL_E_CORRUPT; @@ -185,7 +185,7 @@ int32_t changes(Stream* stream,uint64_t previous,uint64_t after,TailChanges* cha uint64_t at=previous; while(at!=UINT64_MAX) { std::vector storage; uint32_t n=0; int32_t rc=frame(stream,at,&storage,&n); if(rc!=FLATSQL_OK) return rc; - const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n); uint64_t prev; + const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); uint64_t prev; const bool tail=at+4+n>after; if(flatbuffers::BufferHasIdentifier(p,"$FMB")) { if(!VerifyFMBBuffer(v)) return FLATSQL_E_CORRUPT; const auto* m=GetFMB(p); prev=m->PREVIOUS(); @@ -397,7 +397,7 @@ int32_t checkpointVerifyPairs(Feed* f,Stream* stream,const CheckpointSegment& de int32_t rc=frame(stream,desc.offset,&storage,&n); if(rc!=FLATSQL_OK || n!=desc.length) return FLATSQL_E_CORRUPT; const auto* p=reinterpret_cast(storage.data()); std::array digest{}; ps::sha256(p,n,digest.data()); if(digest!=desc.digest) return FLATSQL_E_CORRUPT; - flatbuffers::Verifier v(p,n); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; + flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); if(!VerifyFSGBuffer(v)) return FLATSQL_E_CORRUPT; const auto* s=GetFSG(p); if(s->SELF_OFFSET()!=desc.offset || s->FEED_ID()!=f->fid || s->KIND()!=desc.kind || s->LEVEL()!=desc.level || s->COVERS_THROUGH()!=desc.coversThrough || s->MIN_SEQ()!=desc.minSeq || s->MAX_SEQ()!=desc.maxSeq || !s->PAIRS() || s->PAIRS()->size()!=desc.entries) return FLATSQL_E_CORRUPT; @@ -420,7 +420,7 @@ int32_t checkpointReadPairs(Feed* f,const std::shared_ptr& stream,const int32_t checkpointReadAt(Feed* f,Stream* stream,uint64_t offset,CheckpointState* state,std::string* err) { std::vector storage; uint32_t n=0; int32_t rc=frame(stream,offset,&storage,&n); auto fail=[&]() { if(err) *err="invalid checkpoint or segment in "+stream->path+" at "+std::to_string(offset); return FLATSQL_E_CORRUPT; }; - if(rc!=FLATSQL_OK) return fail(); const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n); + if(rc!=FLATSQL_OK) return fail(); const auto* p=reinterpret_cast(storage.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); if(!VerifyFCKBuffer(v)) return fail(); const auto* ck=GetFCK(p); if(ck->SELF_OFFSET()!=offset || ck->FEED_ID()!=f->fid || ck->GENERATION()!=stream->gen || !ck->COUNTERS() || ck->APPLIED_THROUGH()>offset) return fail(); CheckpointState out; out.offset=offset; out.end=offset+4+n; out.appliedThrough=ck->APPLIED_THROUGH(); out.typeSeqHigh=ck->TYPE_SEQ_HIGH(); out.checkpointBytes=n+4; @@ -645,7 +645,7 @@ int32_t checkpointAppend(Feed* f,Conn* c,Stream* stream,const Counters& counters std::vector storage; uint32_t n=0; rc=frame(stream,at,&storage,&n); if(rc!=FLATSQL_OK) return rc; const auto* bytes=reinterpret_cast(storage.data()); - flatbuffers::Verifier verifier(bytes,n); + flatbuffers::Verifier verifier(bytes,n,frameVerifierOptions(n)); if(!VerifyFMBBuffer(verifier)) return FLATSQL_E_CORRUPT; const auto* m=GetFMB(bytes); if(m->PREVIOUS()>=at || (m->REMOVALS() && m->REMOVALS()->size()) || diff --git a/cpp/src/p4/checkpoint_search.cpp b/cpp/src/p4/checkpoint_search.cpp index 2d38e2a..ba28a9b 100644 --- a/cpp/src/p4/checkpoint_search.cpp +++ b/cpp/src/p4/checkpoint_search.cpp @@ -23,7 +23,7 @@ bool readFrame(Stream* s,uint64_t at,uint64_t size,Frame* f) { std::memcpy(f->aligned.data(),bytes.data(),n); return true; } bool commitHeader(Frame* f,Feed* feed) { - flatbuffers::Verifier v(f->data(),f->length); + flatbuffers::Verifier v(f->data(),f->length,frameVerifierOptions(f->length)); if(!std::memcmp(f->data()+4,"$FCK",4)) { if(!VerifyFCKBuffer(v)) return false; const auto* x=GetFCK(f->data()); diff --git a/cpp/src/p4/dag.cpp b/cpp/src/p4/dag.cpp index 2a21e96..7815587 100644 --- a/cpp/src/p4/dag.cpp +++ b/cpp/src/p4/dag.cpp @@ -67,7 +67,7 @@ int32_t readMeta(Stream* stream,uint64_t at,uint64_t end,Meta* m) { const uint32_t n=ld32(reinterpret_cast(prefix.data())); if(n<8 || uint64_t(n)>end-at-4) return FLATSQL_E_CORRUPT; rc=streamReadRange(stream,int64_t(at+4),n,&m->bytes); if(rc!=FLATSQL_OK) return rc; std::vector aligned((n+7)/8); std::memcpy(aligned.data(),m->bytes.data(),n); - const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n); + const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); m->offset=at; if(!std::memcmp(p+4,"$FMB",4) && VerifyFMBBuffer(v)) { const auto* x=GetFMB(p); m->previous=x->PREVIOUS(); m->kind=FLATSQL_RANGE_FMB; if(x->SELF_OFFSET()!=at) return FLATSQL_E_CORRUPT; } else if(!std::memcmp(p+4,"$FCK",4) && VerifyFCKBuffer(v)) { const auto* x=GetFCK(p); m->previous=x->PREVIOUS(); m->kind=FLATSQL_RANGE_FCK; if(x->SELF_OFFSET()!=at) return FLATSQL_E_CORRUPT; } diff --git a/cpp/src/p4/frames.cpp b/cpp/src/p4/frames.cpp index 14211f3..aba057d 100644 --- a/cpp/src/p4/frames.cpp +++ b/cpp/src/p4/frames.cpp @@ -284,7 +284,7 @@ bool completedGeneration(Stream* stream,uint32_t fid,uint32_t gen) { if(fmb || fck || fsg) { std::string data; if(streamRead(stream,at,n,&data)!=FLATSQL_OK) break; std::vector aligned((n+7)/8); std::memcpy(aligned.data(),data.data(),n); - auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier verifier(p,n); + auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier verifier(p,n,frameVerifierOptions(n)); if(fmb) { if(!VerifyFMBBuffer(verifier)) break; const auto* m=GetFMB(p); @@ -346,7 +346,7 @@ int32_t streamDiscover(Type* t,Conn* idx,std::string* err) { uint32_t n=ld32(reinterpret_cast(prefix.data())); if(n<8 || n>(1u<<20) || int64_t(n)+4>size) continue; std::string bytes; if(streamRead(&stream,0,n,&bytes)!=FLATSQL_OK) continue; std::vector aligned((n+7)/8); std::memcpy(aligned.data(),bytes.data(),n); - const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n); + const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); if(!VerifyFCKBuffer(v)) continue; const auto* ck=GetFCK(p); if(ck->SELF_OFFSET()!=0 || ck->PREVIOUS()!=UINT64_MAX || !ck->FEED_ID() || ck->FEED_ID()>1000000 || !ck->TYPE() || ck->TYPE()->str()!=t->name || !ck->PROVIDER() || !ck->SOURCE()) continue; diff --git a/cpp/src/p4/recovery.cpp b/cpp/src/p4/recovery.cpp index f843105..a16d669 100644 --- a/cpp/src/p4/recovery.cpp +++ b/cpp/src/p4/recovery.cpp @@ -308,7 +308,7 @@ void collectMoves(Stream* stream,uint64_t previous,Feed* f,std::set* mo std::vector aligned; uint32_t size; if(!loadAligned(stream,previous,&aligned,&size)) return; const uint8_t* p=reinterpret_cast(aligned.data()); - flatbuffers::Verifier verifier(p,size); + flatbuffers::Verifier verifier(p,size,frameVerifierOptions(size)); if(!std::memcmp(p+4,"$FCK",4)) { if(!VerifyFCKBuffer(verifier)) return; const auto* ck=GetFCK(p); @@ -369,7 +369,7 @@ int32_t recoverFeed(Type* t,Feed* f,Conn* c,std::vector* moved,std::str for(;;) { std::vector aligned; uint32_t n=0; if(!loadAligned(stream.get(),point,&aligned,&n) || point+4+n>uint64_t(meta.mark)) break; - const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n); + const auto* p=reinterpret_cast(aligned.data()); flatbuffers::Verifier v(p,n,frameVerifierOptions(n)); uint64_t prior=UINT64_MAX; if(!std::memcmp(p+4,"$FCK",4)) { if(!VerifyFCKBuffer(v) || GetFCK(p)->SELF_OFFSET()!=point || GetFCK(p)->FEED_ID()!=f->fid) break; @@ -442,7 +442,7 @@ int32_t recoverFeed(Type* t,Feed* f,Conn* c,std::vector* moved,std::str uint32_t actual; if(!loadAligned(stream.get(),uint64_t(at),&aligned,&actual)) break; const auto* bytes=reinterpret_cast(aligned.data()); - flatbuffers::Verifier verifier(bytes,n); + flatbuffers::Verifier verifier(bytes,n,frameVerifierOptions(n)); if(batch) { if(!VerifyFMBBuffer(verifier)) break; const auto* m=GetFMB(bytes); diff --git a/cpp/src/p4/sds_frames.h b/cpp/src/p4/sds_frames.h index 69f93f3..d634954 100644 --- a/cpp/src/p4/sds_frames.h +++ b/cpp/src/p4/sds_frames.h @@ -4,10 +4,21 @@ #include "FMB/main_generated.h" #include "FCK/main_generated.h" #include "FSG/main_generated.h" +#include #include #include #include "frames.h" namespace flatsql { namespace p4 { +// The verifier options of a stream frame ($FMB, $FCK, $FSG) of n bytes. A +// table takes at least 4 bytes, so the frame holds at most n/4 tables. +// FlatBuffers' default bound of 1,000,000 tables refuses a valid checkpoint +// segment with more entries (a dictionary of over a million object keys is +// one table per key), and a refused segment reads as a corrupt feed. +inline flatbuffers::Verifier::Options frameVerifierOptions(size_t n) { + flatbuffers::Verifier::Options o; + o.max_tables=flatbuffers::uoffset_t(std::max(o.max_tables,n/4+1)); + return o; +} // An FMB side table (SEALED, LARGE, SIGNATURES, IDENTITIES) indexed by ROW // once per frame; empty when the table is absent. False on a ROW outside the // frame's rows or a repeated ROW. diff --git a/cpp/tests/p4/t_million_objects.cpp b/cpp/tests/p4/t_million_objects.cpp new file mode 100644 index 0000000..ccf0b8b --- /dev/null +++ b/cpp/tests/p4/t_million_objects.cpp @@ -0,0 +1,100 @@ +// A feed of more than a million objects survives a stop and a start. +// +// A checkpoint's dictionary segment holds one FlatBuffer table per entry (an +// object key is one). Once a feed's dictionary segment passed 1,000,000 +// entries, FlatBuffers' default verifier bound (1,000,000 tables) refused it: +// the next checkpoint and the stop failed with P4_E_CORRUPT, and the open +// replayed the stream, stopped at that segment and cut the stream there. +// +// t_million_objects writes --records distinct OMM objects (default +// 1,100,000) into one feed in 4,096-record PUTs, compacts the feed (a fresh +// generation, as a format-4 conversion writes it: the whole dictionary in one +// segment), writes 4,096 more objects, stops the engine, opens it again and +// reads every record back: both stops answer OK and every record is held with +// its bytes. +#include +#include +#include + +#include "internal.h" +#include "p4/p4_test.h" + +using namespace p4t; +namespace fp = flatsql::p4; +namespace flatsql { namespace p4 { P4Engine* currentEngine(); } } + +namespace { +std::vector objectFrame(long i) { + return ommFrame(uint32_t(100000 + i), "2026-" + std::to_string(1000000 + i), isoTime(1789000000)); +} +Result putObjects(long from, long to) { + Batch b; + b.type = "OMM"; + b.peer = "12D3KooWMillion"; + b.tags.push_back(Tag{"million", "objects", "", "b1", "", "", ""}); + for (long i = from; i < to; i++) { + In r; + r.frame = objectFrame(i); + r.ts = 1790000000; + b.recs.push_back(std::move(r)); + } + return put(b); +} +} // namespace + +FLATSQL_SLOW_TEST(t_million_objects) { + const long n = argInt("records", 1100000); + const std::string dir = scratchDir("t_million_objects"); + REQUIRE(openEngine(dir) == FLATSQL_OK, "open a fresh store"); + REQUIRE(registerType(ommType()) == FLATSQL_OK, "register OMM"); + for (long at = 0; at < n; at += 4096) { + const Result w = putObjects(at, std::min(n, at + 4096)); + REQUIRE(w.status == FLATSQL_OK, "put at " + std::to_string(at) + ": " + w.err); + } + { + auto* e = fp::currentEngine(); + auto* t = e->findType("OMM"); + REQUIRE(t, "the OMM type"); + fp::Feed* feed = nullptr; + { + std::lock_guard lock(t->mu); + for (auto& f : t->feeds) + if (f && f->provider == "million") feed = f.get(); + } + REQUIRE(feed, "the feed"); + fp::Internal in; + in.what = feed->fid; + in.force = true; + REQUIRE(fp::runOnWriter(e, t, fp::kOpCompact, &in) == FLATSQL_OK && in.b > 0, "compaction: " + in.err); + } + const long total = n + 4096; + const Result w = putObjects(n, total); + REQUIRE(w.status == FLATSQL_OK, "put after the compaction: " + w.err); + CHECK_EQ(closeEngine(300000), FLATSQL_OK, "the stop checkpoints the feed"); + + REQUIRE(openEngine(dir, [] { EngineOpts o; o.createMode = 0; return o; }()) == FLATSQL_OK, "open again"); + REQUIRE(registerType(ommType()) == FLATSQL_OK, "register OMM again"); + long held = 0, wrong = 0; + for (long at = 0; at < total; at += 512) { + std::vector> cids; + std::map want; // CID text -> record bytes + for (long i = at; i < std::min(total, at + 512); i++) { + const std::vector frame = objectFrame(i); + uint8_t cid[36]; + cidOf(frame, cid); + cids.emplace_back(cid, cid + 36); + want[cidText(cid)] = std::string(reinterpret_cast(frame.data() + 4), frame.size() - 4); + } + const Result g = get("OMM", cids); + REQUIRE(g.status == FLATSQL_OK, "get at " + std::to_string(at) + ": " + g.err); + held += long(g.rows.size()); + for (size_t r = 0; r < g.rows.size(); r++) { + auto it = want.find(g.s(r, "cid")); + if (it == want.end() || it->second != g.s(r, "data")) wrong++; + } + } + CHECK_EQ(held, total, "every record is held after the reopen"); + CHECK_EQ(wrong, 0, "every record has its bytes"); + CHECK_EQ(closeEngine(300000), FLATSQL_OK, "the second stop"); + removeTree(dir); +} diff --git a/package-lock.json b/package-lock.json index b9264ff..771d265 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "flatsql", - "version": "3.12.6", + "version": "3.12.7", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "flatsql", - "version": "3.12.6", + "version": "3.12.7", "license": "PolyForm-Noncommercial-1.0.0", "bin": { "flatsql": "bin/flatsql.mjs" diff --git a/package.json b/package.json index 176f8ec..4634ec6 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "flatsql", - "version": "3.12.6", + "version": "3.12.7", "description": "One SQL engine for binary FlatBuffer streams: SDS QRP queries and results, SDS GJN geometry, persistent indexed storage, and one WASI threads artifact across hosts.", "type": "module", "main": "wasm/index.js", diff --git a/scripts/ci-e2e.sh b/scripts/ci-e2e.sh index 6a6d308..ec21f5c 100644 --- a/scripts/ci-e2e.sh +++ b/scripts/ci-e2e.sh @@ -45,7 +45,7 @@ if [[ "$mode" != --wasm-only ]]; then build="${FLATSQL_CI_BUILD_DIR:-cpp/build-ci-e2e}" run native-configure cmake -S cpp -B "$build" -DCMAKE_BUILD_TYPE=Release "-DFLATBUFFERS_DIR=$FLATBUFFERS_DIR" run native-build cmake --build "$build" --target flatsql_p4_test --parallel "${FLATSQL_BUILD_JOBS:-4}" - for flow in t_gjn_binary_query_reopen t_sql_surface t_kill_check_compaction t_fts_prefix_aligned t_fts_record_envelopes t_fts_upgrade t_fts_rebuild_immediate t_fts_repair_pages t_fts_rebuild_held t_fts_repair_crash t_fts_empty_type t_fts_concurrent_readers t_fts_snapshot_ingest t_fts_snapshot_reset t_fts_version_range t_fts_rebuild_retry t_fts_summary_ingest t_fts_summary_repair_mark t_fts_rebuild_range; do + for flow in t_gjn_binary_query_reopen t_sql_surface t_kill_check_compaction t_fts_prefix_aligned t_fts_record_envelopes t_fts_upgrade t_fts_rebuild_immediate t_fts_repair_pages t_fts_rebuild_held t_fts_repair_crash t_fts_empty_type t_fts_concurrent_readers t_fts_snapshot_ingest t_fts_snapshot_reset t_fts_version_range t_fts_rebuild_retry t_fts_summary_ingest t_fts_summary_repair_mark t_fts_rebuild_range t_million_objects; do run "$flow" "$build/flatsql_p4_test" "--test=$flow" # The test harness permits an unmatched filter; an empty run is not evidence. grep -q '^1 tests, 0 failures$' "$results/$flow.log" diff --git a/wasm/flatsql.wasm b/wasm/flatsql.wasm index 4c8edb1..2f22528 100755 Binary files a/wasm/flatsql.wasm and b/wasm/flatsql.wasm differ diff --git a/wasm/integrity.json b/wasm/integrity.json index 3263d3a..9bba86b 100644 --- a/wasm/integrity.json +++ b/wasm/integrity.json @@ -1,13 +1,13 @@ { "algorithm": "sha384", - "hash": "x2ZJHpfRmqNq/T/n47rOVoUKQAhwFmJ1IMkTRwmxnJMPnxWR8gT7bsAfHGgFwdYu", - "sri": "sha384-x2ZJHpfRmqNq/T/n47rOVoUKQAhwFmJ1IMkTRwmxnJMPnxWR8gT7bsAfHGgFwdYu", - "size": 3764279, + "hash": "5lUao/KOC7pXnuZUYmQVdVl7bQxZWMpLyfaSzern9w5KTZoGQaXLYFjTgP4lHE3K", + "sri": "sha384-5lUao/KOC7pXnuZUYmQVdVl7bQxZWMpLyfaSzern9w5KTZoGQaXLYFjTgP4lHE3K", + "size": 3764602, "files": { "flatsql.wasm": { - "sha256": "aec32d3e0dd17a0f2272a5aa30761c5b6f445c7817a7c03375acf607752e836c", - "sri": "sha384-x2ZJHpfRmqNq/T/n47rOVoUKQAhwFmJ1IMkTRwmxnJMPnxWR8gT7bsAfHGgFwdYu", - "size": 3764279 + "sha256": "19361edfb3e6613f857af8b5512fccae8c49a656ab42c99b7114e76a2f6ba175", + "sri": "sha384-5lUao/KOC7pXnuZUYmQVdVl7bQxZWMpLyfaSzern9w5KTZoGQaXLYFjTgP4lHE3K", + "size": 3764602 } } }