The sxql Reference Manual

Table of Contents

The sxql Reference Manual

This is the sxql Reference Manual, version 0.1.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 17:55:13 2021 GMT+0.

1 Introduction

SxQL - An SQL generator.

Usage

(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.

(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)

(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 :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)

(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)

(delete-from :person
  (where (:= :name "Eitaro Fukamachi")))
;=> #<SXQL-STATEMENT: DELETE FROM person WHERE (name = 'Eitaro Fukamachi')>

union-queies (&rest statements)

(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)

(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)

(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)

(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)

(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)

(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)

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

SQL Clauses

fields

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

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

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

from

(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

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

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

order-by

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

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

group-by

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

having

(having (:>= (:sum :hoge) 88))
;=> #<SXQL-CLAUSE: HAVING (SUM(`hoge`) >= 88)>

returning

(returning :id)
;=> #<SXQL-CLAUSE: RETURNING `id`>

limit

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

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

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

offset

(offset 0)
;=> #<SXQL-CLAUSE: OFFSET 0>

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

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

(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

(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

(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

(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

(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

(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

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

alter-column

(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

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

drop-column

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

add-primary-key

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

drop-primary-key

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

rename-to

(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.

(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.

(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.

(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).

(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.

2 Systems

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

2.1 sxql

Author

Eitaro Fukamachi

License

BSD 3-Clause

Description

A SQL generator

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 :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

• optima
• iterate
• cl-syntax-annot
• trivial-types
• split-sequence
• alexandria
• cl-package-locks

Source

sxql.asd (file)

Component

src (module)

3 Modules

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

3.1 sxql/src

Parent

sxql (system)

Location

src/

Components

• sxql.lisp (file)
• compile.lisp (file)
• sql-type.lisp (file)
• operator.lisp (file)
• clause.lisp (file)
• statement.lisp (file)
• composed-statement.lisp (file)
• util.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 sxql.asd

Location

sxql.asd

Systems

sxql (system)

Packages

sxql-asd

4.1.2 sxql/src/sxql.lisp

Dependencies

• statement.lisp (file)
• clause.lisp (file)
• operator.lisp (file)
• compile.lisp (file)
• composed-statement.lisp (file)

Parent

src (module)

Location

src/sxql.lisp

Packages

sxql

Exported Definitions

• add-column (function)
• add-primary-key (function)
• alter-column (function)
• alter-table (macro)
• change-column (function)
• create-index (function)
• create-table (macro)
• delete-from (macro)
• drop-column (function)
• drop-index (function)
• drop-primary-key (function)
• drop-table (macro)
• fields (macro)
• for (macro)
• foreign-key (function)
• from (macro)
• full-join (macro)
• group-by (macro)
• having (macro)
• index-key (function)
• inner-join (macro)
• insert-into (macro)
• join (macro)
• left-join (macro)
• limit (function)
• modify-column (function)
• offset (function)
• on-conflict-do-nothing (macro)
• on-conflict-do-update (macro)
• on-duplicate-key-update (macro)
• order-by (macro)
• pragma (function)
• primary-key (function)
• rename-to (function)
• returning (macro)
• right-join (macro)
• select (macro)
• select-statement-designator (type)
• set= (macro)
• union-all-queries (function)
• union-queries (function)
• unique-key (function)
• update (macro)
• where (macro)

Internal Definitions

• convert-if-fields-clause (function)
• expand-expression (function)
• expand-op (function)
• key-clause-expand (function)

4.1.3 sxql/src/compile.lisp

Dependency

sql-type.lisp (file)

Parent

src (module)

Location

src/compile.lisp

Packages

sxql.compile

Exported Definitions

• sql-compile (function)
• yield (method)
• yield (method)
• yield (method)

Internal Definitions

• copy-sql-clause-compiled (function)
• copy-sql-op-compiled (function)
• copy-sql-statement-compiled (function)
• define-compile-struct (macro)
• find-compile-function (generic function)
• find-compile-function (method)
• find-compile-function (method)
• find-compile-function (method)
• make-sql-clause-compiled (function)
• make-sql-op-compiled (function)
• make-sql-statement-compiled (function)
• sql-clause-compiled (structure)
• sql-clause-compiled-bind (function)
• (setf sql-clause-compiled-bind) (function)
• sql-clause-compiled-name (function)
• (setf sql-clause-compiled-name) (function)
• sql-clause-compiled-p (function)
• sql-clause-compiled-sql (function)
• (setf sql-clause-compiled-sql) (function)
• sql-op-compiled (structure)
• sql-op-compiled-bind (function)
• (setf sql-op-compiled-bind) (function)
• sql-op-compiled-name (function)
• (setf sql-op-compiled-name) (function)
• sql-op-compiled-p (function)
• sql-op-compiled-sql (function)
• (setf sql-op-compiled-sql) (function)
• sql-statement-compiled (structure)
• sql-statement-compiled-bind (function)
• (setf sql-statement-compiled-bind) (function)
• sql-statement-compiled-name (function)
• (setf sql-statement-compiled-name) (function)
• sql-statement-compiled-p (function)
• sql-statement-compiled-sql (function)
• (setf sql-statement-compiled-sql) (function)

4.1.4 sxql/src/sql-type.lisp

Parent

src (module)

Location

src/sql-type.lisp

Packages

sxql.sql-type

Exported Definitions

• *quote-character* (special variable)
• *use-placeholder* (special variable)
• 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-variable (function)
• make-type-keyword (function)
• make-unary-op (function)
• make-unary-splicing-op (function)
• sql-atom (structure)
• sql-clause (structure)
• sql-clause-list (type)
• sql-column-type (structure)
• sql-composed-statement (structure)
• sql-composed-statement-children (function)
• (setf sql-composed-statement-children) (function)
• sql-expression (type)
• sql-expression-list (structure)
• sql-expression-list-p (function)
• sql-keyword (structure)
• sql-list (structure)
• sql-list-elements (function)
• (setf sql-list-elements) (function)
• sql-op (structure)
• sql-splicing-expression-list (structure)
• sql-statement (structure)
• sql-statement-name (function)
• (setf sql-statement-name) (function)
• sql-symbol (structure)
• sql-variable (structure)
• sql-variable-value (function)
• (setf sql-variable-value) (function)
• statement-clause (structure)
• unary-op (structure)
• unary-postfix-op (structure)
• unary-splicing-op (structure)
• with-table-name (macro)
• with-yield-binds (macro)
• yield (generic function)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)

Internal Definitions

• *bind-values* (special variable)
• *inside-function-op* (special variable)
• *table-name-scope* (special variable)
• *use-global-bind-values* (special variable)
• conjunctive-op-expressions (function)
• (setf conjunctive-op-expressions) (function)
• 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 (function)
• (setf expression-clause-expression) (function)
• expression-clause-name (function)
• (setf expression-clause-name) (function)
• expression-clause-p (function)
• expression-list-clause-expressions (function)
• (setf expression-list-clause-expressions) (function)
• 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 (function)
• (setf infix-list-op-left) (function)
• infix-list-op-name (function)
• (setf infix-list-op-name) (function)
• infix-list-op-p (function)
• infix-list-op-right (function)
• (setf infix-list-op-right) (function)
• infix-op-left (function)
• (setf infix-op-left) (function)
• infix-op-name (function)
• (setf infix-op-name) (function)
• infix-op-p (function)
• infix-op-right (function)
• (setf infix-op-right) (function)
• 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 (function)
• (setf sql-clause-name) (function)
• sql-clause-p (function)
• sql-column-type-args (function)
• (setf sql-column-type-args) (function)
• sql-column-type-attrs (function)
• (setf sql-column-type-attrs) (function)
• sql-column-type-name (function)
• (setf sql-column-type-name) (function)
• 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 (function)
• (setf sql-expression-list-elements) (function)
• sql-expression-p (function)
• sql-keyword-name (function)
• (setf sql-keyword-name) (function)
• sql-keyword-p (function)
• sql-list-p (function)
• sql-op-name (function)
• (setf sql-op-name) (function)
• 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 (function)
• (setf sql-symbol-name) (function)
• sql-symbol-p (function)
• sql-variable-p (function)
• statement-clause-name (function)
• (setf statement-clause-name) (function)
• statement-clause-p (function)
• statement-clause-statement (function)
• (setf statement-clause-statement) (function)
• unary-op-name (function)
• (setf unary-op-name) (function)
• unary-op-p (function)
• unary-op-var (function)
• (setf unary-op-var) (function)
• 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)

4.1.5 sxql/src/operator.lisp

Dependency

sql-type.lisp (file)

Parent

src (module)

Location

src/operator.lisp

Packages

sxql.operator

Exported Definitions

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

Internal Definitions

• !=-op (structure)
• !=-op-left (function)
• (setf !=-op-left) (function)
• !=-op-name (function)
• (setf !=-op-name) (function)
• !=-op-p (function)
• !=-op-right (function)
• (setf !=-op-right) (function)
• %-op (structure)
• %-op-expressions (function)
• (setf %-op-expressions) (function)
• %-op-name (function)
• (setf %-op-name) (function)
• %-op-p (function)
• *-op (structure)
• *-op-expressions (function)
• (setf *-op-expressions) (function)
• *-op-name (function)
• (setf *-op-name) (function)
• *-op-p (function)
• +-op (structure)
• +-op-expressions (function)
• (setf +-op-expressions) (function)
• +-op-name (function)
• (setf +-op-name) (function)
• +-op-p (function)
• --op (structure)
• --op-expressions (function)
• (setf --op-expressions) (function)
• --op-name (function)
• (setf --op-name) (function)
• --op-p (function)
• /-op (structure)
• /-op-expressions (function)
• (setf /-op-expressions) (function)
• /-op-name (function)
• (setf /-op-name) (function)
• /-op-p (function)
• <-op (structure)
• <-op-left (function)
• (setf <-op-left) (function)
• <-op-name (function)
• (setf <-op-name) (function)
• <-op-p (function)
• <-op-right (function)
• (setf <-op-right) (function)
• <=-op (structure)
• <=-op-left (function)
• (setf <=-op-left) (function)
• <=-op-name (function)
• (setf <=-op-name) (function)
• <=-op-p (function)
• <=-op-right (function)
• (setf <=-op-right) (function)
• =-op (structure)
• =-op-left (function)
• (setf =-op-left) (function)
• =-op-name (function)
• (setf =-op-name) (function)
• =-op-p (function)
• =-op-right (function)
• (setf =-op-right) (function)
• >-op (structure)
• >-op-left (function)
• (setf >-op-left) (function)
• >-op-name (function)
• (setf >-op-name) (function)
• >-op-p (function)
• >-op-right (function)
• (setf >-op-right) (function)
• >=-op (structure)
• >=-op-left (function)
• (setf >=-op-left) (function)
• >=-op-name (function)
• (setf >=-op-name) (function)
• >=-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 (function)
• (setf a<-op-name) (function)
• 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 (function)
• (setf a>-op-name) (function)
• 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 (function)
• (setf and-op-name) (function)
• and-op-p (function)
• as-op (structure)
• as-op-left (function)
• (setf as-op-left) (function)
• as-op-name (function)
• (setf as-op-name) (function)
• as-op-p (function)
• as-op-right (function)
• (setf as-op-right) (function)
• asc-op (structure)
• asc-op-name (function)
• (setf asc-op-name) (function)
• asc-op-p (function)
• asc-op-var (function)
• (setf asc-op-var) (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-desc-op (function)
• copy-distinct-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-raw-op (function)
• copy-splicing-raw-op (function)
• copy-union-all-op (function)
• copy-union-op (function)
• define-op (macro)
• desc-op (structure)
• desc-op-name (function)
• (setf desc-op-name) (function)
• desc-op-p (function)
• desc-op-var (function)
• (setf desc-op-var) (function)
• distinct-op (structure)
• distinct-op-name (function)
• (setf distinct-op-name) (function)
• distinct-op-p (function)
• distinct-op-var (function)
• (setf distinct-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 (function)
• (setf in-op-name) (function)
• 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 (function)
• (setf is-distinct-from-op-name) (function)
• 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 (function)
• (setf is-not-distinct-from-op-name) (function)
• 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 (function)
• (setf is-null-op-name) (function)
• 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 (function)
• (setf like-op-name) (function)
• 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-desc-op (function)
• make-distinct-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-raw-op (function)
• make-splicing-raw-op (function)
• make-union-all-op (function)
• make-union-op (function)
• not-in-op (structure)
• not-in-op-left (function)
• (setf not-in-op-left) (function)
• not-in-op-name (function)
• (setf not-in-op-name) (function)
• not-in-op-p (function)
• not-in-op-right (function)
• (setf not-in-op-right) (function)
• not-null-op (structure)
• not-null-op-name (function)
• (setf not-null-op-name) (function)
• not-null-op-p (function)
• not-null-op-var (function)
• (setf not-null-op-var) (function)
• not-op (structure)
• not-op-name (function)
• (setf not-op-name) (function)
• not-op-p (function)
• not-op-var (function)
• (setf not-op-var) (function)
• on-op (structure)
• on-op-name (function)
• (setf on-op-name) (function)
• on-op-p (function)
• on-op-var (function)
• (setf on-op-var) (function)
• or-op (structure)
• or-op-expressions (function)
• (setf or-op-expressions) (function)
• or-op-name (function)
• (setf or-op-name) (function)
• or-op-p (function)
• raw-op (structure)
• raw-op-name (function)
• (setf raw-op-name) (function)
• raw-op-p (function)
• raw-op-var (function)
• (setf raw-op-var) (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 (function)
• (setf union-all-op-name) (function)
• union-all-op-p (function)
• union-op (structure)
• union-op-expressions (function)
• (setf union-op-expressions) (function)
• union-op-name (function)
• (setf union-op-name) (function)
• union-op-p (function)
• yield-for-union-ops (macro)

4.1.6 sxql/src/clause.lisp

Dependency

operator.lisp (file)

Parent

src (module)

Location

src/clause.lisp

Packages

sxql.clause

Exported Definitions

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

Internal Definitions

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

4.1.7 sxql/src/statement.lisp

Dependencies

• operator.lisp (file)
• clause.lisp (file)
• util.lisp (file)

Parent

src (module)

Location

src/statement.lisp

Packages

sxql.statement

Exported Definitions

• add-child (generic function)
• add-child (method)
• 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)
• insert-into-statement (structure)
• make-statement (generic function)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• make-statement (method)
• merge-statements (function)
• pragma-statement (structure)
• select-statement (structure)
• select-statement-clause-order (function)
• (setf select-statement-clause-order) (function)
• select-statement-fields-clause (function)
• (setf select-statement-fields-clause) (function)
• select-statement-from-clause (function)
• (setf select-statement-from-clause) (function)
• select-statement-group-by-clause (function)
• (setf select-statement-group-by-clause) (function)
• select-statement-having-clause (function)
• (setf select-statement-having-clause) (function)
• select-statement-join-clause (function)
• (setf select-statement-join-clause) (function)
• select-statement-limit-clause (function)
• (setf select-statement-limit-clause) (function)
• select-statement-offset-clause (function)
• (setf select-statement-offset-clause) (function)
• select-statement-order-by-clause (function)
• (setf select-statement-order-by-clause) (function)
• select-statement-returning-clause (function)
• (setf select-statement-returning-clause) (function)
• select-statement-table-name (function)
• select-statement-updatability-clause (function)
• (setf select-statement-updatability-clause) (function)
• select-statement-where-clause (function)
• (setf select-statement-where-clause) (function)
• sort-clause-types (function)
• update-statement (structure)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)

Internal Definitions

• *clause-priority* (special variable)
• alter-table-statement-children (function)
• (setf alter-table-statement-children) (function)
• alter-table-statement-name (function)
• (setf alter-table-statement-name) (function)
• alter-table-statement-p (function)
• alter-table-statement-table (function)
• (setf alter-table-statement-table) (function)
• 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-insert-into-statement (function)
• copy-pragma-statement (function)
• copy-select-statement (function)
• copy-update-statement (function)
• create-index-statement-columns (function)
• (setf create-index-statement-columns) (function)
• create-index-statement-if-not-exists (function)
• (setf create-index-statement-if-not-exists) (function)
• create-index-statement-index-name (function)
• (setf create-index-statement-index-name) (function)
• create-index-statement-name (function)
• (setf create-index-statement-name) (function)
• create-index-statement-p (function)
• create-index-statement-table-name (function)
• (setf create-index-statement-table-name) (function)
• create-index-statement-unique (function)
• (setf create-index-statement-unique) (function)
• create-index-statement-using (function)
• (setf create-index-statement-using) (function)
• create-table-statement-children (function)
• (setf create-table-statement-children) (function)
• create-table-statement-if-not-exists (function)
• (setf create-table-statement-if-not-exists) (function)
• create-table-statement-name (function)
• (setf create-table-statement-name) (function)
• create-table-statement-p (function)
• create-table-statement-table (function)
• (setf create-table-statement-table) (function)
• delete-from-statement-children (function)
• (setf delete-from-statement-children) (function)
• delete-from-statement-name (function)
• (setf delete-from-statement-name) (function)
• delete-from-statement-p (function)
• drop-index-statement-if-exists (function)
• (setf drop-index-statement-if-exists) (function)
• drop-index-statement-index-name (function)
• (setf drop-index-statement-index-name) (function)
• drop-index-statement-name (function)
• (setf drop-index-statement-name) (function)
• drop-index-statement-on (function)
• (setf drop-index-statement-on) (function)
• drop-index-statement-p (function)
• drop-table-statement-if-exists (function)
• (setf drop-table-statement-if-exists) (function)
• drop-table-statement-name (function)
• (setf drop-table-statement-name) (function)
• drop-table-statement-p (function)
• drop-table-statement-table (function)
• (setf drop-table-statement-table) (function)
• find-make-statement (function)
• insert-into-statement-children (function)
• (setf insert-into-statement-children) (function)
• insert-into-statement-name (function)
• (setf insert-into-statement-name) (function)
• 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-insert-into-statement (function)
• make-pragma-statement (function)
• make-select-statement (function)
• make-update-statement (function)
• multiple-allowed-clause (type)
• pragma-statement-name (function)
• (setf pragma-statement-name) (function)
• pragma-statement-p (function)
• pragma-statement-pragma-name (function)
• (setf pragma-statement-pragma-name) (function)
• pragma-statement-value (function)
• (setf pragma-statement-value) (function)
• select-statement-children (function)
• (setf select-statement-children) (function)
• select-statement-name (function)
• (setf select-statement-name) (function)
• select-statement-p (function)
• update-statement-children (function)
• (setf update-statement-children) (function)
• update-statement-name (function)
• (setf update-statement-name) (function)
• update-statement-p (function)

4.1.8 sxql/src/composed-statement.lisp

Dependencies

• sql-type.lisp (file)
• operator.lisp (file)
• clause.lisp (file)
• statement.lisp (file)
• util.lisp (file)

Parent

src (module)

Location

src/composed-statement.lisp

Packages

sxql.composed-statement

Exported Definitions

• compose-statements (function)
• composed-statement (structure)
• yield (method)

Internal Definitions

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

4.1.9 sxql/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Packages

sxql.util

Exported Definitions

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

5 Packages

Packages are listed by definition order.

5.1 sxql-asd

Source

sxql.asd

Use List

• asdf/interface
• common-lisp

5.2 sxql

Source

sxql.lisp (file)

Use List

• optima
• sxql.clause
• sxql.composed-statement
• sxql.statement
• common-lisp

Exported Definitions

• add-column (function)
• add-primary-key (function)
• alter-column (function)
• alter-table (macro)
• change-column (function)
• create-index (function)
• create-table (macro)
• delete-from (macro)
• drop-column (function)
• drop-index (function)
• drop-primary-key (function)
• drop-table (macro)
• fields (macro)
• for (macro)
• foreign-key (function)
• from (macro)
• full-join (macro)
• group-by (macro)
• having (macro)
• index-key (function)
• inner-join (macro)
• insert-into (macro)
• join (macro)
• left-join (macro)
• limit (function)
• modify-column (function)
• offset (function)
• on-conflict-do-nothing (macro)
• on-conflict-do-update (macro)
• on-duplicate-key-update (macro)
• order-by (macro)
• pragma (function)
• primary-key (function)
• rename-to (function)
• returning (macro)
• right-join (macro)
• select (macro)
• select-statement-designator (type)
• set= (macro)
• union-all-queries (function)
• union-queries (function)
• unique-key (function)
• update (macro)
• where (macro)

Internal Definitions

• convert-if-fields-clause (function)
• expand-expression (function)
• expand-op (function)
• key-clause-expand (function)

5.3 sxql.compile

Source

compile.lisp (file)

Use List

• sxql.sql-type
• trivial-types
• common-lisp

Exported Definitions

sql-compile (function)

Internal Definitions

• copy-sql-clause-compiled (function)
• copy-sql-op-compiled (function)
• copy-sql-statement-compiled (function)
• define-compile-struct (macro)
• find-compile-function (generic function)
• find-compile-function (method)
• find-compile-function (method)
• find-compile-function (method)
• make-sql-clause-compiled (function)
• make-sql-op-compiled (function)
• make-sql-statement-compiled (function)
• sql-clause-compiled (structure)
• sql-clause-compiled-bind (function)
• (setf sql-clause-compiled-bind) (function)
• sql-clause-compiled-name (function)
• (setf sql-clause-compiled-name) (function)
• sql-clause-compiled-p (function)
• sql-clause-compiled-sql (function)
• (setf sql-clause-compiled-sql) (function)
• sql-op-compiled (structure)
• sql-op-compiled-bind (function)
• (setf sql-op-compiled-bind) (function)
• sql-op-compiled-name (function)
• (setf sql-op-compiled-name) (function)
• sql-op-compiled-p (function)
• sql-op-compiled-sql (function)
• (setf sql-op-compiled-sql) (function)
• sql-statement-compiled (structure)
• sql-statement-compiled-bind (function)
• (setf sql-statement-compiled-bind) (function)
• sql-statement-compiled-name (function)
• (setf sql-statement-compiled-name) (function)
• sql-statement-compiled-p (function)
• sql-statement-compiled-sql (function)
• (setf sql-statement-compiled-sql) (function)

5.4 sxql.sql-type

Source

sql-type.lisp (file)

Use List

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

Used By List

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

Exported Definitions

• *quote-character* (special variable)
• *use-placeholder* (special variable)
• 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-variable (function)
• make-type-keyword (function)
• make-unary-op (function)
• make-unary-splicing-op (function)
• sql-atom (structure)
• sql-clause (structure)
• sql-clause-list (type)
• sql-column-type (structure)
• sql-composed-statement (structure)
• sql-composed-statement-children (function)
• (setf sql-composed-statement-children) (function)
• sql-expression (type)
• sql-expression-list (structure)
• sql-expression-list-p (function)
• sql-keyword (structure)
• sql-list (structure)
• sql-list-elements (function)
• (setf sql-list-elements) (function)
• sql-op (structure)
• sql-splicing-expression-list (structure)
• sql-statement (structure)
• sql-statement-name (function)
• (setf sql-statement-name) (function)
• sql-symbol (structure)
• sql-variable (structure)
• sql-variable-value (function)
• (setf sql-variable-value) (function)
• statement-clause (structure)
• unary-op (structure)
• unary-postfix-op (structure)
• unary-splicing-op (structure)
• with-table-name (macro)
• with-yield-binds (macro)
• yield (generic function)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)
• yield (method)

Internal Definitions

• *bind-values* (special variable)
• *inside-function-op* (special variable)
• *table-name-scope* (special variable)
• *use-global-bind-values* (special variable)
• conjunctive-op-expressions (function)
• (setf conjunctive-op-expressions) (function)
• 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 (function)
• (setf expression-clause-expression) (function)
• expression-clause-name (function)
• (setf expression-clause-name) (function)
• expression-clause-p (function)
• expression-list-clause-expressions (function)
• (setf expression-list-clause-expressions) (function)
• 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 (function)
• (setf infix-list-op-left) (function)
• infix-list-op-name (function)
• (setf infix-list-op-name) (function)
• infix-list-op-p (function)
• infix-list-op-right (function)
• (setf infix-list-op-right) (function)
• infix-op-left (function)
• (setf infix-op-left) (function)
• infix-op-name (function)
• (setf infix-op-name) (function)
• infix-op-p (function)
• infix-op-right (function)
• (setf infix-op-right) (function)
• 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 (function)
• (setf sql-clause-name) (function)
• sql-clause-p (function)
• sql-column-type-args (function)
• (setf sql-column-type-args) (function)
• sql-column-type-attrs (function)
• (setf sql-column-type-attrs) (function)
• sql-column-type-name (function)
• (setf sql-column-type-name) (function)
• 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 (function)
• (setf sql-expression-list-elements) (function)
• sql-expression-p (function)
• sql-keyword-name (function)
• (setf sql-keyword-name) (function)
• sql-keyword-p (function)
• sql-list-p (function)
• sql-op-name (function)
• (setf sql-op-name) (function)
• 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 (function)
• (setf sql-symbol-name) (function)
• sql-symbol-p (function)
• sql-variable-p (function)
• statement-clause-name (function)
• (setf statement-clause-name) (function)
• statement-clause-p (function)
• statement-clause-statement (function)
• (setf statement-clause-statement) (function)
• unary-op-name (function)
• (setf unary-op-name) (function)
• unary-op-p (function)
• unary-op-var (function)
• (setf unary-op-var) (function)
• 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.operator

Source

operator.lisp (file)

Use List

• sxql.sql-type
• common-lisp

Used By List

sxql.clause

Exported Definitions

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

Internal Definitions

• !=-op (structure)
• !=-op-left (function)
• (setf !=-op-left) (function)
• !=-op-name (function)
• (setf !=-op-name) (function)
• !=-op-p (function)
• !=-op-right (function)
• (setf !=-op-right) (function)
• %-op (structure)
• %-op-expressions (function)
• (setf %-op-expressions) (function)
• %-op-name (function)
• (setf %-op-name) (function)
• %-op-p (function)
• *-op (structure)
• *-op-expressions (function)
• (setf *-op-expressions) (function)
• *-op-name (function)
• (setf *-op-name) (function)
• *-op-p (function)
• +-op (structure)
• +-op-expressions (function)
• (setf +-op-expressions) (function)
• +-op-name (function)
• (setf +-op-name) (function)
• +-op-p (function)
• --op (structure)
• --op-expressions (function)
• (setf --op-expressions) (function)
• --op-name (function)
• (setf --op-name) (function)
• --op-p (function)
• /-op (structure)
• /-op-expressions (function)
• (setf /-op-expressions) (function)
• /-op-name (function)
• (setf /-op-name) (function)
• /-op-p (function)
• <-op (structure)
• <-op-left (function)
• (setf <-op-left) (function)
• <-op-name (function)
• (setf <-op-name) (function)
• <-op-p (function)
• <-op-right (function)
• (setf <-op-right) (function)
• <=-op (structure)
• <=-op-left (function)
• (setf <=-op-left) (function)
• <=-op-name (function)
• (setf <=-op-name) (function)
• <=-op-p (function)
• <=-op-right (function)
• (setf <=-op-right) (function)
• =-op (structure)
• =-op-left (function)
• (setf =-op-left) (function)
• =-op-name (function)
• (setf =-op-name) (function)
• =-op-p (function)
• =-op-right (function)
• (setf =-op-right) (function)
• >-op (structure)
• >-op-left (function)
• (setf >-op-left) (function)
• >-op-name (function)
• (setf >-op-name) (function)
• >-op-p (function)
• >-op-right (function)
• (setf >-op-right) (function)
• >=-op (structure)
• >=-op-left (function)
• (setf >=-op-left) (function)
• >=-op-name (function)
• (setf >=-op-name) (function)
• >=-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 (function)
• (setf a<-op-name) (function)
• 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 (function)
• (setf a>-op-name) (function)
• 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 (function)
• (setf and-op-name) (function)
• and-op-p (function)
• as-op (structure)
• as-op-left (function)
• (setf as-op-left) (function)
• as-op-name (function)
• (setf as-op-name) (function)
• as-op-p (function)
• as-op-right (function)
• (setf as-op-right) (function)
• asc-op (structure)
• asc-op-name (function)
• (setf asc-op-name) (function)
• asc-op-p (function)
• asc-op-var (function)
• (setf asc-op-var) (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-desc-op (function)
• copy-distinct-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-raw-op (function)
• copy-splicing-raw-op (function)
• copy-union-all-op (function)
• copy-union-op (function)
• define-op (macro)
• desc-op (structure)
• desc-op-name (function)
• (setf desc-op-name) (function)
• desc-op-p (function)
• desc-op-var (function)
• (setf desc-op-var) (function)
• distinct-op (structure)
• distinct-op-name (function)
• (setf distinct-op-name) (function)
• distinct-op-p (function)
• distinct-op-var (function)
• (setf distinct-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 (function)
• (setf in-op-name) (function)
• 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 (function)
• (setf is-distinct-from-op-name) (function)
• 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 (function)
• (setf is-not-distinct-from-op-name) (function)
• 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 (function)
• (setf is-null-op-name) (function)
• 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 (function)
• (setf like-op-name) (function)
• 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-desc-op (function)
• make-distinct-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-raw-op (function)
• make-splicing-raw-op (function)
• make-union-all-op (function)
• make-union-op (function)
• not-in-op (structure)
• not-in-op-left (function)
• (setf not-in-op-left) (function)
• not-in-op-name (function)
• (setf not-in-op-name) (function)
• not-in-op-p (function)
• not-in-op-right (function)
• (setf not-in-op-right) (function)
• not-null-op (structure)
• not-null-op-name (function)
• (setf not-null-op-name) (function)
• not-null-op-p (function)
• not-null-op-var (function)
• (setf not-null-op-var) (function)
• not-op (structure)
• not-op-name (function)
• (setf not-op-name) (function)
• not-op-p (function)
• not-op-var (function)
• (setf not-op-var) (function)
• on-op (structure)
• on-op-name (function)
• (setf on-op-name) (function)
• on-op-p (function)
• on-op-var (function)
• (setf on-op-var) (function)
• or-op (structure)
• or-op-expressions (function)
• (setf or-op-expressions) (function)
• or-op-name (function)
• (setf or-op-name) (function)
• or-op-p (function)
• raw-op (structure)
• raw-op-name (function)
• (setf raw-op-name) (function)
• raw-op-p (function)
• raw-op-var (function)
• (setf raw-op-var) (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 (function)
• (setf union-all-op-name) (function)
• union-all-op-p (function)
• union-op (structure)
• union-op-expressions (function)
• (setf union-op-expressions) (function)
• union-op-name (function)
• (setf union-op-name) (function)
• union-op-p (function)
• yield-for-union-ops (macro)

5.6 sxql.clause

Source

clause.lisp (file)

Use List

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

Used By List

sxql

Exported Definitions

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

Internal Definitions

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