Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the orizuru-orm Reference Manual, version 0.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 05:47:46 2022 GMT+0.
Next: Systems, Previous: The orizuru-orm Reference Manual, Up: The orizuru-orm Reference Manual [Contents][Index]
#+OPTIONS: html-postamble:nil html-preamble:nil
#+AUTHOR:
#+TITLE: Orizuru-orm
* Orizuru-Orm
Orizuru-Orm is an ORM for Common Lisp and postgreSQL, providing a
simple bridge between CLOS and relational databases, and out of the
box migrations, it is based on
[[https://github.com/eudoxia0/crane/][Crane]].
* Usage
** Defining Tables
#+BEGIN_SRC common-lisp
(deftable user ()
(name :type text :uniquep t)
(age :type integer :nullp nil :initform 18)
(friend :type integer :foreign user)))
#+END_SRC
The foreign argument accepts a symbol that represents another table or
a sexp of the form ~(table &key on-delete on-update))~, where
acceptable values are ~:no-action :restrict :cascade :set-null
:set-default~.
*** Column types
|-------------+--------------+----------------------------+-----------------+--------------------+
| orizuru-orm | CL | SQL | inflate/deflate | migration allowed? |
|-------------+--------------+----------------------------+-----------------+--------------------+
| int | integer | integer | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| bigint | integer | bigint | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| smallint | integer | smallint | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| numeric | ratio | numeric | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| double | double-float | double precision | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| text | string | text | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| varchar | string | text | yes | yes |
|-------------+--------------+----------------------------+-----------------+--------------------+
| timestamp | string | timestamp [with time zone] | yes | yes (see notes) |
|-------------+--------------+----------------------------+-----------------+--------------------+
| datetime | string | TODO | TODO | TODO |
|-------------+--------------+----------------------------+-----------------+--------------------+
**** Notes
- for ~timestamp~ columns migration is allowed only from and to ~text~;
- the timezone for timestamp column is governed by the value of the special variable
~orizuru-orm.sql:*timestamp-column-uses-timezone-p*~.
** Migrating
The first rule is: never use migration in production before testing!
And, in any case, always be sure to be able to perform a rollback
(backup, snapshot, whatever tool you have to recover a database).
#+BEGIN_SRC common-lisp
(deftable user ()
(name :type integer :uniquep t :nullp nil)
(age :type integer :nullp t :initform 18)
(description :type text))
#+END_SRC
Just make the changes, and Orizuru-Orm will compute the diffs and
perform all the ~ALTER TABLE~ directives for you.
In the example above the following action will be performed:
- the column ~name~ will change type from ~integer~ to ~text~;
- the column ~age~ will be able to assume a NULL value;
- the column ~friend ~ is *deleted*;
- a column ~description~ is added.
*** About altering column type
This operation is allowed but a bit tricky. A limited automatic
conversion using common sense (my common sense!) is available (see
[[Column types]]) but, of course, the conversion i have chosen could
not be useful or even harmless for your database, so use this feature
with caution. For example a conversion from a column of type ~text~
with value ~foo~ can not be converted to ~integer~ and will signal an
error, while a conversion from ~double~ to ~int~ will drop the decimal
part and so on.
And, finally, be careful that removing a slot will remove a column
(and its values, and possibly the column of a referenced table) from
the database.
** Connecting
#+BEGIN_SRC common-lisp
(setup
:migrations-directory
(asdf:system-relative-pathname :myapp #p"migrations/")
:databases
'(:main
(:type :postgres
:name "myapp_db"
:user "user"
:pass "user")))
(connect)
#+END_SRC
For configuration management and switching databases in development/production
environments, you might want to use [Envy](https://github.com/fukamachi/envy).
** Creating, Saving, and Deleting Objects
#+BEGIN_SRC common-lisp
(let ((instance (create 'ship :name "Dalliance"
:tonnage 77)))
;; FIXME: It's back luck to rename a ship
(setf (name instance) "Serenity")
;; Expand the cargo hold
(incf (tonnage instance) 25)
;; Save these changes!
(save instance)
;; Time to retire
(del instance))
#+END_SRC
** Filtering
#+BEGIN_SRC common-lisp
(filter 'user) ;; Returns everything
(filter 'user :name "John")
(filter 'user (:> :age 21))
;; Returns a single object
(single 'user :name "John")
;; Throws an error if this returns more
;; than one object
(single! 'user (:< age 35))
;; t if a match exists, nil otherwise
(exists 'user :name "John")
;; If this record doesn't exist create it
(get-or-create 'user :name "John" :age 19)
#+END_SRC
*** More complex filtering
*WARNING*: this part is very experimental, the API could change at any
moment probably broken and, moreover, the code is ugly. :)
**** Creating a query set
Assuming a valid database connection and the following tables definition:
#+BEGIN_SRC common-lisp
(deftable m ()
(a
:type integer))
(deftable x ()
(dummy
:type text))
(deftable y ()
(to-x
:type integer
:foreign (x :restrict :cascade)))
(deftable z ()
(to-m
:type integer
:foreign (m :restrict :cascade))
(to-y
:type integer
:foreign (y :restrict :cascade)))
#+END_SRC
evaluating this form:
#+BEGIN_SRC common-lisp
(let ((orizuru-orm.util:*foreign-slots-class-package* :user-package))
(make-query-set :z->y->x.= 2))
#+END_SRC
create an object that hold a query like that (some escaping character
removed for readability):
#+BEGIN_SRC sql
SELECT z.* FROM z
INNER JOIN y ON (z.to-y = y.id)
INNER JOIN x ON (y.to-x = x.id)
WHERE (x.id = 2)
#+END_SRC
as you can see the sequence ~a->b~ means a slot/column (foreign key)
from class/table ~a~ that reference the ~id~ slot/column of
class/table ~b~, the library will figure out the actual name of said
slot.
It is possible to filter around a different slot and with different
test like that:
#+BEGIN_SRC common-lisp
(let ((orizuru-orm.util:*foreign-slots-class-package* :user-package))
(make-query-set :z->y->x_dummy.ilike "%foo"))
#+END_SRC
**** Filtering query set
query can be "chained" with ~filter-set~, this macro will not modify
the original object it is applied to:
#+BEGIN_SRC text
filter-set (&optional qset params logical-op)
#+END_SRC
- qset :: is the query-set object you want to modify (actually a modified copy is returned);
- params :: is a ~list~ of parameters (see examples below);
- logical-op :: a logical operation as keyword '(:or :and :not); default is :and.
Here is some more examples (the following will show the code generated
as sxql):
#+BEGIN_SRC common-lisp
(let ((q (make-query-set :z.= 2)))
(->sxql q)))
;; =>
(SELECT (:Z.*)
(FROM :Z)
(WHERE (:AND (:= :Z.ID 2))))
(let ((q (make-query-set :x.= 2)))
(setf q (filter-set q (:y_id.> 1) :or))
(setf q (filter-set q (:y_id.<= 5) :and))
(->sxql q))
;; =>
(SELECT (X.*)
(FROM X)
(WHERE (AND (<= Y.ID 5)
(OR (> Y.ID 1)
(AND (= X.ID 2))))))
(let ((q (make-query-set :z->y->x.= 2)))
(setf q (filter-set q (:z->m_a.> 9)))
(->sxql q))
;; =>
(SELECT (Z.*)
(FROM Z)
(INNER-JOIN M ON (= Z.TO-M M.ID))
(INNER-JOIN Y ON (= Z.TO-Y Y.ID))
(INNER-JOIN X ON (= Y.TO-X X.ID))
(WHERE (AND (> M.A 9)
(AND (= X.ID 2)))))
;; of course this does not makes sense, it is just to show the API ^^;
(let ((q (make-query-set :z->y->x.= 2)))
(setf q (filter-set q (:y_id.> 1) :not))
(setf q (filter-set q (:y_id.<= 2) :and))
(setf q (filter-set q (:z_id.> 0)))
(setf q (filter-set q (:z->m_a.> 9)))
(->sxql q))
;; =>
(SELECT (:Z.*)
(FROM :Z)
(INNER-JOIN :M :ON (:= :Z.TO-M :M.ID))
(INNER-JOIN :Y :ON (:= :Z.TO-Y :Y.ID))
(INNER-JOIN :X :ON (:= :Y.TO-X :X.ID))
(WHERE (:AND (:> :M.A 9)
(:AND (:> :Z.ID 0)
(:<= :Y.ID 2)
(:AND (:NOT (:> :Y.ID 1))
(:AND (:= :X.ID 2)))))))
#+END_SRC
**** Get results from query-set
to get the results from query use the method ~all-from-set~,
specialized on class ~query-set~
#+BEGIN_SRC common-lisp
all-from-set ((object query-set) &key (as-plist nil))
#+END_SRC
#+BEGIN_SRC common-lisp
(all-from-set a-query-set :as-plist nil)
;; =>
;; '(instance-of-class ...) or nil
(all-from-set a-query-set :as-plist t)
;; =>
;; '((:slot-1 value :slot-2 value) ... ) or nil
#+END_SRC
**** Changing join column
given this two tables
#+BEGIN_SRC common-lisp
(deftable foo ()
(dummy
:type text))
(deftable bar ()
(to-foo
:type integer
:foreign (foo :restrict :cascade))
(to-foo-2
:type integer
:foreign (foo :restrict :cascade)))
#+END_SRC
a query set like
#+BEGIN_SRC common-lisp
(let ((q (make-query-set :y->foo.=1))
#+END_SRC
because the join can happen either on column ~to-foo~ or ~to-foo-2~ an
error is signalled; in this case the user should specify the join
column using the macro:
#+BEGIN_SRC common-lisp
with-join-column ((column) &body body)
#+END_SRC
example given:
#+BEGIN_SRC common-lisp
(with-join-column (:to-foo)
(let ((q (make-query-set :y->foo.=1)))))
#+END_SRC
**** Change mapped table
by default getting data form a query-set will return a list of
instances (or list of plist see: [[Get results from query-set]]) of
the first recognized table, for example the values of this form:
#+BEGIN_SRC common-lisp
(with-join-column (:to-foo)
(let ((q (make-query-set :y->foo.=1)))
(all-from-set q)))
#+END_SRC
is a list of instances of class ~y~ (or nil if the search criteria
does not match any row of the table); to get a list of instances of
~foo~ use the function:
#+BEGIN_SRC text
map-to-model (query-set class-symbol)
#+END_SRC
#+BEGIN_SRC common-lisp
(with-join-column (:to-foo)
(let ((q (make-query-set :y->foo.=1)))
(setf q (map-to-model q :foo))
(all-from-set q)))
;; => '(instance-of-foo-1, instance-of-foo-2 ...)
#+END_SRC
**** Finding slots that are foreign keys
To find the foreign key of a table user must set or bind the special
variable ~orizuru-orm.util:*foreign-slots-class-package*~ to the
actual package where your tables are defined; a macro
~query-set:with-table-package~ makes this task less annoyng:
#+BEGIN_SRC common-lisp
(with-table-package ((the-package) &body body)
(with-join-column (:to-foo)
(let ((q (make-query-set :y->foo.=1)))
(setf q (map-to-model q :foo))
(all-from-set q)))
#+END_SRC
**** Notes
Whilst i appreciate that someone would test this code to improve it i
can not recommend to use it in production (see [[NO WARRANTY]]).
** Beyond ORM
Use [[https://github.com/fukamachi/sxql][sxql]]
** Transactions
#+BEGIN_SRC lisp
;;;; Automatic
(with-transaction ()
(let ((restaurants (filter 'restaurant ...)))
(loop for restaurant in restaurants do
...
(save restaurant))))
;;;; Manual
(progn
(begin-transaction)
(let ((restaurants (filter 'restaurant ...)))
(loop for restaurant in restaurants do
...
(save restaurant)))
(commit))
#+END_SRC
** Fixtures
#+BEGIN_SRC lisp
;;;; initial-data.lisp
(app:user
(:name "john"
:groups (:admin :staff))
(:name "joe"
:groups (:admin)))
(app:company
(:name "Initech"
:city "Denver"))
;;;; myapp.asd
(asdf:defsystem myapp
:defsystem-depends-on (:clos-fixtures)
:components ((:module "src"
:components
((:fixture "initial-data")))))
#+END_SRC
** Inflate/Deflate
#+BEGIN_SRC lisp
(definflate (stamp 'timestamp)
;; Inflate a timestamp value
;; into a timestamp object
(local-time:universal-to-timestamp stamp))
(defdeflate (stamp local-time:timestamp)
;; Deflate a timestamp object
;; into a string
(local-time:format-timestring nil stamp))
#+END_SRC
** Using testing suite
*** Set up Postgres
Assuming there is a working PostgreSQL server running and configured
use the following:
#+BEGIN_SRC shell
$ su -
(root)# su - postgres
(postgres)$ createdb orizuru_test_db
(postgres)$ psql -c "CREATE USER orizuru_test_user WITH PASSWORD 'orizuru_test_user'"
(postgres)$ psql -c "GRANT ALL PRIVILEGES ON DATABASE orizuru_test_db TO orizuru_test_user"
(postgres)$ ^D
(root)# ^D
#+END_SRC
*** Run the test suite
#+BEGIN_SRC lisp
(ql:quickload :orizuru-orm-test)
(run-all-tests :use-debugger t)
#+END_SRC
if you plane to rerun the test you must delete the testing database
first (be careful not to delete a valuable database!)
#+BEGIN_SRC shell
$ su -
(root)# su - postgres
(postgres)$ dropdb orizuru_test_db
#+END_SRC
then go to [[Set up Postgres]] and start again.
* BUGS
Bugs or other problems can be reported on the
[[https://notabug.org/cage/orizuru-orm/][issue tracker]].
* Contributing
Help is appreciated, just point your browser to the
[[https://notabug.org/cage/orizuru-orm/][repository]] to get the
development version, fork and then
[[https://notabug.org/cage/orizuru-orm/pulls][send patches]]. Thank
you in advance! :)
** Testing
If you add new feature please add a test to ensure that it works and,
in the future, if a regression occurs, is not missed.
* Acknowledgment
Much of the work for this library come from "Eudoxia0", the original
author of this code, to whom goes my acknowledgment.
* License
Originally released as Crane Copyright © 2013 Fernando Borretti under
the MIT license (following).
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
For this version:
This program is Copyright © 2019 Universita' degli Studi di Palermo
and released under GNU General Public license version 3 of the
License, or (at your option) any later version.(see COPYING file).
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
* NO WARRANTY
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
Next: Modules, Previous: Introduction, Up: The orizuru-orm Reference Manual [Contents][Index]
The main system appears first, followed by any subsystem dependency.
An ORM for Common Lisp and PostgreSQL.
cage
Fernando Borretti, cage
GPLv3
0.0.1
src (module).
Next: Files, Previous: Systems, Up: The orizuru-orm Reference Manual [Contents][Index]
Modules are listed depth-first from the system components tree.
orizuru-orm (system).
Next: Packages, Previous: Modules, Up: The orizuru-orm Reference Manual [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
Next: orizuru-orm/src/package.lisp, Previous: Lisp, Up: Lisp [Contents][Index]
orizuru-orm (system).
Next: orizuru-orm/src/constants.lisp, Previous: orizuru-orm/orizuru-orm.asd, Up: Lisp [Contents][Index]
src (module).
Next: orizuru-orm/src/errors.lisp, Previous: orizuru-orm/src/package.lisp, Up: Lisp [Contents][Index]
package.lisp (file).
src (module).
Next: orizuru-orm/src/config.lisp, Previous: orizuru-orm/src/constants.lisp, Up: Lisp [Contents][Index]
constants.lisp (file).
src (module).
Next: orizuru-orm/src/util.lisp, Previous: orizuru-orm/src/errors.lisp, Up: Lisp [Contents][Index]
errors.lisp (file).
src (module).
*config* (special variable).
Next: orizuru-orm/src/query-low-level.lisp, Previous: orizuru-orm/src/config.lisp, Up: Lisp [Contents][Index]
config.lisp (file).
src (module).
all-slots (function).
Next: orizuru-orm/src/connect.lisp, Previous: orizuru-orm/src/util.lisp, Up: Lisp [Contents][Index]
util.lisp (file).
src (module).
query-low-level (function).
Next: orizuru-orm/src/types.lisp, Previous: orizuru-orm/src/query-low-level.lisp, Up: Lisp [Contents][Index]
query-low-level.lisp (file).
src (module).
Next: orizuru-orm/src/sql.lisp, Previous: orizuru-orm/src/connect.lisp, Up: Lisp [Contents][Index]
connect.lisp (file).
src (module).
integer (type).
Next: orizuru-orm/src/meta.lisp, Previous: orizuru-orm/src/types.lisp, Up: Lisp [Contents][Index]
types.lisp (file).
src (module).
Next: orizuru-orm/src/query.lisp, Previous: orizuru-orm/src/sql.lisp, Up: Lisp [Contents][Index]
sql.lisp (file).
src (module).
Next: orizuru-orm/src/migration.lisp, Previous: orizuru-orm/src/meta.lisp, Up: Lisp [Contents][Index]
meta.lisp (file).
src (module).
Next: orizuru-orm/src/table.lisp, Previous: orizuru-orm/src/query.lisp, Up: Lisp [Contents][Index]
query.lisp (file).
src (module).
Next: orizuru-orm/src/inflate-deflate.lisp, Previous: orizuru-orm/src/migration.lisp, Up: Lisp [Contents][Index]
migration.lisp (file).
src (module).
Next: orizuru-orm/src/interface.lisp, Previous: orizuru-orm/src/table.lisp, Up: Lisp [Contents][Index]
table.lisp (file).
src (module).
db-nil-p (function).
Next: orizuru-orm/src/fixture.lisp, Previous: orizuru-orm/src/inflate-deflate.lisp, Up: Lisp [Contents][Index]
inflate-deflate.lisp (file).
src (module).
Next: orizuru-orm/src/transaction.lisp, Previous: orizuru-orm/src/interface.lisp, Up: Lisp [Contents][Index]
interface.lisp (file).
src (module).
register-fixture (method).
Next: orizuru-orm/src/query-set.lisp, Previous: orizuru-orm/src/fixture.lisp, Up: Lisp [Contents][Index]
fixture.lisp (file).
src (module).
Previous: orizuru-orm/src/transaction.lisp, Up: Lisp [Contents][Index]
transaction.lisp (file).
src (module).
Next: Definitions, Previous: Files, Up: The orizuru-orm Reference Manual [Contents][Index]
Packages are listed by definition order.
Next: orizuru-orm.errors, Previous: Packages, Up: Packages [Contents][Index]
Functions for reading and writing from and to the global configuration.
*config* (special variable).
Next: orizuru-orm.meta, Previous: orizuru-orm.config, Up: Packages [Contents][Index]
Definition of Orizuru-Orm errors.
common-lisp.
Next: orizuru-orm.util, Previous: orizuru-orm.errors, Up: Packages [Contents][Index]
This file defines the metaclasses that map CLOS objects to SQL tables, and some basic operations on them.
Next: orizuru-orm.migration, Previous: orizuru-orm.meta, Up: Packages [Contents][Index]
Various utilities for use in other parts of Orizuru-Orm.
all-slots (function).
Next: orizuru-orm.constants, Previous: orizuru-orm.util, Up: Packages [Contents][Index]
The first part of this package contains various
simple utilities for manipulating the migration history of a
table. The second part contains code that actually creates tables
and migrates them. The actual generation of table-creating SQL is
handled by orizuru-orm.sql.
Next: orizuru-orm.fixture, Previous: orizuru-orm.migration, Up: Packages [Contents][Index]
Some useful constants
Next: orizuru-orm.types, Previous: orizuru-orm.constants, Up: Packages [Contents][Index]
Customizes clos-fixtures for use in Orizuru-Orm.
common-lisp.
Next: orizuru-orm.table, Previous: orizuru-orm.fixture, Up: Packages [Contents][Index]
Implements the database types.
integer (type).
Next: orizuru-orm.query, Previous: orizuru-orm.types, Up: Packages [Contents][Index]
Implements the deftable macro.
Next: orizuru-orm.query.lowlevel, Previous: orizuru-orm.table, Up: Packages [Contents][Index]
Executing cl-dbi queries in the context of Orizuru-Orm.
Next: orizuru-orm.query-set, Previous: orizuru-orm.query, Up: Packages [Contents][Index]
Executing cl-dbi queries.
common-lisp.
query-low-level (function).
Next: orizuru-orm, Previous: orizuru-orm.query.lowlevel, Up: Packages [Contents][Index]
Implements query sets.
Next: orizuru-orm.sql, Previous: orizuru-orm.query-set, Up: Packages [Contents][Index]
The global Orizuru-Orm package re-exports symbols from internal modules.
Next: orizuru-orm.connect, Previous: orizuru-orm, Up: Packages [Contents][Index]
This module handles the generation of SQL for table definition and migration.
Next: orizuru-orm.transaction, Previous: orizuru-orm.sql, Up: Packages [Contents][Index]
Handles database connections, connection parameter validation, and various low-level DB-specific modes.
Next: orizuru-orm.inflate-deflate, Previous: orizuru-orm.connect, Up: Packages [Contents][Index]
Implements transactions.
Next: orizuru-orm.interface, Previous: orizuru-orm.transaction, Up: Packages [Contents][Index]
Inflation/deflation map SQL string to CLOS
objects. This is unrelated to the ORM, and meant to allow complex
column datatypes to be mapped to CLOS objects. For example, mapping
SQL timestamps to structures that represent time, or mapping other
more complex SQL types to CLOS objects.
db-nil-p (function).
Previous: orizuru-orm.inflate-deflate, Up: Packages [Contents][Index]
This package contains the methods used to access and alter database records in an object-oriented way.
Next: Indexes, Previous: Packages, Up: The orizuru-orm Reference Manual [Contents][Index]
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Special variables, Previous: Public Interface, Up: Public Interface [Contents][Index]
Next: Macros, Previous: Constants, Up: Public Interface [Contents][Index]
A function that gets executed after setup is called. Takes no arguments, does nothing by default.
The name of the default database
Next: Ordinary functions, Previous: Special variables, Up: Public Interface [Contents][Index]
Create an object.
Define a table.
Execute code for each result in the query, without aggregating them all into a list.
Execute an SxQL query on the database ‘database-name‘.
Next: Generic functions, Previous: Macros, Up: Public Interface [Contents][Index]
SQL to add a constraint to a table.
return a plist of (class-referring-name . slot-name)
SQL to alter a constraint in a table.
Connect to all the databases specified in the configuration.
A plist of different types of constraints from a table digest.
Determine if Orizuru-Orm is in debug mode.
A column definition from the digest of its slot, name and name of the database it’s table belongs to
Compute the difference between two digests. See DIGEST.
Calculates the difference between two plists, returning the result as a list of ([property] [old value] [new value])
Cut all connections.
Cut all connections and reset *db* hashtable
SQL to drop a column, given the table and column names.
SQL to drop a constraint from a table.
Find a slot by name
Find a slot by name
Find a slot in a class by keyword name
Get the value of ‘key‘ in the configuration.
Return the configuration object, or signal a no-configuration error.
Return the connection handler for a given database.
Return the database matching a specific name
Find slot by keyword name
Insert a new diff to the migration history
A constraint from its type and values, if it can be created (eg :nullp t doesn’t create a constraint, but :nullp nil creates a NOT NULL constraint).
T if the table has a migration history, NIL otherwise.
Return the keys of a plist.
Bypass orizuru-orm and execute sql query with dbi
Set the configuration.
Turn a symbol or a string into its SQL representation. Identical to the behaviour of SxQL.
Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
Whether the class corresponds to an SQL table or not.
Add a table as child of this query set
automatically generated reader method
automatically generated writer method
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated reader method
automatically generated writer method
automatically generated reader method
The underlying connection object.
conn.
The database name.
name.
A keyword representing the database type (:postgres only atm).
type.
Whether the class should be built only when explicitly calling build.
Turn a Lisp object into a string for insertion in the database.
Serialize a class’s options and slots’ options into a plist
Turn a string into a CLOS object.
Convert a tuple produced by CL-DBI to a CLOS instance.
The database this class belongs to.
Return the name of a the class, a symbol.
Next: Conditions, Previous: Generic functions, Up: Public Interface [Contents][Index]
sb-mop.
sb-mop.
sb-mop.
sb-mop.
sb-mop.
Next: Classes, Previous: Standalone methods, Up: Public Interface [Contents][Index]
An error in the configuration.
key.
Table has no slots.
Orizuru-Orm was not configured.
Error in a query.
Error in a query set.
Error in a query set related to foreign reference.
Next: Types, Previous: Conditions, Up: Public Interface [Contents][Index]
A database.
A keyword representing the database type (:postgres only atm).
common-lisp.
keyword
:type
This slot is read-only.
The database name.
string
:name
This slot is read-only.
The connection specification.
:conn-spec
This slot is read-only.
The underlying connection object.
:connection
A table metaclass.
standard-class.
Whether the class corresponds to an SQL table or not.
:abstractp
This slot is read-only.
Whether the class should be built only when explicitly calling build.
:deferredp
This slot is read-only.
The database this class belongs to.
:database
This slot is read-only.
The base class of all table classes.
:and
:operator
:parent
(quote nil)
:children
:*
:columns
Previous: Classes, Up: Public Interface [Contents][Index]
Previous: Public Interface, Up: Definitions [Contents][Index]
Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]
This variable holds Orizuru-Orm’s global configuration.
A map from database names to <database> objects.
Next: Ordinary functions, Previous: Special variables, Up: Internals [Contents][Index]
Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]
If the slot doesn’t have :initarg or :accessor slots, add them.
Give constraints Orizuru-Orm-specific names
Compute the difference between two slot digests. See DIGEST.
Load the ASDF system for the specified database module.
Transform an object into a call to the set= function used by SxQL. Deflation happens here.
Return the pathname to the file containing the migration history for the table ‘table-name‘.
Take a plist like (:col-type ’string :col-null-p t) and remove the prefixes on the keys. Turn ’deftable slot properties’ (:type, :nullp, etc.) into ’table-class slot properties’ (:col-type, :col-null-p, etc.)
helper function to add a child to a query set
To minimize the number of parentheses, both slots and table options come in the same list. This function separates them: Normal slot names are plain old symbols, table options are keywords.
Serialize a list of digests.
Toggle INDEX pseudo-constraint.
Toggle NULL constraint.
Toggle PRIMARY KEY constraint.
Toggle UNIQUE constraint.
Immediately after configuration, iterate over the list of defined databases, validating configuration parameters, creating their corresponding <database> instances, and setting the value of *default-db*.
Next: Conditions, Previous: Ordinary functions, Up: Internals [Contents][Index]
The database this class belongs to.
Process a plist returned by CL-DBI into a format that can be accepted by make-instance. Inflation happens here.
The connection specification.
automatically generated reader method
automatically generated writer method
automatically generated reader method
automatically generated writer method
key.
automatically generated reader method
automatically generated writer method
Impure version of add-filter
Impure version of add-table
automatically generated reader method
automatically generated writer method
automatically generated reader method
automatically generated writer method
automatically generated reader method
automatically generated writer method
automatically generated reader method
automatically generated writer method
text.
Next: Classes, Previous: Generic functions, Up: Internals [Contents][Index]
condition.
text.
Next: Types, Previous: Conditions, Up: Internals [Contents][Index]
:col-type
:col-null-p
This slot is read-only.
:col-unique-p
This slot is read-only.
:col-primary-p
This slot is read-only.
:col-index-p
This slot is read-only.
:col-foreign
This slot is read-only.
:col-autoincrement-p
This slot is read-only.
Previous: Definitions, Up: The orizuru-orm Reference Manual [Contents][Index]
| Jump to: | %
(
-
A B C D E F G I J K L M N O P Q R S T U V W |
|---|
| Jump to: | %
(
-
A B C D E F G I J K L M N O P Q R S T U V W |
|---|
Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]
| Jump to: | *
+
A C D J K L N O P R S T |
|---|
| Jump to: | *
+
A C D J K L N O P R S T |
|---|
| Jump to: | <
B C D E F I J L M N O P Q S T U V |
|---|
| Jump to: | <
B C D E F I J L M N O P Q S T U V |
|---|