The cl-rethinkdb Reference Manual

Table of Contents

The cl-rethinkdb Reference Manual

This is the cl-rethinkdb Reference Manual, version 0.6.7, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:21:24 2018 GMT+0.

1 Introduction

cl-rethinkdb - RethinkDB driver for Common Lisp

This is an async RethinkDB driver for everyone's favorite programming language. It does its best to follow the query language specification. If it's missing any functions or has implemented any of them incorrectly, please open an issue.

This driver is up to date with RethinkDB's v2.0.x protocol.

As with most of my drivers, cl-rethinkdb requires cl-async, and makes heavy use of cl-async's promises.

This driver is built so that later on, more than one TCP backend can be used. Right now, the only one implemented is cl-async, but usocket/IOLib could just as easily be used if someone puts in the time.

Documentation

The driver makes extensive use of promises, as mentioned, so be sure to know your way around the promise syntax macros when using it.

Everything needed to use the driver is exported out of the cl-rethinkdb package, which has the nickname r.

DSL

cl-rethinkdb makes use of a query DSL that maps keyword function calls to normal function calls. It does this so that predefined common lisp functions can be used instead of giving them rediculous names to avoid naming clashes.

The DSL is activated by using either the r macro (used to build query forms) or the fn macro (used to build anonymous functions).

Note that this section only covers the DSL itself. Check out the full list of commands to start building the query of your dreams.

r (macro)

This macro translates keyword functions into ReQL function calls:

;; grab first 10 records from the `users` table
(r (:limit (:table "users") 10))

This translates to

(cl-rethinkdb-reql::limit (cl-rethinkdb-reql::table "users") 10)

fn (macro)

This macro creates an anonymous function for use in a RethinkDB query.

It works very much like the r macro, and in fact wraps its inner forms in r so that you can use the query DSL from within a function.

;; return an anonymous function that adds `3` to the given argument
(fn (x) (:+ x 3))

Functions can be mixed in with r queries:

;; find all users older than 24
(r (:filter (:table "users")
            (fn (user)
              (:< 24 (:attr user "age")))))

Note how inside the fn body, we're still using functions prefixed with :.

Sending queries and getting results

Once you've constructed a query via r, you need to send it to the server. When the server responds successfully, you will get either an atom (a single value: integer, boolean, hash, array, etc). or a cursor which provides an interface to iterate over a set of atoms.

connect (function)

(defun connect (host port &key db use-outdated noreply profile read-timeout auth))
  => promise (tcp-socket)

Connects a socket to the given host/port and returns a promise that's finished with the socket.

Usage:

(alet ((sock (connect "127.0.0.1" 28015 :db "test")))
  ;; ... do stuff ...
  (disconnect sock))

run (function)

(defun run (sock query-form))
  => promise (atom/cursor profile-data)

Run a query against the given socket (connected using connect). Returns a promise finished with either the atom the query returns or a cursor to the query results.

If profile is t when calling connect, the second promise value will be the profile data returned with the query.

run can signal the following errors on the promise it returns:

• query-client-error
• query-compile-error
• query-runtime-error

Example

(alet* ((sock (connect "127.0.0.1" 28015))
        (query (r (:get (:table "users") 12)))  ; get user id 12
        (value (run sock query)))
  (format t "My user is: ~s~%" value)
  (disconnect sock))

wait-complete (function)

(defun wait-complete (sock))
  => promise (t)

Waits for all queries sent on this socket with noreply => t to finish. This lets you queue up a number of write operations on a socket. You can then call wait-complete on the socket and it will return the response when all the queued operations finish.

cursor (class)

The cursor class keeps track of queries where a sequence of results is returned (as opposed to an atom). It is generally opaque, having no public accessors.

Cursor functions/methods:

• cursorp
• next
• has-next
• to-sequence
• to-array
• each
• stop
• stop/disconnect

cursorp (function)

(defun cursorp (cursor))
  => t/nil

Convenience function to tell if the given object is a cursor.

next (function)

(defun next (sock cursor))
  => promise (atom)

Gets the next result from a cursor. Returns a promise that's finished with the next result. The result could be stored locally already, but it also may need to be retrieved from the server.

next can signal two errors on the promise it returns:

• cursor-overshot
• cursor-no-more-results

(alet* ((sock (connect "127.0.0.1" 28015))
        (query (r (:table "users")))  ; get all users
        (cursor (run sock query)))
  ;; grab the first result from the cursor.
  (alet ((user (next sock cursor)))
    (format t "first user is: ~s~%" user)
    ;; let's grab another user
    (alet ((user (next sock cursor)))
      (format t "second user is: ~s~%" user)
      ;; let the server/driver know we're done with this result set
      (stop/disconnect sock cursor))))

has-next (function)

(defun has-next (cursor))
  => t/nil

Determines if a cursor has more results available.

to-sequence (function)

(defun to-sequence (sock cursor))
  => promise (sequence)

Given a socket and a cursor, to-sequence grabs ALL the results from the cursor, going out to the server to get more if it has to, and returns them as a sequence through the returned promise. The sequence type (vector/list) depends on the value of *sequence-type*.

to-array (function)

(defun to-array (sock cursor))
  => promise (vector)

Given a socket and a cursor, to-array grabs ALL the results from the cursor, going out to the server to get more if it has to, and returns them as an array through the returned promise.

(alet* ((sock (connect "127.0.0.1" 28015))
        (query (r (:table "users")))  ; get all users
        (cursor (run sock query))
        (all-records (to-array sock cursor)))
  (format t "All users: ~s~%" all-records)
  ;; cleanup
  (stop/disconnect sock cursor))

Don't call to-array on a cursor returned from a changefeed. It will just sit there endlessly saving results to a list it will never return.

each (function)

(defun each (sock cursor function))
  => promise 

Call the given function on each of the results of a cursor. The returned promise is finished when all results have been iterated over.

(alet* ((sock (connect "127.0.0.1" 28015))
        (cursor (run sock (r (:table "users")))))
  ;; print each user
  (wait (each sock cursor
          (lambda (x) (format t "user: ~s~%" x)))
    ;; cleanup
    (wait (stop sock cursor)
      (disconnect sock))))

each is the function you want to use for listening to changes on a cursor that is returned from a changefeed.

stop (function)

(defun stop (sock cursor))
  => promise

Stops a currently open query/cursor. This cleans up the cursor locally, and also lets RethinkDB know that the results for this cursor are no longer needed. Returns a promise that is finished with no values when the operation is complete.

stop/disconnect (function)

(defun stop/disconnect (sock cursor))
  => nil

Calls stop on a cursor, and after the stop operation is done closes the passed socket. Useful as a final termination to an operation that uses a cursor.

Note that this function checks if the object passed is indeed a cursor, and if not, just disconnects the socket without throwing any errors.

disconnect (function)

(defun disconnect (sock))
  => nil

Disconnect a connection to a RethinkDB server.

Binary data

Binary data is now part of the driver. Using it is simple...you pass in an unsigned byte array (ie (simple-erray (unsigned-byte 8) (*))) and the driver will handle encoding of the binary data for you. Binary data passed in must be of the unsigned-byte type, or your data will just be encoded as an array (or whatever type it actually is).

When an object is returned that has binary data, the driver converts it back to an unsigned byte array.

You can also force usage of the binary type by using the (:binary ...) type in the DSL. It takes 1 argument: a base64 string of your data. Note, however, that if you do use (:binary "ZG93biB3aXRoIHRoZSBvcHByZXNzaXZlIGNhcGl0YWxpc3QgcmVnaW1l"), when you pull that document out, the data will be encoded as a raw unsigned-byte array (not a base64 string).

Config

These mainly have to do with how you want data returned.

*sequence-type*

When a sequence is returned from RethinkDB, it can be either returned as a list (if *sequence-type* is :list or as a vector (if *sequence-type* is :array). It's really a matter of preference on how you're going to access the data. (But you may also want to read on-sequence-type for a warning about round tripping rethinkdb documents while using :list).

Default: :list

*object-type*

If an object (as in, key/value object) is returned from RethinkDB, it can be encoded as a hash table (if *object-type* is :hash) or as an association list (if *object-type* is :alist). Hash tables are almost always more performant, but alists can be easier to debug. Your choice.

Default: :hash

Thread safety

cl-rethinkdb stores all its global state in one variable: *state*, which is exported in the cl-rethinkdb package. The *state* variable is an instance of the cl-rethinkdb:state CLOS class. This lets you declare a thread-local variable when starting a thread so there are no collisions when accessing the library from multiple threads:

(let ((cl-rethinkdb:*state* (make-instance 'cl-rethinkdb:state)))
  (as:with-event-loop ()
    ;; run queries in this context
    ))

Using let in the above context declares *state* as a thread local variable, as opposed to using setf, which will just modify the global, shared context. Be sure that the let form happens at the start of the thread and encompasses the event loop form.

Commands

All of the following are accessible via the r DSL macro by prefixing the name with a :. So (table "users") becomes (:table "users").

These are almost 100% compatible with the ReQL specification, so if you familiarize yourself with the query language, you will automatically get a good handle on the following.

For a better understanding of the return types of the following commands, see the REQL type hierarchy in the protobuf specification.

• db (db-name) => database
• db-drop (db-name) => object
• db-list () => object
• table-create (db table-name &key datacenter primary-key durability) => object
• table-drop (db table-name) => object
• table-list (db) => object
• sync (table) => object
• index-create (table name &key function multi) => object
• index-drop (table name) => object
• index-list (table) => array
• index-status (table &rest names) => array
• index-wait (table &rest names) => array
• changes (select &key squash include-states) => cursor
• args (arg-list) => special
• binary (base64-string) => binary
• insert (table sequence/object &key conflict durability return-changes) => object
• update (select object/function &key non-atomic durability return-changes) => object
• replace (select object/function &key non-atomic durability return-changes) => object
• delete (select &key durability return-changes) => object
• db (db-name) => db
• table (db table-name &key read-mode identifier-format) => sequence
• get (table item-id) => object
• get-all (table key/keys &key index) => array
  (key/keys can be either a string type or a list of string types)
• between (sequence left right &key index) => sequence
• minval () => constant
• maxval () => constant
• filter (sequence object/function &key default) => sequence
• inner-join (sequence1 sequence2 function) => sequence
• outer-join (sequence1 sequence2 function) => sequence
• eq-join (sequence1 field sequence2 &key index) => sequence
• zip (sequence) => sequence
• map (sequence function) => sequence
• with-fields (sequence &rest strings) => sequence
• concat-map (sequence function) => sequence
• order-by (sequence field &rest fields) => sequence
• asc (field) => field
• desc (field) => field
• skip (sequence number) => sequence
• limit (sequence number) => sequence
• slice (sequence start end) => sequence
• nth (sequence number) => object
• offsets-of (sequence object/reql-function) => sequence
• is-empty (sequence) => boolean
• union (sequence &rest sequences) => sequence
• sample (sequence count) => sequence
• random (lower &optional upper &key float) => number
• group (sequence fields-or-functions &key index) => grouped_sequence
• ungroup (grouped-sequence) => sequence
• reduce (sequence function) => object
• count (sequence &optional object/reql-function) => number
• sum (sequence &optional field-or-function) => number
• avg (sequence &optional field-or-function) => number
• min (sequence &optional field-or-function) => type-of-object-in-sequence
• max (sequence &optional field-or-function) => type-of-object-in-sequence
• distinct (sequence) => sequence
• contains (sequence object) => boolean
• count-reduce () => function
• sum-reduce (field) => function
• avg-reduce (field) => function
• attr (object field) => object
• row (&optional field) => object
• pluck (sequence/object field &rest fields) => sequence/object
• without (sequence/object field &rest fields) => sequence/object
• merge (object &rest objects) => object
• append (array object) => array
• prepend (array object) => array
• difference (array1 array2) => array
• set-insert (array object) => array
• set-intersection (array1 array2) => array
• set-union (array1 array2) => array
• set-difference (array1 array2) => array
• has-fields (object string &rest strings) => bool
• insert-at (array index object) => array
• splice-at (array1 index array2) => array
• delete-at (array index) => array
• change-at (array index object) => array
• keys (object) => array
• object (key val &rest) => object
• \+ (number/string &rest numbers/strings) => number/string
• \- (number &rest numbers) => number
• \* (number &rest numbers) => number
• / (number &rest numbers) => number
• % (number mod) => number
• && (boolean &rest booleans) => boolean
• || (boolean &rest booleans) => boolean
• == (object &rest objects) => boolean
• != (object &rest objects) => boolean
• < (object &rest objects) => boolean
• <= (object &rest objects) => boolean
• > (object &rest objects) => boolean
• >= (object &rest objects) => boolean
• ~ (boolean) => boolean
• match (string string-regex) => object
• split (string &optional separator max-splits) => array
• upcase (string) => string
• downcase (string) => string
• now () => time
• time (timezone year month day &optional hour minute second) => time
• epoch-time (timestamp) => time
• iso8601 (date &key timezone) => time
• in-timezone (time timezone) => time
• timezone (time) => string
• during (time start end) => boolean
• date (time) => time
• time-of-day (time) => number
• year (time) => number
• month (time) => number
• day (time) => number
• day-of-week (time) => number
• day-of-year (time) => number
• hours (time) => number
• minutes (time) => number
• seconds (time) => number
• to-iso8601 (time) => string
• to-epoch-time (time) => number
• monday () => time
• tuesday () => time
• wednesday () => time
• thursday () => time
• friday () => time
• saturday () => time
• sunday () => time
• january () => time
• february () => time
• march () => time
• april () => time
• may () => time
• june () => time
• july () => time
• august () => time
• september () => time
• october () => time
• november () => time
• december () => time
• do (function &rest args) => object
• branch (boolean true-expr false-expr) => object
• for-each (sequence function) => object
• error (message) => error
• default (top1 top2) => top
• expr (lisp-object) => RethinkDB object
• js (javascript-str) => object/function
• coerce-to (object type) => object
• typeof (object) => type-string
• info (object) => object
• json (string) => object
• to-json-string (object) => string
• literal (&optional object) => object
• geojson (object)) => geometry
• to-geojson (geo)) => object
• point (lat long)) => geometry
• line (&rest array/geo)) => geometry
• polygon (&rest array/geo)) => geometry
• distance (geo-from geo-to &key geo-system unit)) => number
• intersects (geo1 geo2)) => bool
• includes (geo1 geo2)) => bool
• circle (geo radius &key num-vertices geo-system unit fill)) => geometry
• get-intersecting (table geo &key index)) => stream
• fill (geo)) => geometry
• get-nearest (table geo &key index max-results max-dist geo-system unit)) => array
• polygon-sub (geo1 geo2)) => geometry

Errors

These are the errors you may encounter while using this driver. Most (if not all) errors will be signalled on a promise instead of thrown directly. Errors on a promise can be caught via catcher.

query-error

A general query error.

query-client-error

extends query-error

Thrown when the driver sucks. If you get this, open an issue.

query-compile-error

extends query-error

Thrown when a query cannot compile. If you get this, take a close look at your query forms.

query-runtime-error

extends query-error

Thrown when the database has a runtime error.

cursor-error

A general error with a cursor.

cursor-overshot

extends cursor-error

Thrown when next is called on a cursor, but the cursor is currently grabbing more results.

cursor-no-more-results

extends cursor-error

Thrown when next is called on a cursor that has no more results. You can test this by using has-next.

reql-error

A REQL error. This is thrown when there's an error in the returned REQL data from the database. For instance, if a time value comes back without a timestamp or binary data type comes back without the payload. Generally, if the database itself is functioning correctly, you won't see this error.

License

MIT. Enjoy.

2 Systems

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

2.1 cl-rethinkdb

Author

Andrew Danger Lyon <orthecreedence@gmail.com>

License

MIT

Description

A RethinkDB driver for Common Lisp

Version

0.6.7

Dependencies

• blackbird
• vom
• local-time
• event-glue
• cl-async
• fast-io
• jonathan
• cl-base64
• cl-hash-util
• cl-ppcre

Source

cl-rethinkdb.asd (file)

Components

• util.lisp (file)
• package.lisp (file)
• config.lisp (file)
• protocol.lisp (file)
• reql (module)
• connection.lisp (file)
• query.lisp (file)

3 Modules

Modules are listed depth-first from the system components tree.

3.1 cl-rethinkdb/reql

Dependency

config.lisp (file)

Parent

cl-rethinkdb (system)

Location

reql/

Components

• types.lisp (file)
• function.lisp (file)
• commands.lisp (file)
• dsl.lisp (file)
• pseudotypes.lisp (file)

4 Files

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

4.1 Lisp

4.1.1 cl-rethinkdb.asd

Location

cl-rethinkdb.asd

Systems

cl-rethinkdb (system)

4.1.2 cl-rethinkdb/util.lisp

Parent

cl-rethinkdb (system)

Location

util.lisp

Packages

cl-rethinkdb-util

Exported Definitions

• do-hash/alist (macro)
• do-list/vector (macro)
• endian (function)
• jprint (function)
• unendian (function)

4.1.3 cl-rethinkdb/package.lisp

Dependency

util.lisp (file)

Parent

cl-rethinkdb (system)

Location

package.lisp

Packages

• cl-rethinkdb
• cl-rethinkdb-reql

4.1.4 cl-rethinkdb/config.lisp

Dependency

package.lisp (file)

Parent

cl-rethinkdb (system)

Location

config.lisp

Exported Definitions

• *object-type* (special variable)
• *sequence-type* (special variable)

4.1.5 cl-rethinkdb/protocol.lisp

Dependency

package.lisp (file)

Parent

cl-rethinkdb (system)

Location

protocol.lisp

Internal Definitions

• +datum-type-array+ (constant)
• +datum-type-bool+ (constant)
• +datum-type-json+ (constant)
• +datum-type-null+ (constant)
• +datum-type-num+ (constant)
• +datum-type-object+ (constant)
• +datum-type-str+ (constant)
• +proto-json+ (constant)
• +proto-query-continue+ (constant)
• +proto-query-start+ (constant)
• +proto-query-stop+ (constant)
• +proto-query-wait+ (constant)
• +proto-version+ (constant)
• +rdb-response-atom+ (constant)
• +rdb-response-client-error+ (constant)
• +rdb-response-compile-error+ (constant)
• +rdb-response-feed+ (constant)
• +rdb-response-partial+ (constant)
• +rdb-response-runtime-error+ (constant)
• +rdb-response-sequence+ (constant)
• +rdb-response-wait-complete+ (constant)

4.1.6 cl-rethinkdb/reql/types.lisp

Parent

reql (module)

Location

reql/types.lisp

Internal Definitions

• alist (type)
• alistp (function)

4.1.7 cl-rethinkdb/reql/function.lisp

Dependency

types.lisp (file)

Parent

reql (module)

Location

reql/function.lisp

Exported Definitions

fn (macro)

Internal Definitions

• *varnum* (special variable)
• generate-fn-var (function)

4.1.8 cl-rethinkdb/reql/commands.lisp

Dependency

function.lisp (file)

Parent

reql (module)

Location

reql/commands.lisp

Internal Definitions

• (function)
• != (function)
• % (function)
• && (function)
• * (function)
• *commands* (special variable)
• + (function)
• - (function)
• / (function)
• < (function)
• <= (function)
• == (function)
• > (function)
• >= (function)
• append (function)
• april (function)
• args (function)
• asc (function)
• attr (function)
• august (function)
• avg (function)
• between (function)
• between-dep (function)
• binary (function)
• bracket (function)
• branch (function)
• call (function)
• change-at (function)
• changes (function)
• circle (function)
• cmd-arg (function)
• cmd-args (method)
• (setf cmd-args) (method)
• cmd-name (method)
• (setf cmd-name) (method)
• cmd-op (method)
• (setf cmd-op) (method)
• cmd-options (method)
• (setf cmd-options) (method)
• coerce-to (function)
• concat-map (function)
• config (function)
• contains (function)
• count (function)
• date (function)
• day (function)
• day-of-week (function)
• day-of-year (function)
• db (function)
• db-create (function)
• db-drop (function)
• db-list (function)
• december (function)
• default (function)
• defcommand (macro)
• delete (function)
• delete-at (function)
• desc (function)
• difference (function)
• distance (function)
• distinct (function)
• do (function)
• downcase (function)
• during (function)
• epoch-time (function)
• eq-join (function)
• error (function)
• expr (function)
• february (function)
• fill (function)
• filter (function)
• for-each (function)
• friday (function)
• func (function)
• geojson (function)
• get (function)
• get-all (function)
• get-intersecting (function)
• get-nearest (function)
• group (function)
• has-fields (function)
• hours (function)
• http (function)
• in-timezone (function)
• includes (function)
• index-create (function)
• index-drop (function)
• index-list (function)
• index-rename (function)
• index-status (function)
• index-wait (function)
• info (function)
• inner-join (function)
• insert (function)
• insert-at (function)
• intersects (function)
• is-empty (function)
• iso8601 (function)
• january (function)
• javascript (function)
• json (function)
• july (function)
• june (function)
• keys (function)
• limit (function)
• line (function)
• literal (function)
• make-array (function)
• make-obj (function)
• map (function)
• march (function)
• match (function)
• max (function)
• maxval (function)
• may (function)
• merge (function)
• min (function)
• minutes (function)
• minval (function)
• monday (function)
• month (function)
• november (function)
• now (function)
• nth (function)
• object (function)
• october (function)
• offsets-of (function)
• order-by (function)
• outer-join (function)
• pluck (function)
• point (function)
• polygon (function)
• polygon-sub (function)
• prepend (function)
• random (function)
• range (function)
• rebalance (function)
• reconfigure (function)
• reduce (function)
• replace (function)
• reql-cmd (class)
• row (function)
• sample (function)
• saturday (function)
• seconds (function)
• september (function)
• set-difference (function)
• set-insert (function)
• set-intersection (function)
• set-union (function)
• skip (function)
• slice (function)
• splice-at (function)
• split (function)
• status (function)
• sum (function)
• sunday (function)
• sync (function)
• table (function)
• table-create (function)
• table-drop (function)
• table-list (function)
• thursday (function)
• time (function)
• time-of-day (function)
• timezone (function)
• to-epoch-time (function)
• to-geojson (function)
• to-iso8601 (function)
• to-json-string (function)
• tuesday (function)
• type-of (function)
• ungroup (function)
• union (function)
• upcase (function)
• update (function)
• uuid (function)
• var (function)
• wait (function)
• wednesday (function)
• with-fields (function)
• without (function)
• year (function)
• zip (function)
• ~ (function)

4.1.9 cl-rethinkdb/reql/dsl.lisp

Dependency

commands.lisp (file)

Parent

reql (module)

Location

reql/dsl.lisp

Exported Definitions

r (macro)

4.1.10 cl-rethinkdb/reql/pseudotypes.lisp

Dependency

dsl.lisp (file)

Parent

reql (module)

Location

reql/pseudotypes.lisp

Exported Definitions

• convert-pseudotypes-recursive (function)
• reql-error (condition)

Internal Definitions

• convert-pseudotypes (function)
• reql-error-msg (method)

4.1.11 cl-rethinkdb/connection.lisp

Dependencies

• reql (module)
• config.lisp (file)

Parent

cl-rethinkdb (system)

Location

connection.lisp

Internal Definitions

• *empty* (special variable)
• connect-error (condition)
• connect-error-msg (method)
• do-close (function)
• do-connect (function)
• finalize-connect (function)
• finalize-query (function)
• set-callbacks (function)
• sock-write (function)
• socket-data (macro)

4.1.12 cl-rethinkdb/query.lisp

Dependencies

• reql (module)
• protocol.lisp (file)
• config.lisp (file)
• connection.lisp (file)

Parent

cl-rethinkdb (system)

Location

query.lisp

Exported Definitions

• *state* (special variable)
• connect (function)
• cursor (class)
• cursor-error (condition)
• cursor-no-more-results (condition)
• cursor-overshot (condition)
• cursor-stopped (condition)
• cursorp (function)
• disconnect (function)
• each (function)
• has-next (function)
• next (function)
• query-client-error (condition)
• query-compile-error (condition)
• query-error (condition)
• query-error-msg (method)
• query-runtime-error (condition)
• run (function)
• state (class)
• stop (function)
• stop/disconnect (function)
• to-array (function)
• to-sequence (function)
• wait-complete (function)

Internal Definitions

• active-queries (method)
• (setf active-queries) (method)
• conn-kv (method)
• (setf conn-kv) (method)
• connection-options (class)
• cursor-current-result (method)
• (setf cursor-current-result) (method)
• cursor-debug (method)
• (setf cursor-debug) (method)
• cursor-error-cursor (method)
• cursor-error-token (method)
• cursor-future (method)
• (setf cursor-future) (method)
• cursor-last-change (method)
• (setf cursor-last-change) (method)
• cursor-results (method)
• (setf cursor-results) (method)
• (setf cursor-results) (method)
• cursor-state (method)
• (setf cursor-state) (method)
• (setf cursor-state) (method)
• cursor-token (method)
• (setf cursor-token) (method)
• generate-token (function)
• get-cursor (function)
• json-to-response (function)
• make-response-handler (function)
• more (function)
• parse-response (function)
• query-error-backtrace (method)
• query-error-query (method)
• query-error-token (method)
• remove-cursor (function)
• save-cursor (function)
• serialize-query (function)
• state-token (method)
• (setf state-token) (method)
• with-query (macro)

5 Packages

Packages are listed by definition order.

5.1 cl-rethinkdb-util

Source

util.lisp (file)

Use List

• blackbird
• common-lisp

Used By List

• cl-rethinkdb
• cl-rethinkdb-reql

Exported Definitions

• do-hash/alist (macro)
• do-list/vector (macro)
• endian (function)
• jprint (function)
• unendian (function)

5.2 cl-rethinkdb

Source

package.lisp (file)

Nickname

r

Use List

• cl-rethinkdb-reql
• blackbird
• cl-rethinkdb-util
• common-lisp

Exported Definitions

• *object-type* (special variable)
• *sequence-type* (special variable)
• *state* (special variable)
• connect (function)
• cursor (class)
• cursor-error (condition)
• cursor-no-more-results (condition)
• cursor-overshot (condition)
• cursor-stopped (condition)
• cursorp (function)
• disconnect (function)
• each (function)
• has-next (function)
• next (function)
• query-client-error (condition)
• query-compile-error (condition)
• query-error (condition)
• query-error-msg (generic function)
• query-error-msg (method)
• query-runtime-error (condition)
• run (function)
• state (class)
• stop (function)
• stop/disconnect (function)
• to-array (function)
• to-sequence (function)
• wait-complete (function)

Internal Definitions

• *empty* (special variable)
• +datum-type-array+ (constant)
• +datum-type-bool+ (constant)
• +datum-type-json+ (constant)
• +datum-type-null+ (constant)
• +datum-type-num+ (constant)
• +datum-type-object+ (constant)
• +datum-type-str+ (constant)
• +proto-json+ (constant)
• +proto-query-continue+ (constant)
• +proto-query-start+ (constant)
• +proto-query-stop+ (constant)
• +proto-query-wait+ (constant)
• +proto-version+ (constant)
• +rdb-response-atom+ (constant)
• +rdb-response-client-error+ (constant)
• +rdb-response-compile-error+ (constant)
• +rdb-response-feed+ (constant)
• +rdb-response-partial+ (constant)
• +rdb-response-runtime-error+ (constant)
• +rdb-response-sequence+ (constant)
• +rdb-response-wait-complete+ (constant)
• active-queries (generic function)
• active-queries (method)
• (setf active-queries) (method)
• (setf active-queries) (generic function)
• conn-kv (generic function)
• conn-kv (method)
• (setf conn-kv) (method)
• (setf conn-kv) (generic function)
• connect-error (condition)
• connect-error-msg (generic function)
• connect-error-msg (method)
• connection-options (class)
• cursor-current-result (generic function)
• cursor-current-result (method)
• (setf cursor-current-result) (method)
• (setf cursor-current-result) (generic function)
• cursor-debug (generic function)
• cursor-debug (method)
• (setf cursor-debug) (method)
• (setf cursor-debug) (generic function)
• cursor-error-cursor (generic function)
• cursor-error-cursor (method)
• cursor-error-token (generic function)
• cursor-error-token (method)
• cursor-future (generic function)
• cursor-future (method)
• (setf cursor-future) (method)
• (setf cursor-future) (generic function)
• cursor-last-change (generic function)
• cursor-last-change (method)
• (setf cursor-last-change) (method)
• (setf cursor-last-change) (generic function)
• cursor-results (generic function)
• cursor-results (method)
• (setf cursor-results) (method)
• (setf cursor-results) (generic function)
• (setf cursor-results) (method)
• cursor-state (generic function)
• cursor-state (method)
• (setf cursor-state) (method)
• (setf cursor-state) (generic function)
• (setf cursor-state) (method)
• cursor-token (generic function)
• cursor-token (method)
• (setf cursor-token) (method)
• (setf cursor-token) (generic function)
• do-close (function)
• do-connect (function)
• finalize-connect (function)
• finalize-query (function)
• generate-token (function)
• get-cursor (function)
• json-to-response (function)
• make-response-handler (function)
• more (function)
• parse-response (function)
• query-error-backtrace (generic function)
• query-error-backtrace (method)
• query-error-query (generic function)
• query-error-query (method)
• query-error-token (generic function)
• query-error-token (method)
• remove-cursor (function)
• save-cursor (function)
• serialize-query (function)
• set-callbacks (function)
• sock-write (function)
• socket-data (macro)
• state-token (generic function)
• state-token (method)
• (setf state-token) (method)
• (setf state-token) (generic function)
• with-query (macro)

5.3 cl-rethinkdb-reql

Source

package.lisp (file)

Nickname

reql

Use List

• cl-rethinkdb-util
• common-lisp

Used By List

cl-rethinkdb

Exported Definitions

• convert-pseudotypes-recursive (function)
• fn (macro)
• r (macro)
• reql-error (condition)

Internal Definitions

• (function)
• != (function)
• % (function)
• && (function)
• * (function)
• *commands* (special variable)
• *varnum* (special variable)
• + (function)
• - (function)
• / (function)
• < (function)
• <= (function)
• == (function)
• > (function)
• >= (function)
• alist (type)
• alistp (function)
• append (function)
• april (function)
• args (function)
• asc (function)
• attr (function)
• august (function)
• avg (function)
• between (function)
• between-dep (function)
• binary (function)
• bracket (function)
• branch (function)
• call (function)
• change-at (function)
• changes (function)
• circle (function)
• cmd-arg (function)
• cmd-args (generic function)
• cmd-args (method)
• (setf cmd-args) (method)
• (setf cmd-args) (generic function)
• cmd-name (generic function)
• cmd-name (method)
• (setf cmd-name) (method)
• (setf cmd-name) (generic function)
• cmd-op (generic function)
• cmd-op (method)
• (setf cmd-op) (method)
• (setf cmd-op) (generic function)
• cmd-options (generic function)
• cmd-options (method)
• (setf cmd-options) (method)
• (setf cmd-options) (generic function)
• coerce-to (function)
• concat-map (function)
• config (function)
• contains (function)
• convert-pseudotypes (function)
• count (function)
• date (function)
• day (function)
• day-of-week (function)
• day-of-year (function)
• db (function)
• db-create (function)
• db-drop (function)
• db-list (function)
• december (function)
• default (function)
• defcommand (macro)
• delete (function)
• delete-at (function)
• desc (function)
• difference (function)
• distance (function)
• distinct (function)
• do (function)
• downcase (function)
• during (function)
• epoch-time (function)
• eq-join (function)
• error (function)
• expr (function)
• february (function)
• fill (function)
• filter (function)
• for-each (function)
• friday (function)
• func (function)
• generate-fn-var (function)
• geojson (function)
• get (function)
• get-all (function)
• get-intersecting (function)
• get-nearest (function)
• group (function)
• has-fields (function)
• hours (function)
• http (function)
• in-timezone (function)
• includes (function)
• index-create (function)
• index-drop (function)
• index-list (function)
• index-rename (function)
• index-status (function)
• index-wait (function)
• info (function)
• inner-join (function)
• insert (function)
• insert-at (function)
• intersects (function)
• is-empty (function)
• iso8601 (function)
• january (function)
• javascript (function)
• json (function)
• july (function)
• june (function)
• keys (function)
• limit (function)
• line (function)
• literal (function)
• make-array (function)
• make-obj (function)
• map (function)
• march (function)
• match (function)
• max (function)
• maxval (function)
• may (function)
• merge (function)
• min (function)
• minutes (function)
• minval (function)
• monday (function)
• month (function)
• november (function)
• now (function)
• nth (function)
• object (function)
• october (function)
• offsets-of (function)
• order-by (function)
• outer-join (function)
• pluck (function)
• point (function)
• polygon (function)
• polygon-sub (function)
• prepend (function)
• random (function)
• range (function)
• rebalance (function)
• reconfigure (function)
• reduce (function)
• replace (function)
• reql-cmd (class)
• reql-error-msg (generic function)
• reql-error-msg (method)
• row (function)
• sample (function)
• saturday (function)
• seconds (function)
• september (function)
• set-difference (function)
• set-insert (function)
• set-intersection (function)
• set-union (function)
• skip (function)
• slice (function)
• splice-at (function)
• split (function)
• status (function)
• sum (function)
• sunday (function)
• sync (function)
• table (function)
• table-create (function)
• table-drop (function)
• table-list (function)
• thursday (function)
• time (function)
• time-of-day (function)
• timezone (function)
• to-epoch-time (function)
• to-geojson (function)
• to-iso8601 (function)
• to-json-string (function)
• tuesday (function)
• type-of (function)
• ungroup (function)
• union (function)
• upcase (function)
• update (function)
• uuid (function)
• var (function)
• wait (function)
• wednesday (function)
• with-fields (function)
• without (function)
• year (function)
• zip (function)
• ~ (function)

6 Definitions

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

6.1 Exported definitions

6.1.1 Special variables

Special Variable: *object-type*

Defines whether data returned as an object should be an :alist or :hash.

Package

cl-rethinkdb

Source

config.lisp (file)

Special Variable: *sequence-type*

Defines whether data returned as a sequence should be a :list or :array.

Package

cl-rethinkdb

Source

config.lisp (file)

Special Variable: *state*

Holds all tracking state for the RethinkDB driver.

Package

cl-rethinkdb

Source

query.lisp (file)

6.1.2 Macros

Macro: do-hash/alist ((BIND-KEY BIND-VAL) HASH/ALIST) &body BODY

Generifies looping over a hash table or alist.

Package

cl-rethinkdb-util

Source

util.lisp (file)

Macro: do-list/vector (BIND-VAL LIST/VECTOR) &body BODY

Generifies looping over a list OR vector.

Package

cl-rethinkdb-util

Source

util.lisp (file)

Macro: fn ARGS &body BODY

Makes creating anonymous REQL functions easy. Takes a list of arguments (this is not a real lambda list, just a flat list of args) and wraps the body in the REQL-generating form ’r’.

Package

cl-rethinkdb-reql

Source

function.lisp (file)

Macro: r &body QUERY-FORM

Wraps query generation in a macro that takes care of pesky function naming issues. For instance, the function ‘count‘ is reserved in CL, so importing cl-rethinkdb-reql:count into your app might mess a lot of things up. Instead, you can wrap your queries in (r ...) and use *keywords* for function names, and all will be well. For instance:

(r::insert (r::table "users") ’(("name" . "larry")))

becomes:

(r (:insert (:table "users") ’(("name" . "larry"))))

This allows you to separate CL functions from query functions both logically and visually.

Package

cl-rethinkdb-reql

Source

dsl.lisp (file)

6.1.3 Functions

Function: connect HOST PORT &key DB USE-OUTDATED NOREPLY PROFILE READ-TIMEOUT AUTH

Connect to a RethinkDB database, optionally specifying the database.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: convert-pseudotypes-recursive OBJ

Recursively handle RethinkDB’s pseudotypes in returned objects.

Package

cl-rethinkdb-reql

Source

pseudotypes.lisp (file)

Function: cursorp CURSOR

Determine if the given object is a cursor.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: disconnect SOCK

Disconnect a RethinkDB connection.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: each SOCK CURSOR FUNCTION

Call the given function on every result in the given cursor.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: endian NUMBER NUM-BYTES

Convert a number into N bytes little endian.

Package

cl-rethinkdb-util

Source

util.lisp (file)

Function: has-next CURSOR

Determine if a cursor has more results.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: jprint OBJ &optional STREAM

Package

cl-rethinkdb-util

Source

util.lisp (file)

Function: next SOCK CURSOR

Grab the next result from a cursor. Always returns a future since it may have to get more results from the server.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: run SOCK QUERY-FORM

This function runs the given query, and returns a future that’s finished when the query response comes in.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: stop SOCK CURSOR

Cleanup a cursor both locally and in the database. Returns a future that is finished with *no values* once the stop operation has completed.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: stop/disconnect SOCK CURSOR

Call stop on a cursor and disconnect the passed socket.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: to-array SOCK CURSOR

Grab ALL results from a cursor. Returns a future finished with the final array.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: to-sequence SOCK CURSOR

Takes a socket and a cursor an returns a sequence of all the items that cursor points to (the type of sequence returned depends on *sequence-type*)

Package

cl-rethinkdb

Source

query.lisp (file)

Function: unendian BYTES NUM-BYTES &key OFFSET

Turns N number of bytes at offset in bytes into an integer.

Package

cl-rethinkdb-util

Source

util.lisp (file)

Function: wait-complete SOCK

Wait for noreply => t queries to come back LOL.

Package

cl-rethinkdb

Source

query.lisp (file)

6.1.4 Generic functions

Generic Function: query-error-msg CONDITION

Package

cl-rethinkdb

Methods

Method: query-error-msg (CONDITION query-error)

Source

query.lisp (file)

6.1.5 Conditions

Condition: cursor-error ()

Describes a general query error.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses

• cursor-no-more-results (condition)
• cursor-overshot (condition)
• cursor-stopped (condition)

Direct methods

• cursor-error-cursor (method)
• cursor-error-token (method)

Direct slots

Slot: token

Initargs

:token

Initform

(quote nil)

Readers

cursor-error-token (generic function)

Slot: cursor

Initargs

:cursor

Initform

(quote nil)

Readers

cursor-error-cursor (generic function)

Condition: cursor-no-more-results ()

Thrown when a cursor has no more results on it.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

cursor-error (condition)

Condition: cursor-overshot ()

Thrown when a cursor has no more results on it.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

cursor-error (condition)

Condition: cursor-stopped ()

Thrown when a cursor that has a pending operation is stopped.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

cursor-error (condition)

Condition: query-client-error ()

A client error condition.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

query-error (condition)

Condition: query-compile-error ()

A query compile error condition.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

query-error (condition)

Condition: query-error ()

A general query failure condition.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses

• query-client-error (condition)
• query-compile-error (condition)
• query-runtime-error (condition)

Direct methods

• query-error-msg (method)
• query-error-backtrace (method)
• query-error-query (method)
• query-error-token (method)

Direct slots

Slot: token

Initargs

:token

Initform

(quote nil)

Readers

query-error-token (generic function)

Slot: query

Initargs

:query

Initform

(quote nil)

Readers

query-error-query (generic function)

Slot: backtrace

Initargs

:backtrace

Initform

(quote nil)

Readers

query-error-backtrace (generic function)

Slot: msg

Initargs

:msg

Initform

(quote "")

Readers

query-error-msg (generic function)

Condition: query-runtime-error ()

A query runtime error condition.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

query-error (condition)

Condition: reql-error ()

A general reql error

Package

cl-rethinkdb-reql

Source

pseudotypes.lisp (file)

Direct superclasses

simple-error (condition)

Direct methods

reql-error-msg (method)

Direct slots

Slot: msg

Initargs

:msg

Initform

(quote "")

Readers

reql-error-msg (generic function)

6.1.6 Classes

Class: cursor ()

The query class holds the state of a query, as well as the future that will be finished when the query returns results.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

dispatch (class)

Direct methods

• (setf cursor-results) (method)
• (setf cursor-state) (method)
• cursor-debug (method)
• cursor-debug (method)
• cursor-current-result (method)
• cursor-current-result (method)
• cursor-results (method)
• cursor-results (method)
• cursor-last-change (method)
• cursor-last-change (method)
• cursor-token (method)
• cursor-token (method)
• cursor-future (method)
• cursor-future (method)
• cursor-state (method)
• cursor-state (method)

Direct slots

Slot: state

Describes the current state of the query (new, complete, etc).

Initargs

:state

Initform

:new

Readers

cursor-state (generic function)

Writers

(setf cursor-state) (generic function)

Slot: future

Holds the future that will be finished with the results from this query.

Initargs

:future

Readers

cursor-future (generic function)

Writers

(setf cursor-future) (generic function)

Slot: token

Holds the token for this query.

Initargs

:token

Readers

cursor-token (generic function)

Writers

(setf cursor-token) (generic function)

Slot: last-change

Tracks the last time the query changed state.

Initform

0

Readers

cursor-last-change (generic function)

Writers

(setf cursor-last-change) (generic function)

Slot: results

Holds the current result set from the query.

Readers

cursor-results (generic function)

Writers

(setf cursor-results) (generic function)

Slot: current-result

Tracks which record the cursor points to.

Initform

0

Readers

cursor-current-result (generic function)

Writers

(setf cursor-current-result) (generic function)

Slot: debug

Holds freeform debug info for this cursor.

Initargs

:debug

Readers

cursor-debug (generic function)

Writers

(setf cursor-debug) (generic function)

Class: state ()

Tracks all state for the driver.

Package

cl-rethinkdb

Source

query.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• print-object (method)
• active-queries (method)
• active-queries (method)
• state-token (method)
• state-token (method)

Direct slots

Slot: token

Initform

0

Readers

state-token (generic function)

Writers

(setf state-token) (generic function)

Slot: active-queries

Initform

(make-hash-table :test (function eq))

Readers

active-queries (generic function)

Writers

(setf active-queries) (generic function)

6.2 Internal definitions

6.2.1 Constants

Constant: +datum-type-array+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-bool+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-json+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-null+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-num+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-object+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +datum-type-str+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-json+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-query-continue+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-query-start+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-query-stop+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-query-wait+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +proto-version+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-atom+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-client-error+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-compile-error+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-feed+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-partial+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-runtime-error+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-sequence+

Package

cl-rethinkdb

Source

protocol.lisp (file)

Constant: +rdb-response-wait-complete+

Package

cl-rethinkdb

Source

protocol.lisp (file)

6.2.2 Special variables

Special Variable: *commands*

Holds name -> lambda mappings for our commands.

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Special Variable: *empty*

An empty data set for setting callbacks. Perhaps a cl-async API for this is in order??

Package

cl-rethinkdb

Source

connection.lisp (file)

Special Variable: *varnum*

Used to track lambda variables in functions.

Package

cl-rethinkdb-reql

Source

function.lisp (file)

6.2.3 Macros

Macro: defcommand (TERMVAL NAME &key DEFUN) ALL-ARGS &key DOCSTR ARRAYS

Wraps creation of commands.

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Macro: socket-data SOCKET

Allow storing of arbitrary data with a socket.

Package

cl-rethinkdb

Source

connection.lisp (file)

Macro: with-query (SOCK CURSOR TOKEN QUERY STATE &key REJECT-ON-STOP) RESOLVE REJECT

Package

cl-rethinkdb

Source

query.lisp (file)

6.2.4 Functions

Function: &rest BOOLS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: != &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: % NUMBER MOD

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: && &rest BOOLS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: * &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: + &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: - &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: / &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: < &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: <= &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: == &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: > &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: >= &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: alistp ALIST

Determine if the given object is an alist.

Package

cl-rethinkdb-reql

Source

types.lisp (file)

Function: append ARRAY OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: april ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: args ARRAY

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: asc STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: attr OBJECT KEY

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: august ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: avg SEQUENCE FIELD/FUNCTION

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: between STREAM LEFT RIGHT &key INDEX RIGHT-BOUND LEFT-BOUND

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: between-dep STREAM LEFT RIGHT &key INDEX RIGHT-BOUND LEFT-BOUND

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: binary BASE64-STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: bracket SEQUENCE/OBJECT NUMBER/STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: branch BOOL TRUE-EXPR FALSE-EXPR

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: call FN &rest ALL-ARGS

Call a command by name.

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: change-at ARRAY INDEX OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: changes TABLE &key SQUASH INCLUDE-STATES

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: circle GEO RADIUS &key NUM-VERTICES GEO-SYSTEM UNIT FILL

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: cmd-arg X

Makes sure all DATA (not command) arrays are wrapped in a make-array cmd.

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: coerce-to VAL STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: concat-map SEQUENCE FUNCTION

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: config DB/TABLE

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: contains SEQUENCE OBJECT/FUNCTION

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: convert-pseudotypes OBJ

Handle pseudotypes.

Package

cl-rethinkdb-reql

Source

pseudotypes.lisp (file)

Function: count SEQUENCE

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: date TIME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: day TIME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: day-of-week TIME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: day-of-year TIME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: db DBNAME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: db-create NAME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: db-drop NAME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: db-list ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: december ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: default OBJECT DEFAULT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: delete SELECTION &key DURABILITY RETURN-CHANGES

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: delete-at ARRAY INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: desc STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: difference ARRAY1 ARRAY2

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: distance GEO-FROM GEO-TO &key GEO-SYSTEM UNIT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: distinct SEQUENCE &key INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: do FUNCTION &rest ARGS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: do-close SOCK

Close the given socket.

Package

cl-rethinkdb

Source

connection.lisp (file)

Function: do-connect HOST PORT &key READ-TIMEOUT

Create a connection to the given host/port, and optionally db.

Package

cl-rethinkdb

Source

connection.lisp (file)

Function: downcase STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: during TIME START END

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: epoch-time NUMBER

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: eq-join SEQUENCE1 FIELD SEQUENCE2 &key INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: error ERRSTR

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: expr LISP-OBJ

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: february ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: fill GEO

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: filter SEQUENCE FUNCTION &key DEFAULT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: finalize-connect SOCK

Make sure a connection to the DB was successful.

Package

cl-rethinkdb

Source

connection.lisp (file)

Function: finalize-query SOCK

Make sure a socket that just had query data sent over it is ready to handle the response.

Package

cl-rethinkdb

Source

connection.lisp (file)

Function: for-each SEQUENCE FUNCTION

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: friday ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: func ARGS BODY

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: generate-fn-var ()

Returns ’unique’ variable ’names’ for ’anonymous’ ’functions’ ;) ;) if you know what I mean heh heh ;) ;) ;).

Package

cl-rethinkdb-reql

Source

function.lisp (file)

Function: generate-token &key STATE

Generates a new token value for a query.

Package

cl-rethinkdb

Source

query.lisp (file)

Function: geojson OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: get TABLE ID

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: get-all TABLE IDS &key INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: get-cursor TOKEN &key STATE

Grab a cursor associated with a token. Returns nil if no cursor exists for that token

Package

cl-rethinkdb

Source

query.lisp (file)

Function: get-intersecting TABLE GEO &key INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: get-nearest TABLE GEO &key INDEX MAX-RESULTS MAX-DIST GEO-SYSTEM UNIT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: group SEQUENCE FIELD/FUNCTION &key INDEX

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: has-fields OBJECT &rest PATHSPEC

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: hours TIME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: http URL &key DATA TIMEOUT METHOD PARAMS HEADER ATTEMPS REDIRECTS VERIFY PAGE PAGE-LIMIT AUTH RESULT-FORMAT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: in-timezone TIME STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: includes GEO1 GEO2

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-create TABLE NAME FUNCTION &key MULTI GEO

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-drop TABLE NAME

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-list TABLE

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-rename TABLE FROM TO &key OVERWRITE

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-status TABLE &rest NAMES

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: index-wait TABLE &rest NAMES

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: info OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: inner-join SEQUENCE1 SEQUENCE2 FUNCTION

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: insert TABLE OBJECT &key CONFLICT DURABILITY RETURN-CHANGES

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: insert-at ARRAY INDEX VAL

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: intersects GEO1 GEO2

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: is-empty SEQUENCE

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: iso8601 STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: january ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: javascript STRING &key TIMEOUT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: json STRING

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: json-to-response JSON

Package

cl-rethinkdb

Source

query.lisp (file)

Function: july ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: june ()

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: keys OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: limit SEQUENCE NUMBER

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: line &rest ARRAY/GEO

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: literal OBJECT

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: make-array &rest OBJECTS

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: make-obj HASH

Package

cl-rethinkdb-reql

Source

commands.lisp (file)

Function: make-response-handler ()

This function returns a closure that can be called multiple times with data from a RethinkDB response. If a full response is received (over one or more calls) it returns the *full byte array of the response*, otherwise nil.

Note that the response chunks MUST be passed in in the order received.

Package

cl-rethinkdb

Source

query.lisp (file)