Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 12 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
@@ -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
Expand Down
6 changes: 3 additions & 3 deletions cpp/src/p4/car.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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<uint8_t,32> digest{},bytesDigest{}; std::string cid; uint32_t length=0; };
bool decodeBatch(const std::string& bytes,Batch* batch,std::map<uint64_t,Record>* 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));
Expand Down Expand Up @@ -162,7 +162,7 @@ flatbuffers::Offset<::FMBEntry> encodeEntry(flatbuffers::FlatBufferBuilder& b,co
int32_t appendSegments(Feed* f,Stream* stream,const std::vector<std::string>& segmentBytes,const FCK* ck,
const std::map<uint64_t,uint64_t>& refs,const std::string& previousRoot,uint64_t applied,int64_t* end,uint64_t* previous) {
std::map<uint64_t,std::string> 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<uint8_t> digests;
if(ck->SEGMENTS()) for(const auto* old:*ck->SEGMENTS()) {
auto i=source.find(old->OFFSET()); if(i==source.end()) return FLATSQL_E_CORRUPT;
Expand Down Expand Up @@ -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<Batch> batches; std::vector<std::string> segments; std::map<uint64_t,Record> records;
for(const auto& cid:archive.order) {
Expand Down
12 changes: 6 additions & 6 deletions cpp/src/p4/checkpoint.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,7 @@ int32_t appliedEnd(Stream* stream,uint64_t previous,uint64_t* end) {
while(at!=UINT64_MAX) {
std::vector<uint64_t> 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<const uint8_t*>(storage.data()); flatbuffers::Verifier v(p,n);
const auto* p=reinterpret_cast<const uint8_t*>(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;
Expand Down Expand Up @@ -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<const uint8_t*>(storage.data());
std::array<uint8_t,32> 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;
Expand Down Expand Up @@ -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<uint64_t> storage; uint32_t n=0; int32_t rc=frame(stream,at,&storage,&n); if(rc!=FLATSQL_OK) return rc;
const auto* p=reinterpret_cast<const uint8_t*>(storage.data()); flatbuffers::Verifier v(p,n); uint64_t prev;
const auto* p=reinterpret_cast<const uint8_t*>(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();
Expand Down Expand Up @@ -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<const uint8_t*>(storage.data());
std::array<uint8_t,32> 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;
Expand All @@ -420,7 +420,7 @@ int32_t checkpointReadPairs(Feed* f,const std::shared_ptr<Stream>& stream,const
int32_t checkpointReadAt(Feed* f,Stream* stream,uint64_t offset,CheckpointState* state,std::string* err) {
std::vector<uint64_t> 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<const uint8_t*>(storage.data()); flatbuffers::Verifier v(p,n);
if(rc!=FLATSQL_OK) return fail(); const auto* p=reinterpret_cast<const uint8_t*>(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;
Expand Down Expand Up @@ -645,7 +645,7 @@ int32_t checkpointAppend(Feed* f,Conn* c,Stream* stream,const Counters& counters
std::vector<uint64_t> storage; uint32_t n=0;
rc=frame(stream,at,&storage,&n); if(rc!=FLATSQL_OK) return rc;
const auto* bytes=reinterpret_cast<const uint8_t*>(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()) ||
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/p4/checkpoint_search.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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());
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/p4/dag.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -67,7 +67,7 @@ int32_t readMeta(Stream* stream,uint64_t at,uint64_t end,Meta* m) {
const uint32_t n=ld32(reinterpret_cast<const uint8_t*>(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<uint64_t> aligned((n+7)/8); std::memcpy(aligned.data(),m->bytes.data(),n);
const auto* p=reinterpret_cast<const uint8_t*>(aligned.data()); flatbuffers::Verifier v(p,n);
const auto* p=reinterpret_cast<const uint8_t*>(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; }
Expand Down
4 changes: 2 additions & 2 deletions cpp/src/p4/frames.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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<uint64_t> aligned((n+7)/8); std::memcpy(aligned.data(),data.data(),n);
auto* p=reinterpret_cast<const uint8_t*>(aligned.data()); flatbuffers::Verifier verifier(p,n);
auto* p=reinterpret_cast<const uint8_t*>(aligned.data()); flatbuffers::Verifier verifier(p,n,frameVerifierOptions(n));
if(fmb) {
if(!VerifyFMBBuffer(verifier)) break;
const auto* m=GetFMB(p);
Expand Down Expand Up @@ -346,7 +346,7 @@ int32_t streamDiscover(Type* t,Conn* idx,std::string* err) {
uint32_t n=ld32(reinterpret_cast<const uint8_t*>(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<uint64_t> aligned((n+7)/8); std::memcpy(aligned.data(),bytes.data(),n);
const auto* p=reinterpret_cast<const uint8_t*>(aligned.data()); flatbuffers::Verifier v(p,n);
const auto* p=reinterpret_cast<const uint8_t*>(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;
Expand Down
6 changes: 3 additions & 3 deletions cpp/src/p4/recovery.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -308,7 +308,7 @@ void collectMoves(Stream* stream,uint64_t previous,Feed* f,std::set<int64_t>* mo
std::vector<uint64_t> aligned; uint32_t size;
if(!loadAligned(stream,previous,&aligned,&size)) return;
const uint8_t* p=reinterpret_cast<const uint8_t*>(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);
Expand Down Expand Up @@ -369,7 +369,7 @@ int32_t recoverFeed(Type* t,Feed* f,Conn* c,std::vector<int64_t>* moved,std::str
for(;;) {
std::vector<uint64_t> 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<const uint8_t*>(aligned.data()); flatbuffers::Verifier v(p,n);
const auto* p=reinterpret_cast<const uint8_t*>(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;
Expand Down Expand Up @@ -442,7 +442,7 @@ int32_t recoverFeed(Type* t,Feed* f,Conn* c,std::vector<int64_t>* moved,std::str
uint32_t actual;
if(!loadAligned(stream.get(),uint64_t(at),&aligned,&actual)) break;
const auto* bytes=reinterpret_cast<const uint8_t*>(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);
Expand Down
11 changes: 11 additions & 0 deletions cpp/src/p4/sds_frames.h
Original file line number Diff line number Diff line change
Expand Up @@ -4,10 +4,21 @@
#include "FMB/main_generated.h"
#include "FCK/main_generated.h"
#include "FSG/main_generated.h"
#include <algorithm>
#include <map>
#include <vector>
#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<size_t>(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.
Expand Down
100 changes: 100 additions & 0 deletions cpp/tests/p4/t_million_objects.cpp
Original file line number Diff line number Diff line change
@@ -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 <map>
#include <string>
#include <vector>

#include "internal.h"
#include "p4/p4_test.h"

using namespace p4t;
namespace fp = flatsql::p4;
namespace flatsql { namespace p4 { P4Engine* currentEngine(); } }

namespace {
std::vector<uint8_t> 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<std::mutex> 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<std::vector<uint8_t>> cids;
std::map<std::string, std::string> want; // CID text -> record bytes
for (long i = at; i < std::min(total, at + 512); i++) {
const std::vector<uint8_t> frame = objectFrame(i);
uint8_t cid[36];
cidOf(frame, cid);
cids.emplace_back(cid, cid + 36);
want[cidText(cid)] = std::string(reinterpret_cast<const char*>(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);
}
4 changes: 2 additions & 2 deletions package-lock.json

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion package.json
Original file line number Diff line number Diff line change
@@ -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",
Expand Down
Loading
Loading