Answer the several results of one call as one tuple - #37
Merged
estebanzimanyi merged 2 commits intoSep 3, 2026
Merged
Conversation
The catalog gives the R-tree and SP-tree kNN cursors classes, so the object layer carries `RTreeNNCursor` and `SPNNCursor`: a cursor is opened from a tree, closed when the walk ends, and the three entries sit on the cursor rather than among the tree's twenty methods. 115 classes and 1342 methods against 113 and 1338, 18 deferred against 22. `TBigint.Values` reaches the layer with them, its count declared the way its definition writes it, so every temporal number answers its distinct values as an array of them. `next` stays deferred on both cursors: it answers the id AND the distance through two out-parameters, and one body writing both is the same shape the value-and-time splits need.
A split states its pieces through the return and the bin each piece falls in through an array MEOS fills, and the flat wrapper already hands both over as a tuple. The object layer had no reading for a tuple return, so the methods that answer one deferred — the time and value splits of every temporal number, the sequence-set span walks, the jsonb each. They now answer `(Temporal?[], DateTime[])` and its siblings, each item read the way a return of its own type is: an array of MEOS values wrapped element by element, an array of instants read as instants, an array of scalars handed on. The element types come from the shape the catalog states — `arrayReturn.element` for the return and the out-array parameters for the rest — so nothing re-parses a C declaration. The five bodies a method could have were mutually exclusive, and two deferrals existed only to say so: a struct argument beside a counted array, and a length out-parameter beside either. One composed body replaces them. Everything the call needs is allocated or pinned first, the call is made ONCE, what it answers is read, and everything allocated is freed however the method leaves — so `timeSplit`, which takes an `Interval` by value and answers two arrays, needs no reading its parts do not already have. A call that allocates nothing has nothing to free, and gets the answer alone as its body. The layer emits 1351 methods over 115 classes with 9 deferred, against 1342 and 18. Its own test states that the pieces and the bins of a split arrive together and in step, from the one call that makes them.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
A split states its pieces through the return and the bin each piece falls in
through an array MEOS fills, and the flat wrapper already hands both over as a
tuple. The object layer had no reading for a tuple return, so the methods that
answer one deferred — the time and value splits of every temporal number, the
sequence-set span walks, the jsonb each. They now answer
(Temporal?[], DateTime[])and its siblings, each item read the way a return of its own typeis: an array of MEOS values wrapped element by element, an array of instants
read as instants, an array of scalars handed on. The element types come from
the shape the catalog states —
arrayReturn.elementfor the return and theout-array parameters for the rest — so nothing re-parses a C declaration.
The five bodies a method could have were mutually exclusive, and two deferrals
existed only to say so: a struct argument beside a counted array, and a length
out-parameter beside either. One composed body replaces them. Everything the
call needs is allocated or pinned first, the call is made ONCE, what it answers
is read, and everything allocated is freed however the method leaves — so
timeSplit, which takes anIntervalby value and answers two arrays, needsno reading its parts do not already have. A call that allocates nothing has
nothing to free, and gets the answer alone as its body.
The layer emits 1351 methods over 115 classes with 9 deferred, against 1342 and
18. Its own test states that the pieces and the bins of a split arrive together
and in step, from the one call that makes them.