The cl-bplustree Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-bplustree Reference Manual

This is the cl-bplustree Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:59:41 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction


h1. cl-bplustree - A Common Lisp implementation of an in-memory B+ tree.

*cl-bplustree* is an implementation of a in-memory B+ tree data structure in Common Lisp.

B+ trees main characteristics:

* All the data is in the leaves, internal nodes hold only keys used for traversal, pointers between the leaves are kept, so range-retrieval is easy and efficient.
* It is a generalization of a binary tree but instead of having only two pointers per node  to other nodes it can have many more (this is called the order of the tree) because of this characteristic the tree has typically a large fanout and a small depth.

For more information about B+ trees, check "Wikipedia":http://en.wikipedia.org/wiki/B%2B_tree.

h2. Dependencies

None.

h2. Usage

h3. @(bplustree-new (order &key key comparer))@

Creates a new empty B+ tre of the given order and returns it.

The _key_ parameter expects a function used to grab the key values (used for sorting) on whatever you are stuffing into the tree, the function will be called with one parameter (a record to be inserted into the tree for example) and it should return the value that will be used as a key. It defaults to @#'identity@.

The _comparer_ parameter expects a function used when comparing keys against each other in the tree operations. This function has to take two parameters (keys of records) and return a value depending on the following conditions:

@(< a b)@ -> -1
@(= a b)@ ->  0
@(> a b)@ ->  1

The meaning of this of course is given by your particular keys and your particular applications, for string keys for example @string<@, @string>@, etc., could be used.

This parameter defaults to a function that implements the explained logic but for numerical keys. If your keys are numeric, you don't need to supply a comparison function.

Example:

bc. (defparameter *my-tree* (bplustree-new 4 :key (lambda (r) (parse-integer r))))

h3. @(bplustree-empty-p (tree))@

Returns true if the tree is empty.

Example:

bc. (bplustree-empty-p *my-tree*) -> T

h3. @(bplustree-insert (record tree &optional key))@

Inserts the given _record_ into the given _tree_, if the given key already exists in the tree, the value is updated. Returns the tree but is not needed to capture it and assign it,this call is not destructive on the tree itself, althought its internal elements are changed by it.

If _key_ is omitted, calls the _key_ function passed to bplustree-new on _record_. If _key_ is included, uses that directly as the key. This enables using a B+ tree as a key/value store instead of a sorted set.

Examples:

bc. (bplustree-insert "100" *my-tree*)
(bplustree-insert "100" *my-tree* 100)

h3. @(bplustree-insert-many (tree &rest items))@

Inserts all the records given into the _tree_. Returns the tree.

Example:

bc. (bplustree-insert-many *my-tree* "5" "10" "-1" "1337" "212" "32" "311" "52")

h3. @(bplustree-search (key tree))@

Searches the value stored in the given _key_ in the given _tree_.

Example:

bc. (bplustree-search 311 *my-tree*) -> "311"

h3. @(bplustree-search-range (from to tree))@

Searches the tree for all the records that exists between the given _from_ and _to_ keys and returns them in a list.

Example:

bc. (bplustree-search-range 0 1000 *my-tree*) -> ("5" "10" "32" "52" "100" "212" "311")

h3. @(bplustree-search-next (key tree))@

Returns the first key after the passed _key_. Passing NIL for the _key_ returns the first key in the tree. The passed _key_ need not be in the tree. Still returns the first key greater than that, which IS in the tree. Returns NIL when passed the last key.

The record corresponding to the key is returned as a second value. If the key was cached, T is returned as a third value.

Examples:

bc. (bplustree-search-next nil *my-tree*) -> (values -1 "-1")
(bplustree-search-next -1 *my-tree*) -> (values 5 "-5" t)
(bplustree-search-next 1337 *my-tree*) -> nil

h3. @(bplustree-search-prev (key tree))@

Returns the key before the passed _key_. Passing NIL for the _key_ returns the last key in the tree. The passed _key_ need not be in the tree. Still returns the first key less than that, which IS in the tree. Returns NIL when passed the first key.

The record corresponding to the key is returned as a second value. If the key was cached, T is returned as a third value.

Examples:

bc. (bplustree-search-prev nil *my-tree*) -> (values 1337 "1337")
(bplustree-search-prev 1337 *my-tree*) -> (values 311 "311" t)
(bplustree-search-prev -1 *my-tree*) -> nil

h3. @(bplustree-delete (key tree))@

Deletes the record stored in the given _key_ in the _tree_. Returns the tree but is not needed to capture it and assign it, this call is not destructive on the tree itself, althought its internal elements are changed by it.

Example:

bc. (bplustree-delete 32 *my-tree*)
(bplustree-search-range 0 1000 *my-tree*)
("5" "10" "52" "100" "212" "311")


h3. @(bplustree-traverse (tree fn))@

Traverses all records in the tree in order from smallest to largest. As the B+ trees store data sorted already this operation is not expensive.

Example:

bc. (bplustree-traverse *my-tree* 'print)
"-1"
"5"
"10"
"32"
"52"
"212"
"311"
"1337"


h3. @(bplustree-traverse-with-keys (tree fn))@

Traverses all records in the tree in order from smallest to largest, calling fn on each with two args: the key and the value. As the B+ trees store data sorted already this operation is not expensive.

Example:

bc. (bplustree-traverse-with-keys *my-tree* (lambda (k v) (print (list k v))))
(-1 "-1") 
(5 "5") 
(10 "10") 
(32 "32") 
(52 "52") 
(212 "212") 
(311 "311") 
(1337 "1337")


h2. Final remarks

I hope this code is useful to you in any sense, either for learning, reading or maybe actual practical use, I will be very glad if you can even modify it to suit your needs. If you have suggestions please send them my way. Be sure to read *COPYING* file as well.

Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-bplustree

Author

Francisco Soto <ebobby@ebobby.org>

License

BSD

Description

In-memory B+ tree

Source

cl-bplustree.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 cl-bplustree.asd

Location

cl-bplustree.asd

Systems

cl-bplustree (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 cl-bplustree/packages.lisp

Parent

cl-bplustree (system)

Location

packages.lisp

Packages

org.ebobby.bplustree


Previous: , Up: Lisp files   [Contents][Index]

3.1.3 cl-bplustree/bplustree.lisp

Dependency

packages.lisp (file)

Parent

cl-bplustree (system)

Location

bplustree.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 org.ebobby.bplustree

Source

packages.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Functions

Function: bplustree-delete KEY TREE

Deletes a record from the given tree using the given key. Returns the tree with the record deleted.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-empty-p TREE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-insert RECORD TREE &optional KEY

Insert a record into the given tree using the given key. Returns the tree with the new record inserted. If ‘key‘ is included, uses that instead of calling the key function on ‘record‘.
This enabled using the tree as a key/value store instead of a sorted set.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-insert-many TREE &rest ITEMS

Insert as many records given into the tree. Returns the tree with the new records inserted.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-new ORDER &key KEY COMPARER

Makes a new B+ tree with the given order.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-search KEY TREE

Search for a record in the given tree using the given key.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-search-next KEY TREE

Return the first key in ‘tree‘ after the passed ‘key‘. Return the record as a second value.
If the third values is true, then the key and value were cached.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-search-prev KEY TREE

Return the key in ‘tree‘ before the passed ‘key‘.
Return the record as a second value.
If the third values is true, then the key and value were cached.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-search-range FROM TO TREE

Search and return a range of records in the given tree between the given keys.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-traverse TREE FN
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-traverse-with-keys TREE FN
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Macros

Macro: build-node-collection-accesors COLUMN

Generates the getter/setter functions for the btreeplus-node internal collections, keys and records.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Macro: build-node-collection-transfer COLUMN

Generates functions to transfer elements from a node into another node.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Macro: with-comparer-function TREE-NAME &body BODY

Wrap code inside a block that will create a dynamic variable that holds the comparer function.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: bplustree-cache INSTANCE
Function: (setf bplustree-cache) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-comparer INSTANCE
Function: (setf bplustree-comparer) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-depth INSTANCE
Function: (setf bplustree-depth) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-key INSTANCE
Function: (setf bplustree-key) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-order INSTANCE
Function: (setf bplustree-order) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-p OBJECT
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-root INSTANCE
Function: (setf bplustree-root) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-traverse-node NODE FN

Call ‘fn‘ on each leaf record in ‘node‘.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: bplustree-traverse-node-with-keys NODE FN

Call ‘fn‘ with key and record for each leaf of ‘node‘.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: build-node ORDER &optional KIND

Makes an empty B+ tree node with the given order and the optional type (:leaf or :internal).

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: copy-bplustree INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: copy-node INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: find-leaf-node NODE KEY

Find the proper leaf node for the given key.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: find-node NODE KEY

Get the next node using the given key in the given node.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: find-record NODE KEY

Get the record with the given key in the given node, nil if none.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: make-bplustree &key (ROOT ROOT) (DEPTH DEPTH) (ORDER ORDER) (KEY KEY) (COMPARER COMPARER) (CACHE CACHE)
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: make-node &key (KIND KIND) (ORDER ORDER) (SIZE SIZE) (KEYS KEYS) (RECORDS RECORDS) (PREV-NODE PREV-NODE) (NEXT-NODE NEXT-NODE)
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: move-records-left NODE INDEX

Move the keys and records going left to right from given starting point.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: move-records-right NODE INDEX

Move the keys and records from the given starting point to the right.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-internal-p NODE

Is the node an internal node?

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-key NODE I
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-key-record-set NODE N KEY RECORD

Sets both the key and record at the given index to the given B+ node.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-key-set NODE I VALUE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-key-transfer SOURCE DESTINATION I-SOURCE I-DESTINATION &key SET-SOURCE-NIL
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-keys INSTANCE
Function: (setf node-keys) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-kind INSTANCE
Function: (setf node-kind) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-min-size NODE

Returns the minimum size a node can have (except root).

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-next-node INSTANCE
Function: (setf node-next-node) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-num-keys NODE

Get the number of keys based on the node size and node type.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-order INSTANCE
Function: (setf node-order) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-overflow-p NODE

Does the node have more records than it should?

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-p OBJECT
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-prev-node INSTANCE
Function: (setf node-prev-node) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-record NODE I
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-record-set NODE I VALUE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-record-transfer SOURCE DESTINATION I-SOURCE I-DESTINATION &key SET-SOURCE-NIL
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-records INSTANCE
Function: (setf node-records) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-size INSTANCE
Function: (setf node-size) VALUE INSTANCE
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: node-underflow-p NODE

Does the node have less records than it should?

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: promote-first-key NODE &key NO-SHIFT

Promotes the first key in the node, if its a leaf it simply returns it, if its an internal node it returns it but shifts the other keys to the left.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Function: search-node-keys NODE KEY &key RECORD-SEARCH

Search the given node keys vector using binary search.
Keys assumed to be sorted. Optional mix and max define the search space. The keyword record-search indicates if you are looking for a record or a node.

Package

org.ebobby.bplustree

Source

bplustree.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Structures

Structure: bplustree ()
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: root
Readers

bplustree-root (function)

Writers

(setf bplustree-root) (function)

Slot: depth
Readers

bplustree-depth (function)

Writers

(setf bplustree-depth) (function)

Slot: order
Readers

bplustree-order (function)

Writers

(setf bplustree-order) (function)

Slot: key
Readers

bplustree-key (function)

Writers

(setf bplustree-key) (function)

Slot: comparer
Readers

bplustree-comparer (function)

Writers

(setf bplustree-comparer) (function)

Slot: cache
Readers

bplustree-cache (function)

Writers

(setf bplustree-cache) (function)

Structure: node ()
Package

org.ebobby.bplustree

Source

bplustree.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: kind
Readers

node-kind (function)

Writers

(setf node-kind) (function)

Slot: order
Readers

node-order (function)

Writers

(setf node-order) (function)

Slot: size
Readers

node-size (function)

Writers

(setf node-size) (function)

Slot: keys
Readers

node-keys (function)

Writers

(setf node-keys) (function)

Slot: records
Readers

node-records (function)

Writers

(setf node-records) (function)

Slot: prev-node
Readers

node-prev-node (function)

Writers

(setf node-prev-node) (function)

Slot: next-node
Readers

node-next-node (function)

Writers

(setf node-next-node) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-bplustree.asd: The cl-bplustree<dot>asd file
cl-bplustree/bplustree.lisp: The cl-bplustree/bplustree<dot>lisp file
cl-bplustree/packages.lisp: The cl-bplustree/packages<dot>lisp file

F
File, Lisp, cl-bplustree.asd: The cl-bplustree<dot>asd file
File, Lisp, cl-bplustree/bplustree.lisp: The cl-bplustree/bplustree<dot>lisp file
File, Lisp, cl-bplustree/packages.lisp: The cl-bplustree/packages<dot>lisp file

L
Lisp File, cl-bplustree.asd: The cl-bplustree<dot>asd file
Lisp File, cl-bplustree/bplustree.lisp: The cl-bplustree/bplustree<dot>lisp file
Lisp File, cl-bplustree/packages.lisp: The cl-bplustree/packages<dot>lisp file

Jump to:   C   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
B   C   F   M   N   P   S   W  
Index Entry  Section

(
(setf bplustree-cache): Internal functions
(setf bplustree-comparer): Internal functions
(setf bplustree-depth): Internal functions
(setf bplustree-key): Internal functions
(setf bplustree-order): Internal functions
(setf bplustree-root): Internal functions
(setf node-keys): Internal functions
(setf node-kind): Internal functions
(setf node-next-node): Internal functions
(setf node-order): Internal functions
(setf node-prev-node): Internal functions
(setf node-records): Internal functions
(setf node-size): Internal functions

B
bplustree-cache: Internal functions
bplustree-comparer: Internal functions
bplustree-delete: Exported functions
bplustree-depth: Internal functions
bplustree-empty-p: Exported functions
bplustree-insert: Exported functions
bplustree-insert-many: Exported functions
bplustree-key: Internal functions
bplustree-new: Exported functions
bplustree-order: Internal functions
bplustree-p: Internal functions
bplustree-root: Internal functions
bplustree-search: Exported functions
bplustree-search-next: Exported functions
bplustree-search-prev: Exported functions
bplustree-search-range: Exported functions
bplustree-traverse: Exported functions
bplustree-traverse-node: Internal functions
bplustree-traverse-node-with-keys: Internal functions
bplustree-traverse-with-keys: Exported functions
build-node: Internal functions
build-node-collection-accesors: Internal macros
build-node-collection-transfer: Internal macros

C
copy-bplustree: Internal functions
copy-node: Internal functions

F
find-leaf-node: Internal functions
find-node: Internal functions
find-record: Internal functions
Function, (setf bplustree-cache): Internal functions
Function, (setf bplustree-comparer): Internal functions
Function, (setf bplustree-depth): Internal functions
Function, (setf bplustree-key): Internal functions
Function, (setf bplustree-order): Internal functions
Function, (setf bplustree-root): Internal functions
Function, (setf node-keys): Internal functions
Function, (setf node-kind): Internal functions
Function, (setf node-next-node): Internal functions
Function, (setf node-order): Internal functions
Function, (setf node-prev-node): Internal functions
Function, (setf node-records): Internal functions
Function, (setf node-size): Internal functions
Function, bplustree-cache: Internal functions
Function, bplustree-comparer: Internal functions
Function, bplustree-delete: Exported functions
Function, bplustree-depth: Internal functions
Function, bplustree-empty-p: Exported functions
Function, bplustree-insert: Exported functions
Function, bplustree-insert-many: Exported functions
Function, bplustree-key: Internal functions
Function, bplustree-new: Exported functions
Function, bplustree-order: Internal functions
Function, bplustree-p: Internal functions
Function, bplustree-root: Internal functions
Function, bplustree-search: Exported functions
Function, bplustree-search-next: Exported functions
Function, bplustree-search-prev: Exported functions
Function, bplustree-search-range: Exported functions
Function, bplustree-traverse: Exported functions
Function, bplustree-traverse-node: Internal functions
Function, bplustree-traverse-node-with-keys: Internal functions
Function, bplustree-traverse-with-keys: Exported functions
Function, build-node: Internal functions
Function, copy-bplustree: Internal functions
Function, copy-node: Internal functions
Function, find-leaf-node: Internal functions
Function, find-node: Internal functions
Function, find-record: Internal functions
Function, make-bplustree: Internal functions
Function, make-node: Internal functions
Function, move-records-left: Internal functions
Function, move-records-right: Internal functions
Function, node-internal-p: Internal functions
Function, node-key: Internal functions
Function, node-key-record-set: Internal functions
Function, node-key-set: Internal functions
Function, node-key-transfer: Internal functions
Function, node-keys: Internal functions
Function, node-kind: Internal functions
Function, node-min-size: Internal functions
Function, node-next-node: Internal functions
Function, node-num-keys: Internal functions
Function, node-order: Internal functions
Function, node-overflow-p: Internal functions
Function, node-p: Internal functions
Function, node-prev-node: Internal functions
Function, node-record: Internal functions
Function, node-record-set: Internal functions
Function, node-record-transfer: Internal functions
Function, node-records: Internal functions
Function, node-size: Internal functions
Function, node-underflow-p: Internal functions
Function, promote-first-key: Internal functions
Function, search-node-keys: Internal functions

M
Macro, build-node-collection-accesors: Internal macros
Macro, build-node-collection-transfer: Internal macros
Macro, with-comparer-function: Internal macros
make-bplustree: Internal functions
make-node: Internal functions
move-records-left: Internal functions
move-records-right: Internal functions

N
node-internal-p: Internal functions
node-key: Internal functions
node-key-record-set: Internal functions
node-key-set: Internal functions
node-key-transfer: Internal functions
node-keys: Internal functions
node-kind: Internal functions
node-min-size: Internal functions
node-next-node: Internal functions
node-num-keys: Internal functions
node-order: Internal functions
node-overflow-p: Internal functions
node-p: Internal functions
node-prev-node: Internal functions
node-record: Internal functions
node-record-set: Internal functions
node-record-transfer: Internal functions
node-records: Internal functions
node-size: Internal functions
node-underflow-p: Internal functions

P
promote-first-key: Internal functions

S
search-node-keys: Internal functions

W
with-comparer-function: Internal macros

Jump to:   (  
B   C   F   M   N   P   S   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   C   D   K   N   O   P   R   S  
Index Entry  Section

C
cache: Internal structures
comparer: Internal structures

D
depth: Internal structures

K
key: Internal structures
keys: Internal structures
kind: Internal structures

N
next-node: Internal structures

O
order: Internal structures
order: Internal structures

P
prev-node: Internal structures

R
records: Internal structures
root: Internal structures

S
size: Internal structures
Slot, cache: Internal structures
Slot, comparer: Internal structures
Slot, depth: Internal structures
Slot, key: Internal structures
Slot, keys: Internal structures
Slot, kind: Internal structures
Slot, next-node: Internal structures
Slot, order: Internal structures
Slot, order: Internal structures
Slot, prev-node: Internal structures
Slot, records: Internal structures
Slot, root: Internal structures
Slot, size: Internal structures

Jump to:   C   D   K   N   O   P   R   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   N   O   P   S  
Index Entry  Section

B
bplustree: Internal structures

C
cl-bplustree: The cl-bplustree system

N
node: Internal structures

O
org.ebobby.bplustree: The org<dot>ebobby<dot>bplustree package

P
Package, org.ebobby.bplustree: The org<dot>ebobby<dot>bplustree package

S
Structure, bplustree: Internal structures
Structure, node: Internal structures
System, cl-bplustree: The cl-bplustree system

Jump to:   B   C   N   O   P   S