asami.durable.tuples — org.clojars.quoll/asami 2.0.0-alpha2

Tuples index with blocks

add-single-tuple! clj/s

(add-single-tuple! tuple node block pos tuple-count byte-pos byte-len)

Performs the operation necessary to add a single tuple from a node/block. tuple: the tuple to be added node: the node to be modified block: the tuples block to be modified pos: the tuple position within the block tuple-count: the number of tuples in the block byte-pos: the byte position representing the pos byte-len: the bytes from the byte position to the end of the block

block-bytes clj/s

Number of bytes in a full block

block-max clj/s

Maximum number of tuples in a block

block-name clj/s

Name of the block statement file

block-reference-offset clj/s

count-code-mask clj/s

count-mask clj/s

The mask to apply for the count bits

count-shift clj/s

The shift to get the count bits

create-tuple-index clj/s

(create-tuple-index name order-name)

(create-tuple-index name order-name root-id)

Creates a tuple index for a name

dec-tuple-size clj/s

One less than the number of values in a tuple

delete-single-tuple! clj/s

(delete-single-tuple! node block pos tuple-count byte-pos byte-len)

Performs the operation necessary to remove a single tuple from a node/block. node: the node to be modified block: the tuples block to be modified pos: the tuple position within the block tuple-count: the number of tuples in the block byte-pos: the byte position representing the pos byte-len: the bytes from the byte position to the end of the block

find-coord clj/s

(find-coord index blocks tuple)

Retrieves the coordinate of a tuple. A coordinate is a structure of node/pos for the node and offset in the node's block. If the tuple is found, then returns a coordinate. If the tuple is not found, then return a pair of coordinates that the tuple appears between. A nil coordinate in a pair indicates the end of the range of the index.

find-index-tuple clj/s

(find-index-tuple index blocks tuple)

Finds a tuple seq in an index

get-block-ref clj/s

(get-block-ref node)

Gets the ID of the block that contains the tuples

get-count clj/s

(get-count node)

Returns the number of tuples in the block

get-high-tuple clj/s

(get-high-tuple node)

Returns the high tuple value from the node's range

get-low-tuple clj/s

(get-low-tuple node)

Returns the low tuple value from the node's range

half-block clj/s

Half the maximum number of tuples in a block

half-block-bytes clj/s

Number of bytes in a full block

high-tuple-offset clj/s

index-name clj/s

Name of the index file

init-node-writer clj/s

(init-node-writer block-id node tuple)

insert-tuple! clj/s

(insert-tuple! {:keys [index blocks root-id] :as this} tuple short-tuple)

Inserts a tuple into an index

low-tuple-offset clj/s

modify-node-block! clj/s

(modify-node-block! {:keys [index blocks] :as tuples-store}
                    {:keys [node pos] :as coord}
                    op!)

Modifies a node and associated block, using the provided operation

next-populated clj/s

(next-populated index node)

Returns the next node with tuples, starting with the provided node.

open-tuples clj/s

(open-tuples order-name name root-id)

partial-equal clj/s

(partial-equal [t1 & r1] [t2 & r2])

Compares tuples. If one is only partial, then they are allowed to compare equal

ReadOnlyTupleIndex clj/s

reference-mask clj/s

search-block clj/s

(search-block block len tuple)

Returns the tuple offset in a block that matches a given tuple. If no tuple matches exactly, then returns a pair of positions to insert between.

set-block-ref! clj/s

(set-block-ref! node block-ref)

Sets the ID of the block that contains the tuples

set-count! clj/s

(set-count! node count*)

Sets the number of tuples in the block

set-high-tuple! clj/s

(set-high-tuple! node tuple)

Sets the high tuple value of the node's range

set-low-tuple! clj/s

(set-low-tuple! node tuple)

Sets the low tuple value of the node's range

set-tuple-at! clj/s

(set-tuple-at! block offset tuple)

Retrieves the tuple found at a particular tuple offset

split-block! clj/s

(split-block! {:keys [index blocks root-id] :as tuples-store}
              {node :node pos :pos :as coord})

Updates a node and associated block to split them into 2 nodes and 2 blocks. Returns the new insertion coordinate

split-node-writer clj/s

(split-node-writer block-id node [low high])

tree-node-size clj/s

Number of bytes used in the index nodes

tuple-at clj/s

(tuple-at block offset)

Retrieves the tuple found at a particular tuple offset

tuple-at-coord clj/s

(tuple-at-coord blocks {:keys [node pos]})

Retrieves the tuple at a coordinate

tuple-node-compare clj/s

(tuple-node-compare tuple node)

Compare the contents of a tuple to the range of a node

tuple-seq clj/s

(tuple-seq index blocks tuple node offset)

Create a lazy sequence of tuples. This iterates through the block associated with the given node, until reaching the size of the block. Then moves to the next node, and starts iterating through the block associated with it. Continues as long as the provided tuple matches the tuple in the block. index: the tree index with the nodes blocks: the block manager for tuples blocks tuple: the tuple being searched for. Every returned tuple with match this one by prefix offset: the starting point of iteration

tuple-size clj/s

The number of values in a tuple

tuple-size-bytes clj/s

The number of bytes in a tuple

TupleIndex clj/s