The sxql Reference Manual

2.1 sxql

A SQL generator

Author

Eitaro Fukamachi

License

BSD 3-Clause

Long Description

# SxQL - An SQL generator.

[](https://travis-ci.org/fukamachi/sxql)

## Usage

“‘common-lisp
(select (:id :name :sex)
(from (:as :person :p))
(where (:and (:>= :age 18)
(:< :age 65)))
(order-by (:desc :age)))
;=> #<SXQL-STATEMENT: SELECT id, name, sex FROM person AS p WHERE ((age >= 18) AND (age < 65)) ORDER BY age DESC>

(yield *)

;=> "SELECT id, name, sex FROM person AS p WHERE ((age >= ?) AND (age < ?)) ORDER BY age DESC"
; (18 65)

(sql-compile **)
;=> #<SXQL-COMPILED: SELECT id, name, sex FROM person AS p WHERE ((age >= ?) AND (age < ?)) ORDER BY age DESC [18, 65]>

(union-queries * (select (:id :name :sex) (from ’(:as animal a))))
;=> #<SXQL-OP: (SELECT id, name, sex FROM (person AS p) WHERE ((age >= ?) AND (age < ?)) ORDER BY age DESC) UNION (SELECT id, name, sex FROM (animal AS a))>

(yield *)
;=> "(SELECT id, name, sex FROM (person AS p) WHERE ((age >= ?) AND (age < ?)) ORDER BY age DESC) UNION (SELECT id, name, sex FROM (animal AS a))"
; (18 65)
“‘

## SQL Statements

### select (field &body clauses)

Creates a SELECT query. It takes a field (or a list of fields) and SQL Clauses.

“‘common-lisp
(select ((:+ 1 1)))
;=> #<SXQL-STATEMENT: SELECT (1 + 1)>

(select :name
(from :person)
(where (:> :age 20)))
;=> #<SXQL-STATEMENT: SELECT name FROM person WHERE (age > 20)>

(select (:id :name)
(from (:as :person :p))
(left-join :person_config :on (:= :person.config_id :person_config.id))
(where (:and (:> :age 20)
(:<= :age 65)))
(order-by :age)
(limit 5))
;=> #<SXQL-STATEMENT: SELECT id, name FROM (person AS p) LEFT JOIN person_config ON (person.config_id = person_config.id) WHERE ((age > 20) AND (age <= 65)) ORDER BY age LIMIT 5>

(select (:sex (:count :*)) (from :person) (group-by :sex))
;=> #<SXQL-STATEMENT: SELECT sex, COUNT(*) FROM person GROUP BY sex>

(select (:sex (:as (:count :*) :num))
(from :person)
(group-by :sex)
(order-by (:desc :num)))
;=> #<SXQL-STATEMENT: SELECT sex, COUNT(*) AS num FROM person GROUP BY sex ORDER BY num DESC>
“‘

### insert-into (table &body clauses)

“‘common-lisp
(insert-into :person
(set= :sex "male"
:age 25
:name "Eitaro Fukamachi"))
;=> #<SXQL-STATEMENT: INSERT INTO person SET sex = ’male’, age = 25, name = ’Eitaro Fukamachi’>

(insert-into :person
(:sex :age :name)
(list "male" 25 "Eitaro Fukamachi"))
;=> #<SXQL-STATEMENT: INSERT INTO person SET sex = ’male’, age = 25, name = ’Eitaro Fukamachi’>

(insert-into :person
(:sex :age :name)
(list (list "male" 25 "Eitaro Fukamachi")
(list "female" 16 "Miku Hatsune")))
;=> #<SXQL-STATEMENT: INSERT INTO person (sex, age, name) VALUES (’male’, 25, ’Eitaro Fukamachi’), (’female’, 16, ’Miku Hatsune’)>

(insert-into :users
(set= :name "Jack"
:jinbei-size "small")
(returning :id))
;=> #<SXQL-STATEMENT: INSERT INTO ‘users‘ (‘name‘, ‘jinbei-size‘) VALUES (’Jack’, ’small’) RETURNING ‘id‘>

(insert-into :person
(:id :name)
(select (:id :name)
(from :person_tmp)))
;=> #<SXQL-STATEMENT: INSERT INTO person (id, name) SELECT id, name FROM person_tmp>
“‘

### update (table &body clauses)

“‘common-lisp
(update :person
(set= :age 26)
(where (:like :name "Eitaro %")))
;=> #<SXQL-STATEMENT: UPDATE person SET age = 26 WHERE (name LIKE ’Eitaro %’)>
“‘

### delete-from (table &body clauses)

“‘common-lisp
(delete-from :person
(where (:= :name "Eitaro Fukamachi")))
;=> #<SXQL-STATEMENT: DELETE FROM person WHERE (name = ’Eitaro Fukamachi’)>
“‘

### union-queies (&rest statements)

“‘common-lisp
(union-queries
(select (:name :birthday) (from :fulltime))
(select (:name :birthday) (from :parttime)))
;=> #<SXQL-OP: (SELECT name, birthday FROM fulltime) UNION (SELECT name, birthday FROM parttime)>
“‘

### union-all-queries (&rest statements)

“‘common-lisp
(union-all-queries
(select (:name :birthday) (from :fulltime))
(select (:name :birthday) (from :parttime)))
;=> #<SXQL-OP: (SELECT name, birthday FROM fulltime) UNION ALL (SELECT name, birthday FROM parttime)>
“‘

### create-table (table column-definitions &body options)

“‘common-lisp
(create-table :enemy
((name :type ’string
:primary-key t)
(age :type ’integer
:not-null t)
(address :type ’text
:not-null nil)
(fatal_weakness :type ’text
:not-null t
:default "None")
(identifying_color :type ’(:char 20)
:unique t)))
;=> #<SXQL-STATEMENT: CREATE TABLE enemy (name STRING PRIMARY KEY, age INTEGER NOT NULL, address TEXT, fatal_weakness TEXT NOT NULL DEFAULT ’None’, identifying_color CHAR(20) UNIQUE)>

(yield *)
;=> "CREATE TABLE enemy (name STRING PRIMARY KEY, age INTEGER NOT NULL, address TEXT, fatal_weakness TEXT NOT NULL DEFAULT ?, identifying_color CHAR(20) UNIQUE)"
; ("None")

(create-table (:enemy :if-not-exists t)
((name :type ’string
:primary-key t)
(age :type ’integer
:not-null t)
(address :type ’text
:not-null nil)
(fatal_weakness :type ’text
:not-null t
:default "None")
(identifying_color :type ’(:char 20)
:unique t)))
;=> #<SXQL-STATEMENT: CREATE TABLE IF NOT EXISTS enemy (name STRING PRIMARY KEY, age INTEGER NOT NULL, address TEXT, fatal_weakness TEXT NOT NULL DEFAULT ’None’, identifying_color CHAR(20) UNIQUE)> “‘

### drop-table (table &key if-exists)

“‘common-lisp
(drop-table :enemy)
;=> #<SXQL-STATEMENT: DROP TABLE enemy>

(drop-table :enemy :if-exists t)
;=> #<SXQL-STATEMENT: DROP TABLE IF EXISTS enemy>
“‘

### alter-table (table &body clauses)

“‘common-lisp
(alter-table :tweet
(add-column :id :type ’bigint :primary-key t :auto-increment t :first t)
(add-column :updated_at :type ’timestamp))
;=> #<SXQL-STATEMENT: ALTER TABLE tweet ADD COLUMN id BIGINT AUTO_INCREMENT PRIMARY KEY FIRST, ADD COLUMN updated_at TIMESTAMP>
“‘

### create-index (index-name &key unique using on)

“‘common-lisp
(create-index "index_name"
:unique t
:using :btee
:on ’(:table :column1 :column2))
;=> #<SXQL-STATEMENT: CREATE UNIQUE INDEX index_name USING BTEE ON table (column1, column2)>
“‘

### drop-index (index-name &key if-exists on)

“‘common-lisp
(drop-index "index_name" :if-exists t :on :person)
;=> #<SXQL-STATEMENT: DROP INDEX IF EXISTS index_name ON person>
“‘

## SQL Clauses

### fields

“‘common-lisp
(fields :id)
;=> #<SXQL-CLAUSE: id>

(fields (:count :id))
;=> #<SXQL-CLAUSE: COUNT(id)>

(fields :id (:sum :amount))
;=> #<SXQL-CLAUSE: id, SUM(amount)>
“‘

### from

“‘common-lisp
(from :person)
;=> #<SXQL-CLAUSE: FROM person>

(from :person :person_config)
;=> #<SXQL-CLAUSE: FROM person, person_config>

(from (select :* (from :person) (where (:= :is_active 1))))
;=> #<SXQL-CLAUSE: FROM (SELECT * FROM person WHERE (is_active = 1))>
“‘

### where

“‘common-lisp
(where (:and (:> :age 20) (:<= :age 65)))
;=> #<SXQL-CLAUSE: WHERE ((age > 20) AND (age <= 65))>

(yield *)
;=> "WHERE ((age > ?) AND (age <= ?))"
; (20 65)
“‘

### order-by

“‘common-lisp
(order-by :age)
;=> #<SXQL-CLAUSE: ORDER BY age>

(order-by :age (:desc :id))
;=> #<SXQL-CLAUSE: ORDER BY age, id DESC>
; NIL
“‘

### group-by

“‘common-lisp
(group-by :sex)
;=> #<SXQL-CLAUSE: GROUP BY sex>
“‘

### having

“‘common-lisp
(having (:>= (:sum :hoge) 88))
;=> #<SXQL-CLAUSE: HAVING (SUM(‘hoge‘) >= 88)>
“‘

### returning

“‘common-lisp
(returning :id)
;=> #<SXQL-CLAUSE: RETURNING ‘id‘>
“‘

### limit

“‘common-lisp
(limit 10)
;=> #<SXQL-CLAUSE: LIMIT 10>

(limit 0 10)
;=> #<SXQL-CLAUSE: LIMIT 0, 10>

(yield *)
;=> "LIMIT 0, 10"
; NIL
“‘

### offset

“‘common-lisp
(offset 0)
;=> #<SXQL-CLAUSE: OFFSET 0>

(yield *)
;=> "OFFSET 0"
; NIL
“‘

### inner-join, left-join, right-join, full-join

“‘common-lisp
(inner-join :person_config :on (:= :person.config_id :person_config.id))
;=> #<SXQL-CLAUSE: INNER JOIN person_config ON (person.config_id = person_config.id)>

(left-join :person_config :on (:= :person.config_id :person_config.id))
;=> #<SXQL-CLAUSE: LEFT JOIN person_config ON (person.config_id = person_config.id)>

(left-join :person_config :using :config_id)
;=> #<SXQL-CLAUSE: LEFT JOIN person_config USING config_id>
“‘

### primary-key

“‘common-lisp
(primary-key :id)
;=> #<SXQL-CLAUSE: PRIMARY KEY (id)>

(primary-key ’(:id))
;=> #<SXQL-CLAUSE: PRIMARY KEY (id)>

(primary-key "id_index" ’(:id))
;=> #<SXQL-CLAUSE: PRIMARY KEY ’id_index’ (id)>
“‘

### unique-key

“‘common-lisp
(unique-key ’(:name :country))
;=> #<SXQL-CLAUSE: UNIQUE (name, country)>

(unique-key "name_and_country_index" ’(:name :country))
;=> #<SXQL-CLAUSE: UNIQUE ’name_and_country_index’ (name, country)>
“‘

### index-key

“‘common-lisp
(index-key (:name :country))
;=> #<SXQL-CLAUSE: KEY (name, country)>

(index-key "name_and_country_index" ’(:name :country))
;=> #<SXQL-CLAUSE: KEY ’name_and_country_index’ (name, country)>
“‘

### foreign-key

“‘common-lisp
(foreign-key ’(:project_id) :references ’(:project :id))
;=> #<SXQL-CLAUSE: FOREIGN KEY (project_id) REFERENCES project (id)>

(foreign-key ’(:user_id) :references ’(:user :id) :on-delete :cascade)
;=> #<SXQL-CLAUSE: FOREIGN KEY (user_id) REFERENCES user (id) ON DELETE CASCADE>
“‘

### add-column

“‘common-lisp
(add-column :updated_at :type ’integer :default 0 :not-null t :after :created_at)
;=> #<SXQL-CLAUSE: ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0 AFTER created_at>
“‘

### modify-column

“‘common-lisp
(modify-column :updated_at :type ’datetime :not-null t)
;=> #<SXQL-CLAUSE: MODIFY COLUMN updated_at DATETIME NOT NULL>
“‘

### alter-column

“‘common-lisp
(alter-column :user :type ’(:varchar 64))
;=> #<SXQL-CLAUSE: ALTER COLUMN user TYPE VARCHAR(64)>

(alter-column :id :set-default 1)
;=> #<SXQL-CLAUSE: ALTER COLUMN id SET DEFAULT 1>

(alter-column :id :drop-default t)
;=> #<SXQL-CLAUSE: ALTER COLUMN id DROP DEFAULT>

(alter-column :profile :not-null t)
;=> #<SXQL-CLAUSE: ALTER COLUMN profile SET NOT NULL>
“‘

### change-column

“‘common-lisp
(change-column :updated_at :updated_on)
;=> #<SXQL-CLAUSE: CHANGE COLUMN updated_at updated_on>
“‘

### drop-column

“‘common-lisp
(drop-column :updated_on)
;=> #<SXQL-CLAUSE: DROP COLUMN updated_on>
“‘

### add-primary-key

“‘common-lisp
(add-primary-key :id :name)
;=> #<SXQL-CLAUSE: ADD PRIMARY KEY (id, name)>
“‘

### drop-primary-key

“‘common-lisp
(drop-primary-key)
;=> #<SXQL-CLAUSE: DROP PRIMARY KEY>
“‘

### rename-to

“‘common-lisp
(rename-to :users)
;=> #<SXQL-CLAUSE: RENAME TO ‘users‘>

(alter-table :user
(rename-to :users))
;=> #<SXQL-STATEMENT: ALTER TABLE ‘user‘ RENAME TO ‘users‘>
“‘

### on-duplicate-key-update

Support MySQL’s ‘INSERT ... ON DUPLICATE KEY UPDATE‘ syntax.

“‘common-lisp
(on-duplicate-key-update :age (:+ :age 1))
;=> #<SXQL-CLAUSE: ON DUPLICATE KEY UPDATE ‘age‘ = (‘age‘ + 1)>

(insert-into :person
(set= :sex "male"
:age 25
:name "Eitaro Fukamachi")
(on-duplicate-key-update :age (:+ :age 1)))
;=> #<SXQL-STATEMENT: INSERT INTO ‘person‘ (‘sex‘, ‘age‘, ‘name‘) VALUES (’male’, 25, ’Eitaro Fukamachi’) ON DUPLICATE KEY UPDATE ‘age‘ = (‘age‘ + 1)>
“‘

### on-coflict-do-nothing

Support PostgreSQL’s ‘INSERT ... ON CONFLICT DO NOTHING‘ syntax.

“‘common-lisp
(on-conflict-do-nothing)
;=> #<SXQL-CLAUSE: ON CONFLICT DO NOTHING>

(on-conflict-do-nothing :index_name)
;=> #<SXQL-CLAUSE: ON CONFLICT ON CONSTRAINT index_name DO NOTHING>

(on-conflict-do-nothing ’(:column1 :column2 :column3))
;=> #<SXQL-CLAUSE: ON CONFLICT (column1, column2, column3) DO NOTHING>
“‘

### on-coflict-do-update

Support PostgreSQL’s ‘INSERT ... ON CONFLICT ... DO UPDATE‘ syntax.

“‘common-lisp
(on-conflict-do-update :index_name (set= :x 1 :y 2))
;=> #<SXQL-CLAUSE: ON CONFLICT ON CONSTRAINT index_name DO UPDATE SET x = 1, y = 2>

(on-conflict-do-update ’(:column1 :column2 :column3) (set= :x 1 :y 2))
;=> #<SXQL-CLAUSE: ON CONFLICT (column1, column2, column3) DO UPDATE SET x = 1, y = 2>

(insert-into :person
(set= :sex "male"
:age 25
:name "Eitaro Fukamachi")
(on-conflict-do-update ’(:name)
(set= :age (:+ :age 1))
(where (:< :age 99))))
;=> #<SXQL-STATEMENT: INSERT INTO person (sex, age, name) VALUES (’male’, 25, ’Eitaro Fukamachi’) ON CONFLICT (name) DO UPDATE SET age = (age + 1) WHERE (age < 99)>
“‘

## SQL Operators

* :not
* :is-null, :not-null
* :asc, :desc
* :distinct
* :=, :!=
* :<, :>, :<= :>=
* :a<, :a>
* :as
* :in, :not-in
* :like
* :and, :or
* :+, :-, :* :/ :%
* :raw
* :is-distinct-from, :is-not-distinct-from (Postgres)

## Set a quote character

‘*quote-character*‘ is the character that a table or column name will be quoted with. The default value is NIL (not quote).

“‘common-lisp
(yield (select :* (from ’table)))
;=> "SELECT * FROM table"
; NIL

;; for MySQL
(let ((*quote-character* #\‘))
(yield (select :* (from ’table))))
;=> "SELECT * FROM ‘table‘"
; NIL

;; for PostgreSQL
(let ((*quote-character* #\"))
(yield (select :* (from ’table))))
;=> "SELECT * FROM "table""
; NIL
“‘

## Author

* Eitaro Fukamachi (e.arrows@gmail.com)

## Copyright

Copyright (c) 2013-2014 Eitaro Fukamachi (e.arrows@gmail.com)

# License

Licensed under the BSD 3-Clause License.

Version

0.1.0

Dependencies

• trivia (system).
• iterate (system).
• cl-annot (system).
• trivial-types (system).
• split-sequence (system).
• named-readtables (system).
• alexandria (system).
• cl-package-locks (system).

Source

sxql.asd.

Child Component

src (module).

3.1 sxql/src

Source

sxql.asd.

Parent Component

sxql (system).

Child Components

• sxql.lisp (file).
• compile.lisp (file).
• sql-type.lisp (file).
• operator.lisp (file).
• clause.lisp (file).
• statement.lisp (file).
• composed-statement.lisp (file).
• syntax.lisp (file).
• util.lisp (file).

4.1 Lisp

• sxql/sxql.asd
• sxql/src/sxql.lisp
• sxql/src/compile.lisp
• sxql/src/sql-type.lisp
• sxql/src/operator.lisp
• sxql/src/clause.lisp
• sxql/src/statement.lisp
• sxql/src/composed-statement.lisp
• sxql/src/syntax.lisp
• sxql/src/util.lisp

5.1 sxql.syntax

Source

syntax.lisp.

Use List

common-lisp.

Used By List

• sxql.
• sxql.clause.
• sxql.compile.
• sxql.composed-statement.
• sxql.operator.
• sxql.sql-type.
• sxql.statement.

Public Interface

enable-syntax (macro).

5.2 sxql.composed-statement

Source

composed-statement.lisp.

Use List

• common-lisp.
• iterate.
• sxql.syntax.

Used By List

sxql.

Public Interface

• compose-statements (function).
• composed-statement (structure).

Internals

• *clause-delimiters* (special variable).
• composed-statement-p (function).
• composed-statement-statements (reader).
• (setf composed-statement-statements) (writer).
• copy-composed-statement (function).
• copy-scoped-clause (function).
• make-composed-statement (function).
• make-scoped-clause (function).
• merging-yield (generic function).
• scoped-clause (structure).
• scoped-clause-clause (reader).
• (setf scoped-clause-clause) (writer).
• scoped-clause-p (function).
• scoped-clause-statement (reader).
• (setf scoped-clause-statement) (writer).
• scoped-clause-type (function).
• scoped-merging-yield (function).
• yield-only-contents (generic function).

5.3 sxql.operator

Source

operator.lisp.

Use List

• common-lisp.
• sxql.sql-type.
• sxql.syntax.

Used By List

sxql.clause.

Public Interface

• *inside-select* (special variable).
• *sql-symbol-conversion* (special variable).
• convert-for-sql (generic function).
• detect-and-convert (function).
• find-constructor (function).
• make-op (generic function).

Internals

• !=-op (structure).
• !=-op-left (function).
• (setf !=-op-left) (function).
• !=-op-name (reader).
• (setf !=-op-name) (writer).
• !=-op-p (function).
• !=-op-right (function).
• (setf !=-op-right) (function).
• %-op (structure).
• %-op-expressions (function).
• (setf %-op-expressions) (function).
• %-op-name (reader).
• (setf %-op-name) (writer).
• %-op-p (function).
• *-op (structure).
• *-op-expressions (function).
• (setf *-op-expressions) (function).
• *-op-name (reader).
• (setf *-op-name) (writer).
• *-op-p (function).
• +-op (structure).
• +-op-expressions (function).
• (setf +-op-expressions) (function).
• +-op-name (reader).
• (setf +-op-name) (writer).
• +-op-p (function).
• --op (structure).
• --op-expressions (function).
• (setf --op-expressions) (function).
• --op-name (reader).
• (setf --op-name) (writer).
• --op-p (function).
• /-op (structure).
• /-op-expressions (function).
• (setf /-op-expressions) (function).
• /-op-name (reader).
• (setf /-op-name) (writer).
• /-op-p (function).
• <-op (structure).
• <-op-left (function).
• (setf <-op-left) (function).
• <-op-name (reader).
• (setf <-op-name) (writer).
• <-op-p (function).
• <-op-right (function).
• (setf <-op-right) (function).
• <=-op (structure).
• <=-op-left (function).
• (setf <=-op-left) (function).
• <=-op-name (reader).
• (setf <=-op-name) (writer).
• <=-op-p (function).
• <=-op-right (function).
• (setf <=-op-right) (function).
• =-op (structure).
• =-op-left (function).
• (setf =-op-left) (function).
• =-op-name (reader).
• (setf =-op-name) (writer).
• =-op-p (function).
• =-op-right (function).
• (setf =-op-right) (function).
• >-op (structure).
• >-op-left (function).
• (setf >-op-left) (function).
• >-op-name (reader).
• (setf >-op-name) (writer).
• >-op-p (function).
• >-op-right (function).
• (setf >-op-right) (function).
• >=-op (structure).
• >=-op-left (function).
• (setf >=-op-left) (function).
• >=-op-name (reader).
• (setf >=-op-name) (writer).
• >=-op-p (function).
• >=-op-right (function).
• (setf >=-op-right) (function).
• a<-op (structure).
• a<-op-left (function).
• (setf a<-op-left) (function).
• a<-op-name (reader).
• (setf a<-op-name) (writer).
• a<-op-p (function).
• a<-op-right (function).
• (setf a<-op-right) (function).
• a>-op (structure).
• a>-op-left (function).
• (setf a>-op-left) (function).
• a>-op-name (reader).
• (setf a>-op-name) (writer).
• a>-op-p (function).
• a>-op-right (function).
• (setf a>-op-right) (function).
• and-op (structure).
• and-op-expressions (function).
• (setf and-op-expressions) (function).
• and-op-name (reader).
• (setf and-op-name) (writer).
• and-op-p (function).
• as-op (structure).
• as-op-left (function).
• (setf as-op-left) (function).
• as-op-name (reader).
• (setf as-op-name) (writer).
• as-op-p (function).
• as-op-right (function).
• (setf as-op-right) (function).
• asc-op (structure).
• asc-op-name (reader).
• (setf asc-op-name) (writer).
• asc-op-nulls (function).
• (setf asc-op-nulls) (function).
• asc-op-p (function).
• asc-op-var (function).
• (setf asc-op-var) (function).
• case-op (structure).
• case-op-expressions (function).
• (setf case-op-expressions) (function).
• case-op-name (reader).
• (setf case-op-name) (writer).
• case-op-p (function).
• copy-!=-op (function).
• copy-%-op (function).
• copy-*-op (function).
• copy-+-op (function).
• copy---op (function).
• copy-/-op (function).
• copy-<-op (function).
• copy-<=-op (function).
• copy-=-op (function).
• copy->-op (function).
• copy->=-op (function).
• copy-a<-op (function).
• copy-a>-op (function).
• copy-and-op (function).
• copy-as-op (function).
• copy-asc-op (function).
• copy-case-op (function).
• copy-desc-op (function).
• copy-distinct-op (function).
• copy-else-op (function).
• copy-in-op (function).
• copy-is-distinct-from-op (function).
• copy-is-not-distinct-from-op (function).
• copy-is-null-op (function).
• copy-like-op (function).
• copy-not-in-op (function).
• copy-not-null-op (function).
• copy-not-op (function).
• copy-on-op (function).
• copy-or-op (function).
• copy-order-op (function).
• copy-raw-op (function).
• copy-similar-to-op (function).
• copy-splicing-raw-op (function).
• copy-union-all-op (function).
• copy-union-op (function).
• copy-when-op (function).
• define-op (macro).
• desc-op (structure).
• desc-op-name (reader).
• (setf desc-op-name) (writer).
• desc-op-nulls (function).
• (setf desc-op-nulls) (function).
• desc-op-p (function).
• desc-op-var (function).
• (setf desc-op-var) (function).
• distinct-op (structure).
• distinct-op-name (reader).
• (setf distinct-op-name) (writer).
• distinct-op-p (function).
• distinct-op-var (function).
• (setf distinct-op-var) (function).
• else-op (structure).
• else-op-name (reader).
• (setf else-op-name) (writer).
• else-op-p (function).
• else-op-var (function).
• (setf else-op-var) (function).
• find-make-op (function).
• has-lower-case-letters-p (function).
• in-op (structure).
• in-op-left (function).
• (setf in-op-left) (function).
• in-op-name (reader).
• (setf in-op-name) (writer).
• in-op-p (function).
• in-op-right (function).
• (setf in-op-right) (function).
• is-distinct-from-op (structure).
• is-distinct-from-op-left (function).
• (setf is-distinct-from-op-left) (function).
• is-distinct-from-op-name (reader).
• (setf is-distinct-from-op-name) (writer).
• is-distinct-from-op-p (function).
• is-distinct-from-op-right (function).
• (setf is-distinct-from-op-right) (function).
• is-not-distinct-from-op (structure).
• is-not-distinct-from-op-left (function).
• (setf is-not-distinct-from-op-left) (function).
• is-not-distinct-from-op-name (reader).
• (setf is-not-distinct-from-op-name) (writer).
• is-not-distinct-from-op-p (function).
• is-not-distinct-from-op-right (function).
• (setf is-not-distinct-from-op-right) (function).
• is-null-op (structure).
• is-null-op-name (reader).
• (setf is-null-op-name) (writer).
• is-null-op-p (function).
• is-null-op-var (function).
• (setf is-null-op-var) (function).
• like-op (structure).
• like-op-left (function).
• (setf like-op-left) (function).
• like-op-name (reader).
• (setf like-op-name) (writer).
• like-op-p (function).
• like-op-right (function).
• (setf like-op-right) (function).
• make-!=-op (function).
• make-%-op (function).
• make-*-op (function).
• make-+-op (function).
• make---op (function).
• make-/-op (function).
• make-<-op (function).
• make-<=-op (function).
• make-=-op (function).
• make->-op (function).
• make->=-op (function).
• make-a<-op (function).
• make-a>-op (function).
• make-and-op (function).
• make-as-op (function).
• make-asc-op (function).
• make-case-op (function).
• make-desc-op (function).
• make-distinct-op (function).
• make-else-op (function).
• make-in-op (function).
• make-is-distinct-from-op (function).
• make-is-not-distinct-from-op (function).
• make-is-null-op (function).
• make-like-op (function).
• make-not-in-op (function).
• make-not-null-op (function).
• make-not-op (function).
• make-on-op (function).
• make-or-op (function).
• make-order-op (function).
• make-raw-op (function).
• make-similar-to-op (function).
• make-splicing-raw-op (function).
• make-union-all-op (function).
• make-union-op (function).
• make-when-op (function).
• not-in-op (structure).
• not-in-op-left (function).
• (setf not-in-op-left) (function).
• not-in-op-name (reader).
• (setf not-in-op-name) (writer).
• not-in-op-p (function).
• not-in-op-right (function).
• (setf not-in-op-right) (function).
• not-null-op (structure).
• not-null-op-name (reader).
• (setf not-null-op-name) (writer).
• not-null-op-p (function).
• not-null-op-var (function).
• (setf not-null-op-var) (function).
• not-op (structure).
• not-op-name (reader).
• (setf not-op-name) (writer).
• not-op-p (function).
• not-op-var (function).
• (setf not-op-var) (function).
• on-op (structure).
• on-op-name (reader).
• (setf on-op-name) (writer).
• on-op-p (function).
• on-op-var (reader).
• (setf on-op-var) (writer).
• or-op (structure).
• or-op-expressions (function).
• (setf or-op-expressions) (function).
• or-op-name (reader).
• (setf or-op-name) (writer).
• or-op-p (function).
• order-op (structure).
• order-op-name (reader).
• (setf order-op-name) (writer).
• order-op-nulls (reader).
• (setf order-op-nulls) (writer).
• order-op-p (function).
• order-op-var (function).
• (setf order-op-var) (function).
• raw-op (structure).
• raw-op-name (reader).
• (setf raw-op-name) (writer).
• raw-op-p (function).
• raw-op-var (reader).
• (setf raw-op-var) (writer).
• similar-to-op (structure).
• similar-to-op-left (function).
• (setf similar-to-op-left) (function).
• similar-to-op-name (reader).
• (setf similar-to-op-name) (writer).
• similar-to-op-p (function).
• similar-to-op-right (function).
• (setf similar-to-op-right) (function).
• splicing-raw-op (structure).
• splicing-raw-op-name (function).
• (setf splicing-raw-op-name) (function).
• splicing-raw-op-p (function).
• splicing-raw-op-var (function).
• (setf splicing-raw-op-var) (function).
• union-all-op (structure).
• union-all-op-expressions (function).
• (setf union-all-op-expressions) (function).
• union-all-op-name (reader).
• (setf union-all-op-name) (writer).
• union-all-op-p (function).
• union-op (structure).
• union-op-expressions (function).
• (setf union-op-expressions) (function).
• union-op-name (reader).
• (setf union-op-name) (writer).
• union-op-p (function).
• when-op (structure).
• when-op-left (function).
• (setf when-op-left) (function).
• when-op-name (reader).
• (setf when-op-name) (writer).
• when-op-p (function).
• when-op-right (function).
• (setf when-op-right) (function).
• yield-for-union-ops (macro).

5.4 sxql.sql-type

Source

sql-type.lisp.

Use List

• cl-annot.class.
• common-lisp.
• split-sequence.
• sxql.syntax.
• trivial-types.

Used By List

• sxql.clause.
• sxql.compile.
• sxql.operator.
• sxql.statement.

Public Interface

• *quote-character* (special variable).
• *use-placeholder* (special variable).
• children (slot).
• conjunctive-op (structure).
• expression-clause (structure).
• expression-list-clause (structure).
• function-op (structure).
• infix-list-op (structure).
• infix-op (structure).
• infix-splicing-op (structure).
• make-conjunctive-op (function).
• make-function-op (function).
• make-infix-list-op (function).
• make-infix-op (function).
• make-infix-splicing-op (function).
• make-sql-column-type (function).
• make-sql-expression-list (function).
• make-sql-keyword (function).
• make-sql-list (function).
• make-sql-splicing-expression-list (function).
• make-sql-splicing-list (function).
• make-sql-symbol (function).
• make-sql-symbol* (function).
• make-sql-variable (function).
• make-type-keyword (function).
• make-unary-op (function).
• make-unary-splicing-op (function).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• name (slot).
• sql-atom (structure).
• sql-clause (structure).
• sql-clause-list (type).
• sql-column-type (structure).
• sql-composed-statement (structure).
• sql-composed-statement-children (reader).
• (setf sql-composed-statement-children) (writer).
• sql-expression (type).
• sql-expression-list (structure).
• sql-expression-list-p (function).
• sql-keyword (structure).
• sql-list (structure).
• sql-list-elements (reader).
• (setf sql-list-elements) (writer).
• sql-op (structure).
• sql-splicing-expression-list (structure).
• sql-statement (structure).
• sql-statement-name (reader).
• (setf sql-statement-name) (writer).
• sql-symbol (structure).
• sql-variable (structure).
• sql-variable-value (reader).
• (setf sql-variable-value) (writer).
• statement (slot).
• statement-clause (structure).
• unary-op (structure).
• unary-postfix-op (structure).
• unary-splicing-op (structure).
• var (slot).
• var (slot).
• with-table-name (macro).
• with-yield-binds (macro).
• yield (generic function).

Internals

• %make-sql-symbol (function).
• *bind-values* (special variable).
• *inside-function-op* (special variable).
• *table-name-scope* (special variable).
• *use-global-bind-values* (special variable).
• conjunctive-op-expressions (reader).
• (setf conjunctive-op-expressions) (writer).
• conjunctive-op-name (function).
• (setf conjunctive-op-name) (function).
• conjunctive-op-p (function).
• copy-conjunctive-op (function).
• copy-expression-clause (function).
• copy-expression-list-clause (function).
• copy-function-op (function).
• copy-infix-list-op (function).
• copy-infix-op (function).
• copy-infix-splicing-op (function).
• copy-sql-atom (function).
• copy-sql-clause (function).
• copy-sql-column-type (function).
• copy-sql-composed-statement (function).
• copy-sql-expression-list (function).
• copy-sql-keyword (function).
• copy-sql-list (function).
• copy-sql-op (function).
• copy-sql-splicing-expression-list (function).
• copy-sql-splicing-list (function).
• copy-sql-statement (function).
• copy-sql-symbol (function).
• copy-sql-variable (function).
• copy-statement-clause (function).
• copy-unary-op (function).
• copy-unary-postfix-op (function).
• copy-unary-splicing-op (function).
• expression-clause-expression (reader).
• (setf expression-clause-expression) (writer).
• expression-clause-name (function).
• (setf expression-clause-name) (function).
• expression-clause-p (function).
• expression-list-clause-expressions (reader).
• (setf expression-list-clause-expressions) (writer).
• expression-list-clause-name (function).
• (setf expression-list-clause-name) (function).
• expression-list-clause-p (function).
• function-op-expressions (function).
• (setf function-op-expressions) (function).
• function-op-name (function).
• (setf function-op-name) (function).
• function-op-p (function).
• infix-list-op-left (reader).
• (setf infix-list-op-left) (writer).
• infix-list-op-name (function).
• (setf infix-list-op-name) (function).
• infix-list-op-p (function).
• infix-list-op-right (reader).
• (setf infix-list-op-right) (writer).
• infix-op-left (reader).
• (setf infix-op-left) (writer).
• infix-op-name (function).
• (setf infix-op-name) (function).
• infix-op-p (function).
• infix-op-right (reader).
• (setf infix-op-right) (writer).
• infix-splicing-op-left (function).
• (setf infix-splicing-op-left) (function).
• infix-splicing-op-name (function).
• (setf infix-splicing-op-name) (function).
• infix-splicing-op-p (function).
• infix-splicing-op-right (function).
• (setf infix-splicing-op-right) (function).
• make-expression-clause (function).
• make-expression-list-clause (function).
• make-sql-atom (function).
• make-sql-clause (function).
• make-sql-composed-statement (function).
• make-sql-op (function).
• make-sql-statement (function).
• make-statement-clause (function).
• make-unary-postfix-op (function).
• sql-all-type (type).
• sql-atom-p (function).
• sql-clause-list-p (function).
• sql-clause-name (reader).
• (setf sql-clause-name) (writer).
• sql-clause-p (function).
• sql-column-type-args (reader).
• (setf sql-column-type-args) (writer).
• sql-column-type-attrs (reader).
• (setf sql-column-type-attrs) (writer).
• sql-column-type-name (reader).
• (setf sql-column-type-name) (writer).
• sql-column-type-p (function).
• sql-composed-statement-name (function).
• (setf sql-composed-statement-name) (function).
• sql-composed-statement-p (function).
• sql-expression-list-elements (reader).
• (setf sql-expression-list-elements) (writer).
• sql-expression-p (function).
• sql-keyword-name (reader).
• (setf sql-keyword-name) (writer).
• sql-keyword-p (function).
• sql-list-p (function).
• sql-op-name (reader).
• (setf sql-op-name) (writer).
• sql-op-p (function).
• sql-splicing-expression-list-elements (function).
• (setf sql-splicing-expression-list-elements) (function).
• sql-splicing-expression-list-p (function).
• sql-splicing-list (structure).
• sql-splicing-list-elements (function).
• (setf sql-splicing-list-elements) (function).
• sql-splicing-list-p (function).
• sql-statement-list-p (function).
• sql-statement-p (function).
• sql-symbol-name (reader).
• (setf sql-symbol-name) (writer).
• sql-symbol-p (function).
• sql-symbol-tokens (reader).
• (setf sql-symbol-tokens) (writer).
• sql-variable-p (function).
• statement-clause-name (function).
• (setf statement-clause-name) (function).
• statement-clause-p (function).
• statement-clause-statement (reader).
• (setf statement-clause-statement) (writer).
• unary-op-name (function).
• (setf unary-op-name) (function).
• unary-op-p (function).
• unary-op-var (reader).
• (setf unary-op-var) (writer).
• unary-postfix-op-name (function).
• (setf unary-postfix-op-name) (function).
• unary-postfix-op-p (function).
• unary-postfix-op-var (function).
• (setf unary-postfix-op-var) (function).
• unary-splicing-op-name (function).
• (setf unary-splicing-op-name) (function).
• unary-splicing-op-p (function).
• unary-splicing-op-var (function).
• (setf unary-splicing-op-var) (function).

5.5 sxql.statement

Source

statement.lisp.

Use List

• cl-annot.class.
• common-lisp.
• iterate.
• sxql.sql-type.
• sxql.syntax.

Used By List

sxql.

Public Interface

• add-child (generic function).
• alter-table-statement (structure).
• compute-select-statement-children (function).
• create-index-statement (structure).
• create-table-statement (structure).
• delete-from-statement (structure).
• drop-index-statement (structure).
• drop-table-statement (structure).
• explain-statement (structure).
• insert-into-statement (structure).
• make-statement (generic function).
• merge-statements (function).
• pragma-statement (structure).
• select-statement (structure).
• select-statement-clause-order (reader).
• (setf select-statement-clause-order) (writer).
• select-statement-fields-clause (reader).
• (setf select-statement-fields-clause) (writer).
• select-statement-from-clause (reader).
• (setf select-statement-from-clause) (writer).
• select-statement-group-by-clause (reader).
• (setf select-statement-group-by-clause) (writer).
• select-statement-having-clause (reader).
• (setf select-statement-having-clause) (writer).
• select-statement-join-clause (reader).
• (setf select-statement-join-clause) (writer).
• select-statement-limit-clause (reader).
• (setf select-statement-limit-clause) (writer).
• select-statement-offset-clause (reader).
• (setf select-statement-offset-clause) (writer).
• select-statement-order-by-clause (reader).
• (setf select-statement-order-by-clause) (writer).
• select-statement-returning-clause (reader).
• (setf select-statement-returning-clause) (writer).
• select-statement-table-name (function).
• select-statement-updatability-clause (reader).
• (setf select-statement-updatability-clause) (writer).
• select-statement-where-clause (reader).
• (setf select-statement-where-clause) (writer).
• sort-clause-types (function).
• update-statement (structure).

Internals

• *clause-priority* (special variable).
• alter-table-statement-children (reader).
• (setf alter-table-statement-children) (writer).
• alter-table-statement-name (reader).
• (setf alter-table-statement-name) (writer).
• alter-table-statement-p (function).
• alter-table-statement-table (reader).
• (setf alter-table-statement-table) (writer).
• copy-alter-table-statement (function).
• copy-create-index-statement (function).
• copy-create-table-statement (function).
• copy-delete-from-statement (function).
• copy-drop-index-statement (function).
• copy-drop-table-statement (function).
• copy-explain-statement (function).
• copy-insert-into-statement (function).
• copy-pragma-statement (function).
• copy-select-statement (function).
• copy-update-statement (function).
• create-index-statement-columns (reader).
• (setf create-index-statement-columns) (writer).
• create-index-statement-if-not-exists (reader).
• (setf create-index-statement-if-not-exists) (writer).
• create-index-statement-index-name (reader).
• (setf create-index-statement-index-name) (writer).
• create-index-statement-name (reader).
• (setf create-index-statement-name) (writer).
• create-index-statement-p (function).
• create-index-statement-table-name (reader).
• (setf create-index-statement-table-name) (writer).
• create-index-statement-unique (reader).
• (setf create-index-statement-unique) (writer).
• create-index-statement-using (reader).
• (setf create-index-statement-using) (writer).
• create-table-statement-children (function).
• (setf create-table-statement-children) (function).
• create-table-statement-if-not-exists (reader).
• (setf create-table-statement-if-not-exists) (writer).
• create-table-statement-name (reader).
• (setf create-table-statement-name) (writer).
• create-table-statement-p (function).
• create-table-statement-table (reader).
• (setf create-table-statement-table) (writer).
• delete-from-statement-children (function).
• (setf delete-from-statement-children) (function).
• delete-from-statement-name (reader).
• (setf delete-from-statement-name) (writer).
• delete-from-statement-p (function).
• drop-index-statement-if-exists (reader).
• (setf drop-index-statement-if-exists) (writer).
• drop-index-statement-index-name (reader).
• (setf drop-index-statement-index-name) (writer).
• drop-index-statement-name (reader).
• (setf drop-index-statement-name) (writer).
• drop-index-statement-on (reader).
• (setf drop-index-statement-on) (writer).
• drop-index-statement-p (function).
• drop-table-statement-if-exists (reader).
• (setf drop-table-statement-if-exists) (writer).
• drop-table-statement-name (reader).
• (setf drop-table-statement-name) (writer).
• drop-table-statement-p (function).
• drop-table-statement-table (reader).
• (setf drop-table-statement-table) (writer).
• explain-statement-analyze (reader).
• (setf explain-statement-analyze) (writer).
• explain-statement-name (reader).
• (setf explain-statement-name) (writer).
• explain-statement-p (function).
• explain-statement-statement (reader).
• (setf explain-statement-statement) (writer).
• explain-statement-verbose (reader).
• (setf explain-statement-verbose) (writer).
• find-make-statement (function).
• insert-into-statement-children (function).
• (setf insert-into-statement-children) (function).
• insert-into-statement-name (reader).
• (setf insert-into-statement-name) (writer).
• insert-into-statement-p (function).
• make-alter-table-statement (function).
• make-create-index-statement (function).
• make-create-table-statement (function).
• make-delete-from-statement (function).
• make-drop-index-statement (function).
• make-drop-table-statement (function).
• make-explain-statement (function).
• make-insert-into-statement (function).
• make-pragma-statement (function).
• make-select-statement (function).
• make-update-statement (function).
• multiple-allowed-clause (type).
• pragma-statement-name (reader).
• (setf pragma-statement-name) (writer).
• pragma-statement-p (function).
• pragma-statement-pragma-name (reader).
• (setf pragma-statement-pragma-name) (writer).
• pragma-statement-value (reader).
• (setf pragma-statement-value) (writer).
• select-statement-children (function).
• (setf select-statement-children) (function).
• select-statement-name (reader).
• (setf select-statement-name) (writer).
• select-statement-p (function).
• update-statement-children (function).
• (setf update-statement-children) (function).
• update-statement-name (reader).
• (setf update-statement-name) (writer).
• update-statement-p (function).

5.6 sxql.util

Source

util.lisp.

Use List

• common-lisp.
• iterate.

Public Interface

• group-by (function).
• subdivide (function).

5.7 sxql.clause

Source

clause.lisp.

Use List

• cl-annot.class.
• common-lisp.
• iterate.
• sxql.operator.
• sxql.sql-type.
• sxql.syntax.
• trivial-types.

Used By List

sxql.

Public Interface

• *inside-insert-into* (special variable).
• column-definition-clause (structure).
• compose-where-clauses (function).
• fields-clause (slot).
• fields-clause (structure).
• foreign-key-clause (structure).
• from-clause (slot).
• from-clause (structure).
• from-clause-table-name (function).
• group-by-clause (slot).
• group-by-clause (structure).
• having-clause (slot).
• having-clause (structure).
• join-clause (slot).
• join-clause (structure).
• key-clause (structure).
• limit-clause (slot).
• limit-clause (structure).
• make-clause (generic function).
• make-column-definition-clause (function).
• offset-clause (slot).
• offset-clause (structure).
• order-by-clause (slot).
• order-by-clause (structure).
• primary-key-clause (structure).
• references-clause (structure).
• returning-clause (slot).
• returning-clause (structure).
• set=-clause (structure).
• unique-key-clause (structure).
• updatability-clause (slot).
• updatability-clause (structure).
• values-clause (structure).
• where-clause (slot).
• where-clause (structure).

Internals

• %make-column-definition-clause (function).
• %make-on-conflict-do-update-clause (function).
• %make-on-duplicate-key-update-clause (function).
• %make-set=-clause (function).
• add-column-clause (structure).
• add-column-clause-after (function).
• (setf add-column-clause-after) (function).
• add-column-clause-column-definition (function).
• (setf add-column-clause-column-definition) (function).
• add-column-clause-expression (function).
• (setf add-column-clause-expression) (function).
• add-column-clause-first (function).
• (setf add-column-clause-first) (function).
• add-column-clause-name (reader).
• (setf add-column-clause-name) (writer).
• add-column-clause-p (function).
• add-primary-key-clause (structure).
• add-primary-key-clause-expression (function).
• (setf add-primary-key-clause-expression) (function).
• add-primary-key-clause-name (reader).
• (setf add-primary-key-clause-name) (writer).
• add-primary-key-clause-p (function).
• alter-column-clause (structure).
• alter-column-clause-column-name (reader).
• (setf alter-column-clause-column-name) (writer).
• alter-column-clause-drop-default (reader).
• (setf alter-column-clause-drop-default) (writer).
• alter-column-clause-name (reader).
• (setf alter-column-clause-name) (writer).
• alter-column-clause-not-null (reader).
• (setf alter-column-clause-not-null) (writer).
• alter-column-clause-p (function).
• alter-column-clause-set-default (reader).
• (setf alter-column-clause-set-default) (writer).
• alter-column-clause-type (reader).
• (setf alter-column-clause-type) (writer).
• change-column-clause (structure).
• change-column-clause-after (function).
• (setf change-column-clause-after) (function).
• change-column-clause-column-definition (function).
• (setf change-column-clause-column-definition) (function).
• change-column-clause-expression (function).
• (setf change-column-clause-expression) (function).
• change-column-clause-first (function).
• (setf change-column-clause-first) (function).
• change-column-clause-name (reader).
• (setf change-column-clause-name) (writer).
• change-column-clause-p (function).
• column-definition-clause-auto-increment (reader).
• (setf column-definition-clause-auto-increment) (writer).
• column-definition-clause-autoincrement (reader).
• (setf column-definition-clause-autoincrement) (writer).
• column-definition-clause-column-name (reader).
• (setf column-definition-clause-column-name) (writer).
• column-definition-clause-default (reader).
• (setf column-definition-clause-default) (writer).
• column-definition-clause-name (function).
• (setf column-definition-clause-name) (function).
• column-definition-clause-not-null (reader).
• (setf column-definition-clause-not-null) (writer).
• column-definition-clause-p (function).
• column-definition-clause-primary-key (reader).
• (setf column-definition-clause-primary-key) (writer).
• column-definition-clause-type (reader).
• (setf column-definition-clause-type) (writer).
• column-definition-clause-unique (reader).
• (setf column-definition-clause-unique) (writer).
• column-modifier-clause (structure).
• column-modifier-clause-after (reader).
• (setf column-modifier-clause-after) (writer).
• column-modifier-clause-column-definition (reader).
• (setf column-modifier-clause-column-definition) (writer).
• column-modifier-clause-expression (function).
• (setf column-modifier-clause-expression) (function).
• column-modifier-clause-first (reader).
• (setf column-modifier-clause-first) (writer).
• column-modifier-clause-name (function).
• (setf column-modifier-clause-name) (function).
• column-modifier-clause-p (function).
• copy-add-column-clause (function).
• copy-add-primary-key-clause (function).
• copy-alter-column-clause (function).
• copy-change-column-clause (function).
• copy-column-definition-clause (function).
• copy-column-modifier-clause (function).
• copy-drop-column-clause (function).
• copy-drop-primary-key-clause (function).
• copy-fields-clause (function).
• copy-foreign-key-clause (function).
• copy-from-clause (function).
• copy-group-by-clause (function).
• copy-having-clause (function).
• copy-join-clause (function).
• copy-key-clause (function).
• copy-limit-clause (function).
• copy-modify-column-clause (function).
• copy-offset-clause (function).
• copy-on-clause (function).
• copy-on-conflict-do-nothing-clause (function).
• copy-on-conflict-do-update-clause (function).
• copy-on-delete-clause (function).
• copy-on-duplicate-key-update-clause (function).
• copy-on-update-clause (function).
• copy-order-by-clause (function).
• copy-primary-key-clause (function).
• copy-references-clause (function).
• copy-rename-to-clause (function).
• copy-returning-clause (function).
• copy-set=-clause (function).
• copy-unique-key-clause (function).
• copy-updatability-clause (function).
• copy-values-clause (function).
• copy-where-clause (function).
• drop-column-clause (structure).
• drop-column-clause-expression (function).
• (setf drop-column-clause-expression) (function).
• drop-column-clause-name (reader).
• (setf drop-column-clause-name) (writer).
• drop-column-clause-p (function).
• drop-primary-key-clause (structure).
• drop-primary-key-clause-name (reader).
• (setf drop-primary-key-clause-name) (writer).
• drop-primary-key-clause-p (function).
• fields-clause-name (reader).
• (setf fields-clause-name) (writer).
• fields-clause-p (function).
• fields-clause-statement (function).
• (setf fields-clause-statement) (function).
• find-make-clause (function).
• foreign-key-clause-column-names (reader).
• (setf foreign-key-clause-column-names) (writer).
• foreign-key-clause-expression (function).
• (setf foreign-key-clause-expression) (function).
• foreign-key-clause-name (reader).
• (setf foreign-key-clause-name) (writer).
• foreign-key-clause-p (function).
• foreign-key-clause-references (reader).
• (setf foreign-key-clause-references) (writer).
• from-clause-name (reader).
• (setf from-clause-name) (writer).
• from-clause-p (function).
• from-clause-statement (function).
• (setf from-clause-statement) (function).
• group-by-clause-expressions (function).
• (setf group-by-clause-expressions) (function).
• group-by-clause-name (reader).
• (setf group-by-clause-name) (writer).
• group-by-clause-p (function).
• having-clause-expression (function).
• (setf having-clause-expression) (function).
• having-clause-name (reader).
• (setf having-clause-name) (writer).
• having-clause-p (function).
• join-clause-kind (reader).
• (setf join-clause-kind) (writer).
• join-clause-name (function).
• (setf join-clause-name) (function).
• join-clause-on (reader).
• (setf join-clause-on) (writer).
• join-clause-p (function).
• join-clause-statement (function).
• (setf join-clause-statement) (function).
• join-clause-using (reader).
• (setf join-clause-using) (writer).
• key-clause-expression (function).
• (setf key-clause-expression) (function).
• key-clause-key-name (reader).
• (setf key-clause-key-name) (writer).
• key-clause-keys (reader).
• (setf key-clause-keys) (writer).
• key-clause-name (reader).
• (setf key-clause-name) (writer).
• key-clause-p (function).
• limit-clause-count1 (reader).
• (setf limit-clause-count1) (writer).
• limit-clause-count2 (reader).
• (setf limit-clause-count2) (writer).
• limit-clause-expressions (function).
• (setf limit-clause-expressions) (function).
• limit-clause-name (reader).
• (setf limit-clause-name) (writer).
• limit-clause-p (function).
• make-add-column-clause (function).
• make-add-primary-key-clause (function).
• make-alter-column-clause (function).
• make-change-column-clause (function).
• make-column-modifier-clause (function).
• make-conflict-target (function).
• make-drop-column-clause (function).
• make-drop-primary-key-clause (function).
• make-fields-clause (function).
• make-foreign-key-clause (function).
• make-from-clause (function).
• make-group-by-clause (function).
• make-having-clause (function).
• make-join-clause (function).
• make-key-clause (function).
• make-key-clause-for-all (function).
• make-limit-clause (function).
• make-modify-column-clause (function).
• make-offset-clause (function).
• make-on-clause (function).
• make-on-conflict-do-nothing-clause (function).
• make-on-conflict-do-update-clause (function).
• make-on-delete-clause (function).
• make-on-duplicate-key-update-clause (function).
• make-on-update-clause (function).
• make-order-by-clause (function).
• make-primary-key-clause (function).
• make-references-clause (function).
• make-rename-to-clause (function).
• make-returning-clause (function).
• make-set=-clause (function).
• make-sql-column-type-from-list (function).
• make-unique-key-clause (function).
• make-updatability-clause (function).
• make-values-clause (function).
• make-where-clause (function).
• modify-column-clause (structure).
• modify-column-clause-after (function).
• (setf modify-column-clause-after) (function).
• modify-column-clause-column-definition (function).
• (setf modify-column-clause-column-definition) (function).
• modify-column-clause-expression (function).
• (setf modify-column-clause-expression) (function).
• modify-column-clause-first (function).
• (setf modify-column-clause-first) (function).
• modify-column-clause-name (reader).
• (setf modify-column-clause-name) (writer).
• modify-column-clause-p (function).
• offset-clause-name (reader).
• (setf offset-clause-name) (writer).
• offset-clause-offset (reader).
• (setf offset-clause-offset) (writer).
• offset-clause-p (function).
• on-clause (structure).
• on-clause-action (reader).
• (setf on-clause-action) (writer).
• on-clause-name (reader).
• (setf on-clause-name) (writer).
• on-clause-p (function).
• on-conflict-do-nothing-clause (structure).
• on-conflict-do-nothing-clause-conflict-target (reader).
• (setf on-conflict-do-nothing-clause-conflict-target) (writer).
• on-conflict-do-nothing-clause-name (reader).
• (setf on-conflict-do-nothing-clause-name) (writer).
• on-conflict-do-nothing-clause-p (function).
• on-conflict-do-update-clause (structure).
• on-conflict-do-update-clause-conflict-target (reader).
• (setf on-conflict-do-update-clause-conflict-target) (writer).
• on-conflict-do-update-clause-name (reader).
• (setf on-conflict-do-update-clause-name) (writer).
• on-conflict-do-update-clause-p (function).
• on-conflict-do-update-clause-update-set (reader).
• (setf on-conflict-do-update-clause-update-set) (writer).
• on-conflict-do-update-clause-where-condition (reader).
• (setf on-conflict-do-update-clause-where-condition) (writer).
• on-delete-clause (structure).
• on-delete-clause-action (function).
• (setf on-delete-clause-action) (function).
• on-delete-clause-name (reader).
• (setf on-delete-clause-name) (writer).
• on-delete-clause-p (function).
• on-duplicate-key-update-clause (structure).
• on-duplicate-key-update-clause-args (reader).
• (setf on-duplicate-key-update-clause-args) (writer).
• on-duplicate-key-update-clause-name (reader).
• (setf on-duplicate-key-update-clause-name) (writer).
• on-duplicate-key-update-clause-p (function).
• on-update-clause (structure).
• on-update-clause-action (function).
• (setf on-update-clause-action) (function).
• on-update-clause-name (reader).
• (setf on-update-clause-name) (writer).
• on-update-clause-p (function).
• order-by-clause-expressions (function).
• (setf order-by-clause-expressions) (function).
• order-by-clause-name (reader).
• (setf order-by-clause-name) (writer).
• order-by-clause-p (function).
• primary-key-clause-expression (function).
• (setf primary-key-clause-expression) (function).
• primary-key-clause-key-name (function).
• (setf primary-key-clause-key-name) (function).
• primary-key-clause-keys (function).
• (setf primary-key-clause-keys) (function).
• primary-key-clause-name (reader).
• (setf primary-key-clause-name) (writer).
• primary-key-clause-p (function).
• references-clause-column-names (reader).
• (setf references-clause-column-names) (writer).
• references-clause-expression (function).
• (setf references-clause-expression) (function).
• references-clause-name (reader).
• (setf references-clause-name) (writer).
• references-clause-p (function).
• references-clause-table-name (reader).
• (setf references-clause-table-name) (writer).
• rename-to-clause (structure).
• rename-to-clause-expression (function).
• (setf rename-to-clause-expression) (function).
• rename-to-clause-name (reader).
• (setf rename-to-clause-name) (writer).
• rename-to-clause-p (function).
• returning-clause-expressions (function).
• (setf returning-clause-expressions) (function).
• returning-clause-name (reader).
• (setf returning-clause-name) (writer).
• returning-clause-p (function).
• set=-clause-args (reader).
• (setf set=-clause-args) (writer).
• set=-clause-name (reader).
• (setf set=-clause-name) (writer).
• set=-clause-p (function).
• unique-key-clause-expression (function).
• (setf unique-key-clause-expression) (function).
• unique-key-clause-key-name (function).
• (setf unique-key-clause-key-name) (function).
• unique-key-clause-keys (function).
• (setf unique-key-clause-keys) (function).
• unique-key-clause-name (reader).
• (setf unique-key-clause-name) (writer).
• unique-key-clause-p (function).
• updatability-clause-idents (reader).
• (setf updatability-clause-idents) (writer).
• updatability-clause-name (function).
• (setf updatability-clause-name) (function).
• updatability-clause-nowait (reader).
• (setf updatability-clause-nowait) (writer).
• updatability-clause-p (function).
• updatability-clause-statement (function).
• (setf updatability-clause-statement) (function).
• updatability-clause-update-type (reader).
• (setf updatability-clause-update-type) (writer).
• values-clause-expression (function).
• (setf values-clause-expression) (function).
• values-clause-name (reader).
• (setf values-clause-name) (writer).
• values-clause-p (function).
• where-clause-expression (function).
• (setf where-clause-expression) (function).
• where-clause-name (reader).
• (setf where-clause-name) (writer).
• where-clause-p (function).