The whirlog Reference Manual

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

The whirlog Reference Manual

This is the whirlog Reference Manual, version 2, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 06:31:41 2022 GMT+0.

Table of Contents


1 Introduction

Lisp Mascot Whirlog

Liberapay

Introduction

Whirlog is a minimal versioned log structured relational DB implemented in Common Lisp.

  (let-tables ((tbl (key :key? t) val))
    (with-db ("/tmp/db/" (tbl))
	(let ((rec (new-record 'key "foo" 'val "bar")))
	  (do-context ()
	    (store-record tbl rec)
            (assert (string= (column-value (find-record tbl #("foo")) 'val) "bar")))
	  
	  (do-context ()
            (let ((rec (set-column-values rec 'val "baz")))
              (store-record tbl rec))

            (assert (string= (column-value (find-record tbl #("foo")) 'val) "baz"))))
	  
	  (do-context ()
	    (delete-record tbl #("foo"))
	    (assert (null (find-record tbl #("foo")))))))

You may find a more real worldish example here.

Databases

Databases are implemented as directories containing one file per table. with-db may be used to indicate a root path and open/close specified tables.

Contexts

Contexts are independent atomic transactions. Changes are committed on success and rolled back on error by default, but the behavior may be customized by manually calling commit-changes and/or rollback-changes as needed.

Tables

Tables are implemented as persistent, ordered trees of lazy loaded records. Each table has a set of columns and a key.

Columns

Columns may be typed or untyped (default), untyped columns compare their values using sort:compare.

  (let-tables ((foos (id :key? t)
                     (parent :type record :table t :nil? t)
		     ...))
    ...)
nil?

Columns don't allow nil values in stored records by default, the behavior may be overridden by passing :nil? t on definition. Attempting to store a nil value in a column defined without ':nil? t' results in nil-not-allowed being signalled.

lset-column

lset columns encode sets as lists and decode back to sets again, sets are compared by value.

record-column

Record columns encode records as keys (vectors) which are compared by value.

Records

Records are implemented as immutable lists of pairs (or alists); and written as is to disk. This means that any readable/writeable value will do as field value, and that log files are human readable as well as trivial to process.

#("foo")((WHIRLOG::VAL . "bar"))
#("foo")((WHIRLOG::VAL . "baz"))
#("foo"):D
Keys

Record keys are implemented as vectors and compared by value.

Versioning

Each logged version of a record (as identified by its key) is available on demand.

Threads

Threaded table access has to be protected either by enclosing in do-sync or passing :sync? t (which is the default) where appropriate. Calls that require exclusive table access will eventually fail with an error unless they're able to acquire a table specific spinlock implemented using SBCL atomics.


2 Systems

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


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

2.1 whirlog

a minimal versioned log structured relational DB

Maintainer

codr7

Author

codr7

License

MIT

Version

2

Source

whirlog.asd.

Child Components

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   [Contents][Index]

3.1.1 whirlog/whirlog.asd

Source

whirlog.asd.

Parent Component

whirlog (system).

ASDF Systems

whirlog.


3.1.2 whirlog/util.lisp

Source

whirlog.asd.

Parent Component

whirlog (system).

Packages

util.

Public Interface

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

3.1.3 whirlog/sort.lisp

Dependency

util.lisp (file).

Source

whirlog.asd.

Parent Component

whirlog (system).

Packages

sort.

Public Interface

3.1.4 whirlog/rb.lisp

Dependency

sort.lisp (file).

Source

whirlog.asd.

Parent Component

whirlog (system).

Packages

rb.

Public Interface
Internals

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

3.1.5 whirlog/whirlog.lisp

Dependency

rb.lisp (file).

Source

whirlog.asd.

Parent Component

whirlog (system).

Packages

whirlog.

Public Interface
Internals

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

3.1.6 whirlog/lset.lisp

Dependency

whirlog.lisp (file).

Source

whirlog.asd.

Parent Component

whirlog (system).

Packages

lset.

Public Interface
Internals

4 Packages

Packages are listed by definition order.


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

4.1 sort

Source

sort.lisp.

Use List

common-lisp.

Public Interface

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

4.2 lset

Source

lset.lisp.

Use List

common-lisp.

Public Interface
Internals

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

4.3 whirlog

Source

whirlog.lisp.

Use List

common-lisp.

Public Interface
Internals

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

4.4 rb

Source

rb.lisp.

Use List

common-lisp.

Public Interface
Internals

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

4.5 util

Source

util.lisp.

Use List

common-lisp.

Public Interface

5 Definitions

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


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

5.1 Public Interface


5.1.1 Macros

Macro: do-context (() &body body)
Package

whirlog.

Source

whirlog.lisp.

Macro: do-records ((rec tbl &key start) &body body)
Package

whirlog.

Source

whirlog.lisp.

Macro: do-sync ((tbl &optional slots) &body body)
Package

whirlog.

Source

whirlog.lisp.

Macro: do-tree ((key val root) &body body)
Package

rb.

Source

rb.lisp.

Macro: dohash ((k v tbl) &body body)
Package

util.

Source

util.lisp.

Macro: let-kw ((rem &rest keys) &body body)
Package

util.

Source

util.lisp.

Macro: let-tables ((&rest tables) &body body)
Package

whirlog.

Source

whirlog.lisp.

Macro: let-when (var form &body body)
Package

util.

Source

util.lisp.

Macro: nor (&rest args)
Package

util.

Source

util.lisp.

Macro: while (cnd &body body)
Package

util.

Source

util.lisp.

Macro: with-db ((path (&rest tbls) &key lazy?) &body body)
Package

whirlog.

Source

whirlog.lisp.


5.1.2 Ordinary functions

Function: add (set val)
Package

lset.

Source

lset.lisp.

Function: benchmarks ()
Package

rb.

Source

rb.lisp.

Function: clear (set)
Package

lset.

Source

lset.lisp.

Function: clear (root)
Package

rb.

Source

rb.lisp.

Function: close-table (tbl)

Closes and unbinds TBL’s file

Package

whirlog.

Source

whirlog.lisp.

Function: column-count (tbl)

Returns number of columns in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: column-value (rec col)

Returns value for COL in REC

Package

whirlog.

Source

whirlog.lisp.

Function: (setf column-value) (rec col)

Sets value for COL in REC to VAL

Package

whirlog.

Source

whirlog.lisp.

Function: commit (&key retries)

Commits changes in current context

Package

whirlog.

Source

whirlog.lisp.

Function: committed-record (tbl key &key version sync?)
Package

whirlog.

Source

whirlog.lisp.

Function: (setf committed-record) (tbl key &key version sync?)
Package

whirlog.

Source

whirlog.lisp.

Function: compare-key (tbl x y)
Package

whirlog.

Source

whirlog.lisp.

Function: compare-record (tbl xs ys)
Package

whirlog.

Source

whirlog.lisp.

Function: decode-record (tbl key in)
Package

whirlog.

Source

whirlog.lisp.

Function: delete-record (tbl key &key sync?)

Deletes REC from TBL

Package

whirlog.

Source

whirlog.lisp.

Function: encode-key (tbl in)
Package

whirlog.

Source

whirlog.lisp.

Function: encode-record (tbl in)
Package

whirlog.

Source

whirlog.lisp.

Function: find-node (root key)
Package

rb.

Source

rb.lisp.

Function: find-record (tbl key &key version sync?)
Package

whirlog.

Source

whirlog.lisp.

Function: get-kw (kw lst)
Package

util.

Source

util.lisp.

Function: get-node (root key)
Package

rb.

Source

rb.lisp.

Function: (setf get-node) (root key)
Package

rb.

Source

rb.lisp.

Function: init-record (tbl rec)
Package

whirlog.

Source

whirlog.lisp.

Function: kw (&rest args)
Package

util.

Source

util.lisp.

Function: new (&rest args)
Package

lset.

Source

lset.lisp.

Function: new-column (name &rest opts)

Returns new columns for NAME and OPTS

Package

whirlog.

Source

whirlog.lisp.

Function: new-context ()

Returns a fresh context

Package

whirlog.

Source

whirlog.lisp.

Function: new-root (&key compare key)
Package

rb.

Source

rb.lisp.

Function: new-table (name &rest cols)

Returns new table with NAME and COLS

Package

whirlog.

Source

whirlog.lisp.

Function: node-count (root)
Package

rb.

Source

rb.lisp.

Function: open-table (tbl &key lazy?)

Opens and assigns TBL’s file

Package

whirlog.

Source

whirlog.lisp.

Function: read-records (tbl in &key lazy? sync?)

Reads records from IN into TBL

Package

whirlog.

Source

whirlog.lisp.

Function: record-count (tbl)

Returns number of records in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: remove-node (root key)
Package

rb.

Source

rb.lisp.

Function: rollback-changes ()

Rolls back changes in current context

Package

whirlog.

Source

whirlog.lisp.

Reader: root-node (instance)
Writer: (setf root-node) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

node.

Function: set-node (val root &key key)
Package

rb.

Source

rb.lisp.

Function: sethash (key tbl val)
Package

util.

Source

util.lisp.

Function: size (set)
Package

lset.

Source

lset.lisp.

Function: store-record (tbl rec)

Stores REC in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: sym (&rest args)
Package

util.

Source

util.lisp.

Function: table-records (tbl key &key sync?)

Returns stack of records for KEY in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: (setf table-records) (tbl key &key sync?)

Sets stack of records for KEY in TBL to VAL

Package

whirlog.

Source

whirlog.lisp.

Function: tests ()
Package

lset.

Source

lset.lisp.

Function: tests ()
Package

whirlog.

Source

whirlog.lisp.

Function: tests ()
Package

rb.

Source

rb.lisp.


5.1.3 Generic functions

Generic Reader: column (condition)
Package

whirlog.

Methods
Reader Method: column ((condition nil-not-allowed))
Source

whirlog.lisp.

Target Slot

column.

Generic Reader: columns (object)
Package

whirlog.

Methods
Reader Method: columns ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

columns.

Generic Function: compare (x y)
Package

sort.

Methods
Method: compare ((x vector) y)
Source

sort.lisp.

Method: compare ((x symbol) y)
Source

sort.lisp.

Method: compare ((x string) y)
Source

sort.lisp.

Method: compare ((x number) y)
Source

sort.lisp.

Method: compare ((x list) y)
Source

sort.lisp.

Generic Function: compare-column (col x y)
Package

whirlog.

Methods
Method: compare-column ((col lset-column) xs ys)
Source

lset.lisp.

Method: compare-column ((col column) x y)
Source

whirlog.lisp.

Method: compare-column ((col record-column) x y)
Source

whirlog.lisp.

Generic Function: create-column (tbl col)
Package

whirlog.

Methods
Method: create-column (tbl (col lset-column))
Source

lset.lisp.

Method: create-column (tbl (col record-column))
Source

whirlog.lisp.

Method: create-column (tbl (col column))
Source

whirlog.lisp.

Generic Function: decode-column (col val)
Package

whirlog.

Methods
Method: decode-column ((col lset-column) vals)
Source

lset.lisp.

Method: decode-column ((col column) val)
Source

whirlog.lisp.

Generic Function: encode-column (col val)
Package

whirlog.

Methods
Method: encode-column ((col lset-column) (set lset))
Source

lset.lisp.

Method: encode-column ((col record-column) (val list))
Source

whirlog.lisp.

Method: encode-column ((col column) val)
Source

whirlog.lisp.

Generic Reader: file (object)
Package

whirlog.

Methods
Reader Method: file ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

file.

Generic Function: init-column (col rec)
Package

whirlog.

Methods
Method: init-column ((col lset-column) rec)
Source

lset.lisp.

Method: init-column ((col column) rec)
Source

whirlog.lisp.

Generic Reader: key (object)
Package

whirlog.

Methods
Reader Method: key ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

key.

Generic Reader: key? (object)
Package

whirlog.

Methods
Reader Method: key? ((column column))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

key?.

Generic Reader: name (object)
Package

whirlog.

Methods
Reader Method: name ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

name.

Reader Method: name ((column column))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

name.

Generic Reader: records (object)
Package

whirlog.

Methods
Reader Method: records ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

records.

Generic Reader: table (condition)
Package

whirlog.

Methods
Reader Method: table ((record-column record-column))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

table.

Reader Method: table ((condition nil-not-allowed))
Source

whirlog.lisp.

Target Slot

table.


5.1.4 Conditions

Condition: db-error
Package

whirlog.

Source

whirlog.lisp.

Direct superclasses

error.

Direct subclasses

nil-not-allowed.

Condition: nil-not-allowed
Package

whirlog.

Source

whirlog.lisp.

Direct superclasses

db-error.

Direct methods
Direct slots
Slot: table
Initargs

:table

Readers

table.

Writers

This slot is read-only.

Slot: column
Initargs

:column

Readers

column.

Writers

This slot is read-only.

Slot: record
Initargs

:record

Readers

record.

Writers

This slot is read-only.


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.5 Structures

Structure: lset
Package

lset.

Source

lset.lisp.

Direct superclasses

structure-object.

Direct methods

encode-column.

Direct slots
Slot: compare
Package

sort.

Type

function

Initform

(function sort:compare)

Readers

lset-compare.

Writers

(setf lset-compare).

Slot: items
Type

list

Readers

lset-items.

Writers

(setf lset-items).

Slot: size
Type

integer

Initform

0

Readers

lset-size.

Writers

(setf lset-size).

Structure: root
Package

rb.

Source

rb.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: compare
Package

sort.

Type

function

Readers

root-compare.

Writers

(setf root-compare).

Slot: key
Type

function

Readers

root-key.

Writers

(setf root-key).

Slot: node
Type

(or rb::node null)

Readers

root-node.

Writers

(setf root-node).

Slot: size
Type

fixnum

Initform

0

Readers

root-size.

Writers

(setf root-size).


Previous: , Up: Public Interface   [Contents][Index]

5.1.6 Classes

Class: column
Package

whirlog.

Source

whirlog.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: nil?
Initargs

:nil?

Readers

nil?.

Writers

This slot is read-only.

Slot: key?
Initargs

:key?

Readers

key?.

Writers

This slot is read-only.

Class: lset-column
Package

lset.

Source

lset.lisp.

Direct superclasses

column.

Direct methods
Direct slots
Slot: item-column
Initargs

:item-column

Readers

item-column.

Writers

This slot is read-only.

Class: record-column
Package

whirlog.

Source

whirlog.lisp.

Direct superclasses

column.

Direct methods
Direct slots
Slot: table
Initform

(error "missing table")

Initargs

:table

Readers

table.

Writers

This slot is read-only.

Class: table
Package

whirlog.

Source

whirlog.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: busy?
Readers

busy?.

Writers

This slot is read-only.

Slot: key
Initargs

:key

Readers

key.

Writers

This slot is read-only.

Slot: columns
Initargs

:columns

Readers

columns.

Writers

This slot is read-only.

Slot: file
Initargs

:file

Readers

file.

Writers

This slot is read-only.

Slot: records
Readers

records.

Writers

This slot is read-only.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *context*
Package

whirlog.

Source

whirlog.lisp.

Special Variable: *delete*
Package

whirlog.

Source

whirlog.lisp.

Special Variable: *eof*
Package

whirlog.

Source

whirlog.lisp.

Special Variable: *path*
Package

whirlog.

Source

whirlog.lisp.


5.2.2 Macros

Macro: if-changed ((tbl key var) x y)
Package

whirlog.

Source

whirlog.lisp.

Macro: movef-red-left (node)
Package

rb.

Source

rb.lisp.

Macro: rotlf (node)
Package

rb.

Source

rb.lisp.

Macro: rotrf (node)
Package

rb.

Source

rb.lisp.

Macro: with-test-db ((&rest tables) &body body)
Package

whirlog.

Source

whirlog.lisp.


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

5.2.3 Ordinary functions

Function: ccompare (root x y)
Package

rb.

Source

rb.lisp.

Function: ckey (root value)
Package

rb.

Source

rb.lisp.

Function: clone-record (tbl rec)
Package

whirlog.

Source

whirlog.lisp.

Function: committed-tests ()
Package

whirlog.

Source

whirlog.lisp.

Function: copy-lset (instance)
Package

lset.

Source

lset.lisp.

Function: copy-node (instance)
Package

rb.

Source

rb.lisp.

Function: copy-root (instance)
Package

rb.

Source

rb.lisp.

Function: delete-if-exists (path)
Package

whirlog.

Source

whirlog.lisp.

Function: delete? (rec)

Returns T if REC is a delete

Package

whirlog.

Source

whirlog.lisp.

Function: eof? (x)

Returns T if X is EOF

Package

whirlog.

Source

whirlog.lisp.

Function: find-record-encoded (tbl key &key version sync?)

Returns record for KEY in TBL if found, otherwise NIL

Package

whirlog.

Source

whirlog.lisp.

Function: find-table-record (tbl key &key sync?)

Returns record for KEY in TBL, or NIL if not found

Package

whirlog.

Source

whirlog.lisp.

Function: fix (node)
Package

rb.

Source

rb.lisp.

Function: flip (node)
Package

rb.

Source

rb.lisp.

Function: get-change (tbl key)

Gets change for KEY in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: (setf get-change) (tbl key)

Sets change to REC for KEY in TBL

Package

whirlog.

Source

whirlog.lisp.

Reader: lset-compare (instance)
Writer: (setf lset-compare) (instance)
Package

lset.

Source

lset.lisp.

Target Slot

compare.

Reader: lset-items (instance)
Writer: (setf lset-items) (instance)
Package

lset.

Source

lset.lisp.

Target Slot

items.

Function: lset-p (object)
Package

lset.

Source

lset.lisp.

Reader: lset-size (instance)
Writer: (setf lset-size) (instance)
Package

lset.

Source

lset.lisp.

Target Slot

size.

Function: make-lset (&key compare items size)
Package

lset.

Source

lset.lisp.

Function: make-node (&key key value left right red?)
Package

rb.

Source

rb.lisp.

Function: make-root (&key compare key node size)
Package

rb.

Source

rb.lisp.

Function: move-red-left (node)
Package

rb.

Source

rb.lisp.

Function: new-column-set (col &rest vals)
Package

lset.

Source

lset.lisp.

Function: new-node (key val)
Package

rb.

Source

rb.lisp.

Function: new-record (&rest flds)

Returns new record with FLDS

Package

whirlog.

Source

whirlog.lisp.

Reader: node-key (instance)
Writer: (setf node-key) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

key.

Reader: node-left (instance)
Writer: (setf node-left) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

left.

Function: node-p (object)
Package

rb.

Source

rb.lisp.

Reader: node-red? (instance)
Writer: (setf node-red?) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

red?.

Reader: node-right (instance)
Writer: (setf node-right) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

right.

Reader: node-value (instance)
Writer: (setf node-value) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

value.

Function: read-value (in)

Reads value from IN

Package

whirlog.

Source

whirlog.lisp.

Function: record-key (tbl rec)

Returns key for REC in TBL

Package

whirlog.

Source

whirlog.lisp.

Function: record-tests ()
Package

whirlog.

Source

whirlog.lisp.

Function: red? (node)
Package

rb.

Source

rb.lisp.

Function: reload-tests ()
Package

whirlog.

Source

whirlog.lisp.

Function: remove-min (node)
Package

rb.

Source

rb.lisp.

Reader: root-compare (instance)
Writer: (setf root-compare) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

compare.

Reader: root-key (instance)
Writer: (setf root-key) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

key.

Function: root-p (object)
Package

rb.

Source

rb.lisp.

Reader: root-size (instance)
Writer: (setf root-size) (instance)
Package

rb.

Source

rb.lisp.

Target Slot

size.

Function: rotl (node)
Package

rb.

Source

rb.lisp.

Function: rotr (node)
Package

rb.

Source

rb.lisp.

Function: set-column-values (rec &rest flds)

Returns REC with updated FLDS

Package

whirlog.

Source

whirlog.lisp.

Function: table-tests ()
Package

whirlog.

Source

whirlog.lisp.

Function: test-setup ()
Package

whirlog.

Source

whirlog.lisp.

Function: trim-path (in)
Package

whirlog.

Source

whirlog.lisp.

Function: write-value (out x)

Writes X to OUT

Package

whirlog.

Source

whirlog.lisp.


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

5.2.4 Generic functions

Generic Reader: busy? (object)
Package

whirlog.

Methods
Reader Method: busy? ((table table))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

busy?.

Generic Reader: item-column (object)
Package

lset.

Methods
Reader Method: item-column ((lset-column lset-column))

automatically generated reader method

Source

lset.lisp.

Target Slot

item-column.

Generic Reader: nil? (object)
Package

whirlog.

Methods
Reader Method: nil? ((column column))

automatically generated reader method

Source

whirlog.lisp.

Target Slot

nil?.

Generic Reader: record (condition)
Package

whirlog.

Methods
Reader Method: record ((condition nil-not-allowed))
Source

whirlog.lisp.

Target Slot

record.


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

5.2.5 Structures

Structure: node
Package

rb.

Source

rb.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: key
Readers

node-key.

Writers

(setf node-key).

Slot: value
Readers

node-value.

Writers

(setf node-value).

Slot: left
Type

(or rb::node null)

Readers

node-left.

Writers

(setf node-left).

Slot: right
Type

(or rb::node null)

Readers

node-right.

Writers

(setf node-right).

Slot: red?
Type

boolean

Initform

t

Readers

node-red?.

Writers

(setf node-red?).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   I   K   L   M   N   O   R   S   T   W  
Index Entry  Section

(
(setf column-value): Public ordinary functions
(setf committed-record): Public ordinary functions
(setf get-change): Private ordinary functions
(setf get-node): Public ordinary functions
(setf lset-compare): Private ordinary functions
(setf lset-items): Private ordinary functions
(setf lset-size): Private ordinary functions
(setf node-key): Private ordinary functions
(setf node-left): Private ordinary functions
(setf node-red?): Private ordinary functions
(setf node-right): Private ordinary functions
(setf node-value): Private ordinary functions
(setf root-compare): Private ordinary functions
(setf root-key): Private ordinary functions
(setf root-node): Public ordinary functions
(setf root-size): Private ordinary functions
(setf table-records): Public ordinary functions

A
add: Public ordinary functions

B
benchmarks: Public ordinary functions
busy?: Private generic functions
busy?: Private generic functions

C
ccompare: Private ordinary functions
ckey: Private ordinary functions
clear: Public ordinary functions
clear: Public ordinary functions
clone-record: Private ordinary functions
close-table: Public ordinary functions
column: Public generic functions
column: Public generic functions
column-count: Public ordinary functions
column-value: Public ordinary functions
columns: Public generic functions
columns: Public generic functions
commit: Public ordinary functions
committed-record: Public ordinary functions
committed-tests: Private ordinary functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare-column: Public generic functions
compare-column: Public generic functions
compare-column: Public generic functions
compare-column: Public generic functions
compare-key: Public ordinary functions
compare-record: Public ordinary functions
copy-lset: Private ordinary functions
copy-node: Private ordinary functions
copy-root: Private ordinary functions
create-column: Public generic functions
create-column: Public generic functions
create-column: Public generic functions
create-column: Public generic functions

D
decode-column: Public generic functions
decode-column: Public generic functions
decode-column: Public generic functions
decode-record: Public ordinary functions
delete-if-exists: Private ordinary functions
delete-record: Public ordinary functions
delete?: Private ordinary functions
do-context: Public macros
do-records: Public macros
do-sync: Public macros
do-tree: Public macros
dohash: Public macros

E
encode-column: Public generic functions
encode-column: Public generic functions
encode-column: Public generic functions
encode-column: Public generic functions
encode-key: Public ordinary functions
encode-record: Public ordinary functions
eof?: Private ordinary functions

F
file: Public generic functions
file: Public generic functions
find-node: Public ordinary functions
find-record: Public ordinary functions
find-record-encoded: Private ordinary functions
find-table-record: Private ordinary functions
fix: Private ordinary functions
flip: Private ordinary functions
Function, (setf column-value): Public ordinary functions
Function, (setf committed-record): Public ordinary functions
Function, (setf get-change): Private ordinary functions
Function, (setf get-node): Public ordinary functions
Function, (setf lset-compare): Private ordinary functions
Function, (setf lset-items): Private ordinary functions
Function, (setf lset-size): Private ordinary functions
Function, (setf node-key): Private ordinary functions
Function, (setf node-left): Private ordinary functions
Function, (setf node-red?): Private ordinary functions
Function, (setf node-right): Private ordinary functions
Function, (setf node-value): Private ordinary functions
Function, (setf root-compare): Private ordinary functions
Function, (setf root-key): Private ordinary functions
Function, (setf root-node): Public ordinary functions
Function, (setf root-size): Private ordinary functions
Function, (setf table-records): Public ordinary functions
Function, add: Public ordinary functions
Function, benchmarks: Public ordinary functions
Function, ccompare: Private ordinary functions
Function, ckey: Private ordinary functions
Function, clear: Public ordinary functions
Function, clear: Public ordinary functions
Function, clone-record: Private ordinary functions
Function, close-table: Public ordinary functions
Function, column-count: Public ordinary functions
Function, column-value: Public ordinary functions
Function, commit: Public ordinary functions
Function, committed-record: Public ordinary functions
Function, committed-tests: Private ordinary functions
Function, compare-key: Public ordinary functions
Function, compare-record: Public ordinary functions
Function, copy-lset: Private ordinary functions
Function, copy-node: Private ordinary functions
Function, copy-root: Private ordinary functions
Function, decode-record: Public ordinary functions
Function, delete-if-exists: Private ordinary functions
Function, delete-record: Public ordinary functions
Function, delete?: Private ordinary functions
Function, encode-key: Public ordinary functions
Function, encode-record: Public ordinary functions
Function, eof?: Private ordinary functions
Function, find-node: Public ordinary functions
Function, find-record: Public ordinary functions
Function, find-record-encoded: Private ordinary functions
Function, find-table-record: Private ordinary functions
Function, fix: Private ordinary functions
Function, flip: Private ordinary functions
Function, get-change: Private ordinary functions
Function, get-kw: Public ordinary functions
Function, get-node: Public ordinary functions
Function, init-record: Public ordinary functions
Function, kw: Public ordinary functions
Function, lset-compare: Private ordinary functions
Function, lset-items: Private ordinary functions
Function, lset-p: Private ordinary functions
Function, lset-size: Private ordinary functions
Function, make-lset: Private ordinary functions
Function, make-node: Private ordinary functions
Function, make-root: Private ordinary functions
Function, move-red-left: Private ordinary functions
Function, new: Public ordinary functions
Function, new-column: Public ordinary functions
Function, new-column-set: Private ordinary functions
Function, new-context: Public ordinary functions
Function, new-node: Private ordinary functions
Function, new-record: Private ordinary functions
Function, new-root: Public ordinary functions
Function, new-table: Public ordinary functions
Function, node-count: Public ordinary functions
Function, node-key: Private ordinary functions
Function, node-left: Private ordinary functions
Function, node-p: Private ordinary functions
Function, node-red?: Private ordinary functions
Function, node-right: Private ordinary functions
Function, node-value: Private ordinary functions
Function, open-table: Public ordinary functions
Function, read-records: Public ordinary functions
Function, read-value: Private ordinary functions
Function, record-count: Public ordinary functions
Function, record-key: Private ordinary functions
Function, record-tests: Private ordinary functions
Function, red?: Private ordinary functions
Function, reload-tests: Private ordinary functions
Function, remove-min: Private ordinary functions
Function, remove-node: Public ordinary functions
Function, rollback-changes: Public ordinary functions
Function, root-compare: Private ordinary functions
Function, root-key: Private ordinary functions
Function, root-node: Public ordinary functions
Function, root-p: Private ordinary functions
Function, root-size: Private ordinary functions
Function, rotl: Private ordinary functions
Function, rotr: Private ordinary functions
Function, set-column-values: Private ordinary functions
Function, set-node: Public ordinary functions
Function, sethash: Public ordinary functions
Function, size: Public ordinary functions
Function, store-record: Public ordinary functions
Function, sym: Public ordinary functions
Function, table-records: Public ordinary functions
Function, table-tests: Private ordinary functions
Function, test-setup: Private ordinary functions
Function, tests: Public ordinary functions
Function, tests: Public ordinary functions
Function, tests: Public ordinary functions
Function, trim-path: Private ordinary functions
Function, write-value: Private ordinary functions

G
Generic Function, busy?: Private generic functions
Generic Function, column: Public generic functions
Generic Function, columns: Public generic functions
Generic Function, compare: Public generic functions
Generic Function, compare-column: Public generic functions
Generic Function, create-column: Public generic functions
Generic Function, decode-column: Public generic functions
Generic Function, encode-column: Public generic functions
Generic Function, file: Public generic functions
Generic Function, init-column: Public generic functions
Generic Function, item-column: Private generic functions
Generic Function, key: Public generic functions
Generic Function, key?: Public generic functions
Generic Function, name: Public generic functions
Generic Function, nil?: Private generic functions
Generic Function, record: Private generic functions
Generic Function, records: Public generic functions
Generic Function, table: Public generic functions
get-change: Private ordinary functions
get-kw: Public ordinary functions
get-node: Public ordinary functions

I
if-changed: Private macros
init-column: Public generic functions
init-column: Public generic functions
init-column: Public generic functions
init-record: Public ordinary functions
item-column: Private generic functions
item-column: Private generic functions

K
key: Public generic functions
key: Public generic functions
key?: Public generic functions
key?: Public generic functions
kw: Public ordinary functions

L
let-kw: Public macros
let-tables: Public macros
let-when: Public macros
lset-compare: Private ordinary functions
lset-items: Private ordinary functions
lset-p: Private ordinary functions
lset-size: Private ordinary functions

M
Macro, do-context: Public macros
Macro, do-records: Public macros
Macro, do-sync: Public macros
Macro, do-tree: Public macros
Macro, dohash: Public macros
Macro, if-changed: Private macros
Macro, let-kw: Public macros
Macro, let-tables: Public macros
Macro, let-when: Public macros
Macro, movef-red-left: Private macros
Macro, nor: Public macros
Macro, rotlf: Private macros
Macro, rotrf: Private macros
Macro, while: Public macros
Macro, with-db: Public macros
Macro, with-test-db: Private macros
make-lset: Private ordinary functions
make-node: Private ordinary functions
make-root: Private ordinary functions
Method, busy?: Private generic functions
Method, column: Public generic functions
Method, columns: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare-column: Public generic functions
Method, compare-column: Public generic functions
Method, compare-column: Public generic functions
Method, create-column: Public generic functions
Method, create-column: Public generic functions
Method, create-column: Public generic functions
Method, decode-column: Public generic functions
Method, decode-column: Public generic functions
Method, encode-column: Public generic functions
Method, encode-column: Public generic functions
Method, encode-column: Public generic functions
Method, file: Public generic functions
Method, init-column: Public generic functions
Method, init-column: Public generic functions
Method, item-column: Private generic functions
Method, key: Public generic functions
Method, key?: Public generic functions
Method, name: Public generic functions
Method, name: Public generic functions
Method, nil?: Private generic functions
Method, record: Private generic functions
Method, records: Public generic functions
Method, table: Public generic functions
Method, table: Public generic functions
move-red-left: Private ordinary functions
movef-red-left: Private macros

N
name: Public generic functions
name: Public generic functions
name: Public generic functions
new: Public ordinary functions
new-column: Public ordinary functions
new-column-set: Private ordinary functions
new-context: Public ordinary functions
new-node: Private ordinary functions
new-record: Private ordinary functions
new-root: Public ordinary functions
new-table: Public ordinary functions
nil?: Private generic functions
nil?: Private generic functions
node-count: Public ordinary functions
node-key: Private ordinary functions
node-left: Private ordinary functions
node-p: Private ordinary functions
node-red?: Private ordinary functions
node-right: Private ordinary functions
node-value: Private ordinary functions
nor: Public macros

O
open-table: Public ordinary functions

R
read-records: Public ordinary functions
read-value: Private ordinary functions
record: Private generic functions
record: Private generic functions
record-count: Public ordinary functions
record-key: Private ordinary functions
record-tests: Private ordinary functions
records: Public generic functions
records: Public generic functions
red?: Private ordinary functions
reload-tests: Private ordinary functions
remove-min: Private ordinary functions
remove-node: Public ordinary functions
rollback-changes: Public ordinary functions
root-compare: Private ordinary functions
root-key: Private ordinary functions
root-node: Public ordinary functions
root-p: Private ordinary functions
root-size: Private ordinary functions
rotl: Private ordinary functions
rotlf: Private macros
rotr: Private ordinary functions
rotrf: Private macros

S
set-column-values: Private ordinary functions
set-node: Public ordinary functions
sethash: Public ordinary functions
size: Public ordinary functions
store-record: Public ordinary functions
sym: Public ordinary functions

T
table: Public generic functions
table: Public generic functions
table: Public generic functions
table-records: Public ordinary functions
table-tests: Private ordinary functions
test-setup: Private ordinary functions
tests: Public ordinary functions
tests: Public ordinary functions
tests: Public ordinary functions
trim-path: Private ordinary functions

W
while: Public macros
with-db: Public macros
with-test-db: Private macros
write-value: Private ordinary functions

Jump to:   (  
A   B   C   D   E   F   G   I   K   L   M   N   O   R   S   T   W  

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

A.3 Variables

Jump to:   *  
B   C   F   I   K   L   N   R   S   T   V  
Index Entry  Section

*
*context*: Private special variables
*delete*: Private special variables
*eof*: Private special variables
*path*: Private special variables

B
busy?: Public classes

C
column: Public conditions
columns: Public classes
compare: Public structures
compare: Public structures

F
file: Public classes

I
item-column: Public classes
items: Public structures

K
key: Public structures
key: Public classes
key: Private structures
key?: Public classes

L
left: Private structures

N
name: Public classes
name: Public classes
nil?: Public classes
node: Public structures

R
record: Public conditions
records: Public classes
red?: Private structures
right: Private structures

S
size: Public structures
size: Public structures
Slot, busy?: Public classes
Slot, column: Public conditions
Slot, columns: Public classes
Slot, compare: Public structures
Slot, compare: Public structures
Slot, file: Public classes
Slot, item-column: Public classes
Slot, items: Public structures
Slot, key: Public structures
Slot, key: Public classes
Slot, key: Private structures
Slot, key?: Public classes
Slot, left: Private structures
Slot, name: Public classes
Slot, name: Public classes
Slot, nil?: Public classes
Slot, node: Public structures
Slot, record: Public conditions
Slot, records: Public classes
Slot, red?: Private structures
Slot, right: Private structures
Slot, size: Public structures
Slot, size: Public structures
Slot, table: Public conditions
Slot, table: Public classes
Slot, value: Private structures
Special Variable, *context*: Private special variables
Special Variable, *delete*: Private special variables
Special Variable, *eof*: Private special variables
Special Variable, *path*: Private special variables

T
table: Public conditions
table: Public classes

V
value: Private structures

Jump to:   *  
B   C   F   I   K   L   N   R   S   T   V  

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

A.4 Data types

Jump to:   C   D   F   L   N   P   R   S   T   U   W  
Index Entry  Section

C
Class, column: Public classes
Class, lset-column: Public classes
Class, record-column: Public classes
Class, table: Public classes
column: Public classes
Condition, db-error: Public conditions
Condition, nil-not-allowed: Public conditions

D
db-error: Public conditions

F
File, lset.lisp: The whirlog/lset․lisp file
File, rb.lisp: The whirlog/rb․lisp file
File, sort.lisp: The whirlog/sort․lisp file
File, util.lisp: The whirlog/util․lisp file
File, whirlog.asd: The whirlog/whirlog․asd file
File, whirlog.lisp: The whirlog/whirlog․lisp file

L
lset: The lset package
lset: Public structures
lset-column: Public classes
lset.lisp: The whirlog/lset․lisp file

N
nil-not-allowed: Public conditions
node: Private structures

P
Package, lset: The lset package
Package, rb: The rb package
Package, sort: The sort package
Package, util: The util package
Package, whirlog: The whirlog package

R
rb: The rb package
rb.lisp: The whirlog/rb․lisp file
record-column: Public classes
root: Public structures

S
sort: The sort package
sort.lisp: The whirlog/sort․lisp file
Structure, lset: Public structures
Structure, node: Private structures
Structure, root: Public structures
System, whirlog: The whirlog system

T
table: Public classes

U
util: The util package
util.lisp: The whirlog/util․lisp file

W
whirlog: The whirlog system
whirlog: The whirlog package
whirlog.asd: The whirlog/whirlog․asd file
whirlog.lisp: The whirlog/whirlog․lisp file

Jump to:   C   D   F   L   N   P   R   S   T   U   W