The sxql Reference Manual

This is the sxql Reference Manual, version 0.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 07:01:12 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 sxql

A SQL generator

Author

Eitaro Fukamachi

License

BSD 3-Clause

Long Description

# SxQL - An SQL generator.

[![Build Status](https://travis-ci.org/fukamachi/sxql.svg?branch=master)](https://travis-ci.org/fukamachi/sxql)

## Usage

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

(yield *)

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

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

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

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

## SQL Statements

### select (field &body clauses)

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

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

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

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

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

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

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

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

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

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

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

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

### update (table &body clauses)

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

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

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

### union-queies (&rest statements)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## SQL Clauses

### fields

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

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

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

### from

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

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

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

### where

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

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

### order-by

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

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

### group-by

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

### having

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

### returning

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

### limit

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

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

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

### offset

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

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

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

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

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

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

### primary-key

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

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

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

### unique-key

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

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

### index-key

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

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

### foreign-key

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

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

### add-column

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

### modify-column

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

### alter-column

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

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

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

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

### change-column

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

### drop-column

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

### add-primary-key

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

### drop-primary-key

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

### rename-to

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

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

### on-duplicate-key-update

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

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

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

### on-coflict-do-nothing

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

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

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

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

### on-coflict-do-update

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

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

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

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

## SQL Operators

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

## Set a quote character

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

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

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

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

## Author

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

## Copyright

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

# License

Licensed under the BSD 3-Clause License.

Version

0.1.0

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

sxql.asd.

Child Component

src (module).


3 Modules

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


3.1 sxql/src

Source

sxql.asd.

Parent Component

sxql (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 sxql/sxql.asd

Source

sxql.asd.

Parent Component

sxql (system).

ASDF Systems

sxql.

Packages

sxql-asd.


4.1.2 sxql/src/sxql.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.

Public Interface
Internals

4.1.3 sxql/src/compile.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.compile.

Public Interface
Internals

4.1.4 sxql/src/sql-type.lisp

Dependency

syntax.lisp (file).

Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.sql-type.

Public Interface
Internals

4.1.5 sxql/src/operator.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.operator.

Public Interface
Internals

4.1.6 sxql/src/clause.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.clause.

Public Interface
Internals

4.1.7 sxql/src/statement.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.statement.

Public Interface
Internals

4.1.8 sxql/src/composed-statement.lisp

Dependencies
Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.composed-statement.

Public Interface
Internals

4.1.9 sxql/src/syntax.lisp

Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.syntax.

Public Interface

enable-syntax (macro).


4.1.10 sxql/src/util.lisp

Source

sxql.asd.

Parent Component

src (module).

Packages

sxql.util.

Public Interface

5 Packages

Packages are listed by definition order.


5.1 sxql.clause

Source

clause.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.2 sxql

Source

sxql.lisp.

Use List
Public Interface
Internals

5.3 sxql.statement

Source

statement.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.4 sxql.util

Source

util.lisp.

Use List
  • common-lisp.
  • iterate.
Public Interface

5.5 sxql.syntax

Source

syntax.lisp.

Use List

common-lisp.

Used By List
Public Interface

enable-syntax (macro).


5.6 sxql.composed-statement

Source

composed-statement.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.7 sxql.sql-type

Source

sql-type.lisp.

Use List
  • cl-annot.class.
  • common-lisp.
  • split-sequence.
  • sxql.syntax.
  • trivial-types.
Used By List
Public Interface
Internals

5.8 sxql-asd

Source

sxql.asd.

Use List
  • asdf/interface.
  • common-lisp.

5.9 sxql.operator

Source

operator.lisp.

Use List
Used By List

sxql.clause.

Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *inside-insert-into*
Package

sxql.clause.

Source

clause.lisp.

Special Variable: *inside-select*
Package

sxql.operator.

Source

operator.lisp.

Special Variable: *quote-character*
Package

sxql.sql-type.

Source

sql-type.lisp.

Special Variable: *sql-symbol-conversion*

Function for converting a string into an SQL symbol. It takes a string and must returns a string.

Package

sxql.operator.

Source

operator.lisp.

Special Variable: *use-placeholder*
Package

sxql.sql-type.

Source

sql-type.lisp.


6.1.2 Macros

Macro: alter-table (table &body clauses)
Package

sxql.

Source

sxql.lisp.

Macro: create-table (table column-definitions &body options)
Package

sxql.

Source

sxql.lisp.

Macro: delete-from (table &body clauses)
Package

sxql.

Source

sxql.lisp.

Macro: drop-table (table &key if-exists)
Package

sxql.

Source

sxql.lisp.

Macro: enable-syntax ()
Package

sxql.syntax.

Source

syntax.lisp.

Macro: fields (&rest fields)
Package

sxql.

Source

sxql.lisp.

Macro: for (update-type &key of nowait)
Package

sxql.

Source

sxql.lisp.

Macro: from (&rest statements)
Package

sxql.

Source

sxql.lisp.

Macro: full-join (table &key on using)
Package

sxql.

Source

sxql.lisp.

Macro: group-by (&rest expressions)
Package

sxql.

Source

sxql.lisp.

Macro: having (expression)
Package

sxql.

Source

sxql.lisp.

Macro: inner-join (table &key on using)
Package

sxql.

Source

sxql.lisp.

Macro: insert-into (table &body clauses)
Package

sxql.

Source

sxql.lisp.

Macro: join (table &key kind on using)
Package

sxql.

Source

sxql.lisp.

Macro: left-join (table &key on using)
Package

sxql.

Source

sxql.lisp.

Macro: on-conflict-do-nothing (&optional conflict-target)
Package

sxql.

Source

sxql.lisp.

Macro: on-conflict-do-update (conflict-target update-set &optional where-condition)
Package

sxql.

Source

sxql.lisp.

Macro: on-duplicate-key-update (&rest args)
Package

sxql.

Source

sxql.lisp.

Macro: order-by (&rest expressions)
Package

sxql.

Source

sxql.lisp.

Macro: returning (&rest expressions)
Package

sxql.

Source

sxql.lisp.

Macro: right-join (table &key on using)
Package

sxql.

Source

sxql.lisp.

Macro: select (fields &body clauses)
Package

sxql.

Source

sxql.lisp.

Macro: set= (&rest args)
Package

sxql.

Source

sxql.lisp.

Macro: update (table &body clauses)
Package

sxql.

Source

sxql.lisp.

Macro: where (expression)
Package

sxql.

Source

sxql.lisp.

Macro: with-table-name (table-name &body body)
Package

sxql.sql-type.

Source

sql-type.lisp.

Macro: with-yield-binds (&body body)
Package

sxql.sql-type.

Source

sql-type.lisp.


6.1.3 Ordinary functions

Function: add-column (column-name &rest args)
Package

sxql.

Source

sxql.lisp.

Function: add-primary-key (&rest column-names)
Package

sxql.

Source

sxql.lisp.

Function: alter-column (column-name &rest args)
Package

sxql.

Source

sxql.lisp.

Function: change-column (old-column-name new-column-name &rest args)
Package

sxql.

Source

sxql.lisp.

Function: compose-statements (statement &rest statements)
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Function: compose-where-clauses (clauses)
Package

sxql.clause.

Source

clause.lisp.

Function: compute-select-statement-children (select-statement)
Package

sxql.statement.

Source

statement.lisp.

Function: create-index (index-name &rest args &key unique using on if-not-exists)
Package

sxql.

Source

sxql.lisp.

Function: detect-and-convert (object)
Package

sxql.operator.

Source

operator.lisp.

Function: drop-column (column-name)
Package

sxql.

Source

sxql.lisp.

Function: drop-index (index-name &key if-exists on)
Package

sxql.

Source

sxql.lisp.

Function: drop-primary-key ()
Package

sxql.

Source

sxql.lisp.

Function: explain (statement &key analyze verbose)
Package

sxql.

Source

sxql.lisp.

Function: find-constructor (name suffix &key package errorp)
Package

sxql.operator.

Source

operator.lisp.

Function: foreign-key (column-names &key references on-delete on-update)
Package

sxql.

Source

sxql.lisp.

Function: from-clause-table-name (from)
Package

sxql.clause.

Source

clause.lisp.

Function: group-by (key sequence &key test)
Package

sxql.util.

Source

util.lisp.

Function: index-key (&rest key-args)
Package

sxql.

Source

sxql.lisp.

Function: limit (count1 &optional count2)
Package

sxql.

Source

sxql.lisp.

Function: make-column-definition-clause (column-name &rest args &key type not-null default auto-increment autoincrement unique primary-key)
Package

sxql.clause.

Source

clause.lisp.

Function: make-conjunctive-op (name &rest expressions)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-function-op (name &rest expressions)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-infix-list-op (&key name left right)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-infix-op (name left right)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-infix-splicing-op (name left right)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-column-type (name &key args attrs)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-expression-list (&rest elements)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-keyword (name)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-list (&rest elements)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-splicing-expression-list (&rest elements)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-splicing-list (&rest elements)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-symbol (name)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-symbol* (tokens)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-sql-variable (value)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-type-keyword (type)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-unary-op (name var)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: make-unary-splicing-op (name var)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: merge-statements (statement defaults)
Package

sxql.statement.

Source

statement.lisp.

Function: modify-column (column-name &rest args)
Package

sxql.

Source

sxql.lisp.

Function: offset (offset)
Package

sxql.

Source

sxql.lisp.

Function: pragma (name &optional value)
Package

sxql.

Source

sxql.lisp.

Function: primary-key (&rest key-args)
Package

sxql.

Source

sxql.lisp.

Function: rename-to (new-table-name)
Package

sxql.

Source

sxql.lisp.

Reader: select-statement-clause-order (instance)
Writer: (setf select-statement-clause-order) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

clause-order.

Reader: select-statement-fields-clause (instance)
Writer: (setf select-statement-fields-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

fields-clause.

Reader: select-statement-from-clause (instance)
Writer: (setf select-statement-from-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

from-clause.

Reader: select-statement-group-by-clause (instance)
Writer: (setf select-statement-group-by-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

group-by-clause.

Reader: select-statement-having-clause (instance)
Writer: (setf select-statement-having-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

having-clause.

Reader: select-statement-join-clause (instance)
Writer: (setf select-statement-join-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

join-clause.

Reader: select-statement-limit-clause (instance)
Writer: (setf select-statement-limit-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

limit-clause.

Reader: select-statement-offset-clause (instance)
Writer: (setf select-statement-offset-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

offset-clause.

Reader: select-statement-order-by-clause (instance)
Writer: (setf select-statement-order-by-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

order-by-clause.

Reader: select-statement-returning-clause (instance)
Writer: (setf select-statement-returning-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

returning-clause.

Function: select-statement-table-name (select)
Package

sxql.statement.

Source

statement.lisp.

Reader: select-statement-updatability-clause (instance)
Writer: (setf select-statement-updatability-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

updatability-clause.

Reader: select-statement-where-clause (instance)
Writer: (setf select-statement-where-clause) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

where-clause.

Function: sort-clause-types (types)
Package

sxql.statement.

Source

statement.lisp.

Function: sql-compile (object)
Package

sxql.compile.

Source

compile.lisp.

Reader: sql-composed-statement-children (instance)
Writer: (setf sql-composed-statement-children) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

children.

Function: sql-expression-list-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Reader: sql-list-elements (instance)
Writer: (setf sql-list-elements) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

elements.

Reader: sql-statement-name (instance)
Writer: (setf sql-statement-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

name.

Reader: sql-variable-value (instance)
Writer: (setf sql-variable-value) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

value.

Function: subdivide (sequence chunk-size)

Split ‘sequence‘ into subsequences of size ‘chunk-size‘.

Package

sxql.util.

Source

util.lisp.

Function: union-all-queries (&rest queries)
Package

sxql.

Source

sxql.lisp.

Function: union-queries (&rest queries)
Package

sxql.

Source

sxql.lisp.

Function: unique-key (&rest key-args)
Package

sxql.

Source

sxql.lisp.


6.1.4 Generic functions

Generic Function: add-child (statement child)
Package

sxql.statement.

Source

statement.lisp.

Methods
Method: add-child ((statement sql-composed-statement) child)
Generic Function: convert-for-sql (object)
Package

sxql.operator.

Source

operator.lisp.

Methods
Method: convert-for-sql ((object number))
Method: convert-for-sql ((object string))
Method: convert-for-sql ((object vector))
Method: convert-for-sql ((object null))
Method: convert-for-sql ((object (eql t)))
Method: convert-for-sql ((object symbol))
Method: convert-for-sql ((object list))
Method: convert-for-sql ((object structure-object))
Method: convert-for-sql ((object standard-object))
Generic Function: make-clause (clause-name &rest args)
Package

sxql.clause.

Source

clause.lisp.

Methods
Method: make-clause ((clause-name (eql :on-conflict-do-update)) &rest args)
Method: make-clause ((clause-name (eql :on-conflict-do-nothing)) &rest args)
Method: make-clause ((clause-name (eql :add-primary-key)) &rest args)
Method: make-clause ((clause-name (eql :alter-column)) &rest args)
Method: make-clause ((clause-name (eql :change-column)) &rest args)
Method: make-clause ((clause-name (eql :modify-column)) &rest args)
Method: make-clause ((clause-name (eql :add-column)) &rest args)
Method: make-clause ((clause-name (eql :foreign-key)) &rest args)
Method: make-clause ((clause-name (eql :unique-key)) &rest args)
Method: make-clause ((clause-name (eql :primary-key)) &rest args)
Method: make-clause ((clause-name (eql :key)) &rest args)
Method: make-clause ((clause-name (eql :updatability)) &rest args)
Method: make-clause ((clause-name (eql :join)) &rest args)
Method: make-clause (clause-name &rest args)
Generic Function: make-op (op-name &rest args)
Package

sxql.operator.

Source

operator.lisp.

Methods
Method: make-op ((op-name (eql :asc)) &rest args)
Method: make-op ((op-name (eql :desc)) &rest args)
Method: make-op (op-name &rest args)
Generic Function: make-statement (statement-name &rest args)
Package

sxql.statement.

Source

statement.lisp.

Methods
Method: make-statement ((statement-name (eql :explain)) &rest args)
Method: make-statement ((statement-name (eql :pragma)) &rest args)
Method: make-statement ((statement-name (eql :drop-index)) &rest args)
Method: make-statement ((statement-name (eql :create-index)) &rest args)
Method: make-statement ((statement-name (eql :drop-table)) &rest args)
Method: make-statement ((statement-name (eql :create-table)) &rest args)
Method: make-statement ((statement-name (eql :insert-into)) &rest args)
Method: make-statement ((statement-name (eql :select)) &rest args)
Method: make-statement (statement-name &rest args)
Generic Function: yield (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Methods
Method: yield ((statement composed-statement))
Source

composed-statement.lisp.

Method: yield ((object sql-statement-compiled))
Source

compile.lisp.

Method: yield ((object sql-clause-compiled))
Source

compile.lisp.

Method: yield ((object sql-op-compiled))
Source

compile.lisp.

Method: yield ((statement explain-statement))
Source

statement.lisp.

Method: yield ((statement pragma-statement))
Source

statement.lisp.

Method: yield ((statement drop-index-statement))
Source

statement.lisp.

Method: yield ((statement create-index-statement))
Source

statement.lisp.

Method: yield ((statement insert-into-statement))
Source

statement.lisp.

Method: yield ((statement alter-table-statement))
Source

statement.lisp.

Method: yield ((statement drop-table-statement))
Source

statement.lisp.

Method: yield ((statement create-table-statement))
Source

statement.lisp.

Method: yield :before ((statement select-statement))
Source

statement.lisp.

Method: yield ((statement select-statement))
Source

statement.lisp.

Method: yield ((clause set=-clause))
Source

clause.lisp.

Method: yield ((clause join-clause))
Source

clause.lisp.

Method: yield ((clause offset-clause))
Source

clause.lisp.

Method: yield ((clause limit-clause))
Source

clause.lisp.

Method: yield ((clause on-conflict-do-update-clause))
Source

clause.lisp.

Method: yield ((clause on-conflict-do-nothing-clause))
Source

clause.lisp.

Method: yield ((clause on-duplicate-key-update-clause))
Source

clause.lisp.

Method: yield ((clause drop-primary-key-clause))
Source

clause.lisp.

Method: yield ((clause column-definition-clause))
Source

clause.lisp.

Method: yield ((clause alter-column-clause))
Source

clause.lisp.

Method: yield ((clause column-modifier-clause))
Source

clause.lisp.

Method: yield ((clause on-clause))
Source

clause.lisp.

Method: yield ((clause key-clause))
Source

clause.lisp.

Method: yield ((obj updatability-clause))
Source

clause.lisp.

Method: yield ((op else-op))
Source

operator.lisp.

Method: yield ((op when-op))
Source

operator.lisp.

Method: yield ((op case-op))
Source

operator.lisp.

Method: yield ((op union-all-op))
Source

operator.lisp.

Method: yield ((op union-op))
Source

operator.lisp.

Method: yield ((op as-op))
Source

operator.lisp.

Method: yield ((raw splicing-raw-op))
Source

operator.lisp.

Method: yield ((raw raw-op))
Source

operator.lisp.

Method: yield ((op order-op))
Source

operator.lisp.

Method: yield ((op not-null-op))
Source

operator.lisp.

Method: yield ((op is-null-op))
Source

operator.lisp.

Method: yield :around (object)
Method: yield ((statement sql-composed-statement))
Method: yield ((clause expression-list-clause))
Method: yield ((clause statement-clause))
Method: yield ((clause expression-clause))
Method: yield ((type sql-column-type))
Method: yield ((op function-op))
Method: yield ((op conjunctive-op))
Method: yield ((op infix-list-op))
Method: yield ((op infix-splicing-op))
Method: yield ((op infix-op))
Method: yield ((op unary-postfix-op))
Method: yield ((op unary-splicing-op))
Method: yield ((op unary-op))
Method: yield ((list sql-splicing-expression-list))
Method: yield ((list sql-expression-list))
Method: yield ((list sql-splicing-list))
Method: yield ((list sql-list))
Method: yield ((var sql-variable))
Method: yield ((keyword sql-keyword))
Method: yield ((symbol sql-symbol))
Method: yield ((var-list list))

6.1.5 Standalone methods

Method: print-object ((statement composed-statement) stream)
Source

composed-statement.lisp.

Method: print-object ((clause sql-clause) stream)
Source

sql-type.lisp.

Method: print-object ((clause sql-statement) stream)
Source

sql-type.lisp.

Method: print-object ((op sql-op) stream)
Source

sql-type.lisp.

Method: print-object ((object sql-clause-compiled) stream)
Source

compile.lisp.

Method: print-object ((object sql-statement-compiled) stream)
Source

compile.lisp.

Method: print-object ((object sql-op-compiled) stream)
Source

compile.lisp.


6.1.6 Structures

Structure: alter-table-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"alter table"

Readers

alter-table-statement-name.

Writers

(setf alter-table-statement-name).

Slot: table
Type

sxql.sql-type:sql-symbol

Readers

alter-table-statement-table.

Writers

(setf alter-table-statement-table).

Slot: children
Package

sxql.sql-type.

Readers

alter-table-statement-children.

Writers

(setf alter-table-statement-children).

Structure: column-definition-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

sql-clause.

Direct methods

yield.

Direct slots
Slot: column-name
Readers

column-definition-clause-column-name.

Writers

(setf column-definition-clause-column-name).

Slot: type
Package

common-lisp.

Readers

column-definition-clause-type.

Writers

(setf column-definition-clause-type).

Slot: not-null
Readers

column-definition-clause-not-null.

Writers

(setf column-definition-clause-not-null).

Slot: default
Readers

column-definition-clause-default.

Writers

(setf column-definition-clause-default).

Slot: auto-increment
Readers

column-definition-clause-auto-increment.

Writers

(setf column-definition-clause-auto-increment).

Slot: autoincrement
Readers

column-definition-clause-autoincrement.

Writers

(setf column-definition-clause-autoincrement).

Slot: unique
Readers

column-definition-clause-unique.

Writers

(setf column-definition-clause-unique).

Slot: primary-key
Readers

column-definition-clause-primary-key.

Writers

(setf column-definition-clause-primary-key).

Structure: composed-statement
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: statements
Readers

composed-statement-statements.

Writers

(setf composed-statement-statements).

Structure: conjunctive-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-op.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: expressions
Type

(and trivial-types:proper-list (satisfies sxql.sql-type::sql-statement-list-p))

Readers

conjunctive-op-expressions.

Writers

(setf conjunctive-op-expressions).

Structure: create-index-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"create index"

Readers

create-index-statement-name.

Writers

(setf create-index-statement-name).

Slot: index-name
Type

sxql.sql-type:sql-symbol

Readers

create-index-statement-index-name.

Writers

(setf create-index-statement-index-name).

Slot: table-name
Type

sxql.sql-type:sql-symbol

Readers

create-index-statement-table-name.

Writers

(setf create-index-statement-table-name).

Slot: columns
Type

sxql.sql-type:sql-list

Readers

create-index-statement-columns.

Writers

(setf create-index-statement-columns).

Slot: unique
Type

boolean

Readers

create-index-statement-unique.

Writers

(setf create-index-statement-unique).

Slot: using
Type

(or null sxql.sql-type:sql-keyword)

Readers

create-index-statement-using.

Writers

(setf create-index-statement-using).

Slot: if-not-exists
Type

boolean

Readers

create-index-statement-if-not-exists.

Writers

(setf create-index-statement-if-not-exists).

Structure: create-table-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-composed-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"create table"

Readers

create-table-statement-name.

Writers

(setf create-table-statement-name).

Slot: table
Readers

create-table-statement-table.

Writers

(setf create-table-statement-table).

Slot: if-not-exists
Type

boolean

Readers

create-table-statement-if-not-exists.

Writers

(setf create-table-statement-if-not-exists).

Structure: delete-from-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-composed-statement.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"delete from"

Readers

delete-from-statement-name.

Writers

(setf delete-from-statement-name).

Structure: drop-index-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"drop index"

Readers

drop-index-statement-name.

Writers

(setf drop-index-statement-name).

Slot: index-name
Type

sxql.sql-type:sql-symbol

Readers

drop-index-statement-index-name.

Writers

(setf drop-index-statement-index-name).

Slot: if-exists
Type

boolean

Readers

drop-index-statement-if-exists.

Writers

(setf drop-index-statement-if-exists).

Slot: on
Type

(or null sxql.sql-type:sql-symbol)

Readers

drop-index-statement-on.

Writers

(setf drop-index-statement-on).

Structure: drop-table-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"drop table"

Readers

drop-table-statement-name.

Writers

(setf drop-table-statement-name).

Slot: table
Type

sxql.sql-type:sql-symbol

Readers

drop-table-statement-table.

Writers

(setf drop-table-statement-table).

Slot: if-exists
Type

boolean

Readers

drop-table-statement-if-exists.

Writers

(setf drop-table-statement-if-exists).

Structure: explain-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"explain"

Readers

explain-statement-name.

Writers

(setf explain-statement-name).

Slot: statement
Package

sxql.sql-type.

Readers

explain-statement-statement.

Writers

(setf explain-statement-statement).

Slot: analyze
Type

boolean

Readers

explain-statement-analyze.

Writers

(setf explain-statement-analyze).

Slot: verbose
Type

boolean

Readers

explain-statement-verbose.

Writers

(setf explain-statement-verbose).

Structure: expression-clause
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-clause.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: expression
Type

(or sxql.sql-type:sql-expression sxql.sql-type:sql-expression-list)

Readers

expression-clause-expression.

Writers

(setf expression-clause-expression).

Structure: expression-list-clause
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-clause.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: expressions
Type

(and trivial-types:proper-list (satisfies sxql.sql-type:sql-expression-list-p))

Readers

expression-list-clause-expressions.

Writers

(setf expression-list-clause-expressions).

Structure: fields-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

statement-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

""

Readers

fields-clause-name.

Writers

(setf fields-clause-name).

Structure: foreign-key-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"foreign key"

Readers

foreign-key-clause-name.

Writers

(setf foreign-key-clause-name).

Slot: column-names
Type

sxql.sql-type:sql-list

Readers

foreign-key-clause-column-names.

Writers

(setf foreign-key-clause-column-names).

Slot: references
Type

sxql.clause:references-clause

Readers

foreign-key-clause-references.

Writers

(setf foreign-key-clause-references).

Structure: from-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

statement-clause.

Direct methods

yield-only-contents.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"from"

Readers

from-clause-name.

Writers

(setf from-clause-name).

Structure: function-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

conjunctive-op.

Direct methods

yield.

Structure: group-by-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-list-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"group by"

Readers

group-by-clause-name.

Writers

(setf group-by-clause-name).

Structure: having-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"having"

Readers

having-clause-name.

Writers

(setf having-clause-name).

Structure: infix-list-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-op.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: left
Type

sxql.sql-type:sql-expression

Readers

infix-list-op-left.

Writers

(setf infix-list-op-left).

Slot: right
Type

(or trivial-types:proper-list sxql.sql-type:sql-statement)

Readers

infix-list-op-right.

Writers

(setf infix-list-op-right).

Structure: infix-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-op.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: left
Type

(or sxql.sql-type:sql-statement sxql.sql-type:sql-expression sxql.sql-type:sql-expression-list)

Readers

infix-op-left.

Writers

(setf infix-op-left).

Slot: right
Type

(or sxql.sql-type:sql-statement sxql.sql-type:sql-expression sxql.sql-type:sql-expression-list)

Readers

infix-op-right.

Writers

(setf infix-op-right).

Structure: infix-splicing-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

infix-op.

Direct subclasses

as-op.

Direct methods

yield.

Structure: insert-into-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-composed-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"insert into"

Readers

insert-into-statement-name.

Writers

(setf insert-into-statement-name).

Structure: join-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

statement-clause.

Direct methods

yield.

Direct slots
Slot: kind
Type

(or (eql :inner) (eql :left) (eql :right) (eql :full))

Initform

:inner

Readers

join-clause-kind.

Writers

(setf join-clause-kind).

Slot: on
Type

(or null sxql.sql-type:sql-expression)

Readers

join-clause-on.

Writers

(setf join-clause-on).

Slot: using
Type

(or null sxql.sql-type:sql-symbol sxql.sql-type:sql-list)

Readers

join-clause-using.

Writers

(setf join-clause-using).

Structure: key-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"key"

Readers

key-clause-name.

Writers

(setf key-clause-name).

Slot: key-name
Type

(or null sxql.sql-type:sql-variable)

Readers

key-clause-key-name.

Writers

(setf key-clause-key-name).

Slot: keys
Readers

key-clause-keys.

Writers

(setf key-clause-keys).

Structure: limit-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-list-clause.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"limit"

Readers

limit-clause-name.

Writers

(setf limit-clause-name).

Slot: count1
Type

sxql.sql-type:sql-variable

Readers

limit-clause-count1.

Writers

(setf limit-clause-count1).

Slot: count2
Type

(or null sxql.sql-type:sql-variable)

Readers

limit-clause-count2.

Writers

(setf limit-clause-count2).

Structure: offset-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

sql-clause.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"offset"

Readers

offset-clause-name.

Writers

(setf offset-clause-name).

Slot: offset
Type

sxql.sql-type:sql-variable

Readers

offset-clause-offset.

Writers

(setf offset-clause-offset).

Structure: order-by-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-list-clause.

Direct methods

yield-only-contents.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"order by"

Readers

order-by-clause-name.

Writers

(setf order-by-clause-name).

Structure: pragma-statement

A statement for PRAGMA statement available in SQLITE. See https://www.sqlite.org/pragma.html

Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-statement.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"pragma"

Readers

pragma-statement-name.

Writers

(setf pragma-statement-name).

Slot: pragma-name
Readers

pragma-statement-pragma-name.

Writers

(setf pragma-statement-pragma-name).

Slot: value
Readers

pragma-statement-value.

Writers

(setf pragma-statement-value).

Structure: primary-key-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

key-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"primary key"

Readers

primary-key-clause-name.

Writers

(setf primary-key-clause-name).

Structure: references-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"references"

Readers

references-clause-name.

Writers

(setf references-clause-name).

Slot: table-name
Type

sxql.sql-type:sql-symbol

Readers

references-clause-table-name.

Writers

(setf references-clause-table-name).

Slot: column-names
Type

sxql.sql-type:sql-list

Readers

references-clause-column-names.

Writers

(setf references-clause-column-names).

Structure: returning-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-list-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"returning"

Readers

returning-clause-name.

Writers

(setf returning-clause-name).

Structure: select-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-composed-statement.

Direct methods
Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"select"

Readers

select-statement-name.

Writers

(setf select-statement-name).

Slot: clause-order
Readers

select-statement-clause-order.

Writers

(setf select-statement-clause-order).

Slot: fields-clause
Package

sxql.clause.

Readers

select-statement-fields-clause.

Writers

(setf select-statement-fields-clause).

Slot: from-clause
Package

sxql.clause.

Readers

select-statement-from-clause.

Writers

(setf select-statement-from-clause).

Slot: join-clause
Package

sxql.clause.

Readers

select-statement-join-clause.

Writers

(setf select-statement-join-clause).

Slot: where-clause
Package

sxql.clause.

Readers

select-statement-where-clause.

Writers

(setf select-statement-where-clause).

Slot: group-by-clause
Package

sxql.clause.

Readers

select-statement-group-by-clause.

Writers

(setf select-statement-group-by-clause).

Slot: having-clause
Package

sxql.clause.

Readers

select-statement-having-clause.

Writers

(setf select-statement-having-clause).

Slot: returning-clause
Package

sxql.clause.

Readers

select-statement-returning-clause.

Writers

(setf select-statement-returning-clause).

Slot: order-by-clause
Package

sxql.clause.

Readers

select-statement-order-by-clause.

Writers

(setf select-statement-order-by-clause).

Slot: limit-clause
Package

sxql.clause.

Readers

select-statement-limit-clause.

Writers

(setf select-statement-limit-clause).

Slot: offset-clause
Package

sxql.clause.

Readers

select-statement-offset-clause.

Writers

(setf select-statement-offset-clause).

Slot: updatability-clause
Package

sxql.clause.

Readers

select-statement-updatability-clause.

Writers

(setf select-statement-updatability-clause).

Structure: set=-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

sql-clause.

Direct methods

yield.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"set"

Readers

set=-clause-name.

Writers

(setf set=-clause-name).

Slot: args
Type

(and trivial-types:proper-list (satisfies sxql.sql-type:sql-expression-list-p))

Readers

set=-clause-args.

Writers

(setf set=-clause-args).

Structure: sql-atom
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses
Structure: sql-clause
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Initform

""

Readers

sql-clause-name.

Writers

(setf sql-clause-name).

Structure: sql-column-type
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct methods

yield.

Direct slots
Slot: name
Readers

sql-column-type-name.

Writers

(setf sql-column-type-name).

Slot: args
Type

list

Readers

sql-column-type-args.

Writers

(setf sql-column-type-args).

Slot: attrs
Type

list

Readers

sql-column-type-attrs.

Writers

(setf sql-column-type-attrs).

Structure: sql-composed-statement
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-statement.

Direct subclasses
Direct methods
Direct slots
Slot: children
Type

trivial-types:proper-list

Readers

sql-composed-statement-children.

Writers

(setf sql-composed-statement-children).

Structure: sql-expression-list
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses

sql-splicing-expression-list.

Direct methods

yield.

Direct slots
Slot: elements
Type

(and trivial-types:proper-list (satisfies sxql.sql-type:sql-expression-list-p))

Readers

sql-expression-list-elements.

Writers

(setf sql-expression-list-elements).

Structure: sql-keyword
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-atom.

Direct methods

yield.

Direct slots
Slot: name
Type

string

Readers

sql-keyword-name.

Writers

(setf sql-keyword-name).

Structure: sql-list
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses

sql-splicing-list.

Direct methods

yield.

Direct slots
Slot: elements
Type

trivial-types:proper-list

Readers

sql-list-elements.

Writers

(setf sql-list-elements).

Structure: sql-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Readers

sql-op-name.

Writers

(setf sql-op-name).

Structure: sql-splicing-expression-list
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-expression-list.

Direct methods

yield.

Structure: sql-statement
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Initform

""

Readers

sql-statement-name.

Writers

(setf sql-statement-name).

Structure: sql-symbol
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-atom.

Direct methods

yield.

Direct slots
Slot: name
Type

string

Readers

sql-symbol-name.

Writers

(setf sql-symbol-name).

Slot: tokens
Type

cons

Readers

sql-symbol-tokens.

Writers

(setf sql-symbol-tokens).

Structure: sql-variable
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-atom.

Direct methods

yield.

Direct slots
Slot: value
Type

(or string number (vector (unsigned-byte 8)) array)

Readers

sql-variable-value.

Writers

(setf sql-variable-value).

Structure: statement-clause
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-clause.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: statement
Type

(or sxql.sql-type:sql-expression sxql.sql-type:sql-expression-list sxql.sql-type:sql-statement)

Readers

statement-clause-statement.

Writers

(setf statement-clause-statement).

Structure: unary-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

sql-op.

Direct subclasses
Direct methods

yield.

Direct slots
Slot: var
Type

sxql.sql-type:sql-expression

Readers

unary-op-var.

Writers

(setf unary-op-var).

Structure: unary-postfix-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

unary-op.

Direct subclasses

order-op.

Direct methods

yield.

Structure: unary-splicing-op
Package

sxql.sql-type.

Source

sql-type.lisp.

Direct superclasses

unary-op.

Direct subclasses

distinct-op.

Direct methods

yield.

Structure: unique-key-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

key-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"unique"

Readers

unique-key-clause-name.

Writers

(setf unique-key-clause-name).

Structure: updatability-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

statement-clause.

Direct methods

yield.

Direct slots
Slot: update-type
Type

keyword

Initform

:update

Readers

updatability-clause-update-type.

Writers

(setf updatability-clause-update-type).

Slot: idents
Type

list

Initform

(quote nil)

Readers

updatability-clause-idents.

Writers

(setf updatability-clause-idents).

Slot: nowait
Type

boolean

Readers

updatability-clause-nowait.

Writers

(setf updatability-clause-nowait).

Structure: update-statement
Package

sxql.statement.

Source

statement.lisp.

Direct superclasses

sql-composed-statement.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"update"

Readers

update-statement-name.

Writers

(setf update-statement-name).

Structure: values-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"values"

Readers

values-clause-name.

Writers

(setf values-clause-name).

Structure: where-clause
Package

sxql.clause.

Source

clause.lisp.

Direct superclasses

expression-clause.

Direct methods

yield-only-contents.

Direct slots
Slot: name
Package

sxql.sql-type.

Type

string

Initform

"where"

Readers

where-clause-name.

Writers

(setf where-clause-name).


6.1.7 Types

Type: select-statement-designator ()
Package

sxql.

Source

sxql.lisp.

Type: sql-clause-list ()
Package

sxql.sql-type.

Source

sql-type.lisp.

Type: sql-expression ()
Package

sxql.sql-type.

Source

sql-type.lisp.


6.2 Internals


6.2.1 Special variables

Special Variable: *bind-values*
Package

sxql.sql-type.

Source

sql-type.lisp.

Special Variable: *clause-delimiters*
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Special Variable: *clause-priority*
Package

sxql.statement.

Source

statement.lisp.

Special Variable: *inside-function-op*
Package

sxql.sql-type.

Source

sql-type.lisp.

Special Variable: *table-name-scope*
Package

sxql.sql-type.

Source

sql-type.lisp.

Special Variable: *use-global-bind-values*
Package

sxql.sql-type.

Source

sql-type.lisp.


6.2.2 Macros

Macro: define-compile-struct (structure-name &rest defstruct-options)
Package

sxql.compile.

Source

compile.lisp.

Macro: define-op ((op-name struct-type &key sql-op-name include-slots package) &body body)
Package

sxql.operator.

Source

operator.lisp.

Macro: yield-for-union-ops (keyword)
Package

sxql.operator.

Source

operator.lisp.


6.2.3 Ordinary functions

Function: !=-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf !=-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: !=-op-name (instance)
Writer: (setf !=-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: !=-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: !=-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf !=-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: %-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf %-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: %-op-name (instance)
Writer: (setf %-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: %-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: %make-column-definition-clause (column-name &key type not-null default auto-increment autoincrement unique primary-key)
Package

sxql.clause.

Source

clause.lisp.

Function: %make-on-conflict-do-update-clause (conflict-target update-set &optional where-condition)
Package

sxql.clause.

Source

clause.lisp.

Function: %make-on-duplicate-key-update-clause (&rest args)
Package

sxql.clause.

Source

clause.lisp.

Function: %make-set=-clause (&rest args)
Package

sxql.clause.

Source

clause.lisp.

Function: %make-sql-symbol (&key name tokens)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: *-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf *-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: *-op-name (instance)
Writer: (setf *-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: *-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: +-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf +-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: +-op-name (instance)
Writer: (setf +-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: +-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: --op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf --op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: --op-name (instance)
Writer: (setf --op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: --op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: /-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf /-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: /-op-name (instance)
Writer: (setf /-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: /-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: <-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf <-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: <-op-name (instance)
Writer: (setf <-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: <-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: <-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf <-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: <=-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf <=-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: <=-op-name (instance)
Writer: (setf <=-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: <=-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: <=-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf <=-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: =-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf =-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: =-op-name (instance)
Writer: (setf =-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: =-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: =-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf =-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: >-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf >-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: >-op-name (instance)
Writer: (setf >-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: >-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: >-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf >-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: >=-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf >=-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: >=-op-name (instance)
Writer: (setf >=-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: >=-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: >=-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf >=-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: a<-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf a<-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: a<-op-name (instance)
Writer: (setf a<-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: a<-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: a<-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf a<-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: a>-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf a>-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: a>-op-name (instance)
Writer: (setf a>-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: a>-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: a>-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf a>-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: add-column-clause-after (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf add-column-clause-after) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: add-column-clause-column-definition (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf add-column-clause-column-definition) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: add-column-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf add-column-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: add-column-clause-first (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf add-column-clause-first) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: add-column-clause-name (instance)
Writer: (setf add-column-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: add-column-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: add-primary-key-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf add-primary-key-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: add-primary-key-clause-name (instance)
Writer: (setf add-primary-key-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: add-primary-key-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: alter-column-clause-column-name (instance)
Writer: (setf alter-column-clause-column-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

column-name.

Reader: alter-column-clause-drop-default (instance)
Writer: (setf alter-column-clause-drop-default) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

drop-default.

Reader: alter-column-clause-name (instance)
Writer: (setf alter-column-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Reader: alter-column-clause-not-null (instance)
Writer: (setf alter-column-clause-not-null) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

not-null.

Function: alter-column-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: alter-column-clause-set-default (instance)
Writer: (setf alter-column-clause-set-default) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

set-default.

Reader: alter-column-clause-type (instance)
Writer: (setf alter-column-clause-type) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

type.

Reader: alter-table-statement-children (instance)
Writer: (setf alter-table-statement-children) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

children.

Reader: alter-table-statement-name (instance)
Writer: (setf alter-table-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: alter-table-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: alter-table-statement-table (instance)
Writer: (setf alter-table-statement-table) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

table.

Function: and-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf and-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: and-op-name (instance)
Writer: (setf and-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: and-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: as-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf as-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: as-op-name (instance)
Writer: (setf as-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: as-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: as-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf as-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: asc-op-name (instance)
Writer: (setf asc-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: asc-op-nulls (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf asc-op-nulls) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: asc-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: asc-op-var (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf asc-op-var) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: case-op-expressions (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf case-op-expressions) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: case-op-name (instance)
Writer: (setf case-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: case-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: change-column-clause-after (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf change-column-clause-after) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: change-column-clause-column-definition (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf change-column-clause-column-definition) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: change-column-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf change-column-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: change-column-clause-first (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf change-column-clause-first) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: change-column-clause-name (instance)
Writer: (setf change-column-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: change-column-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: column-definition-clause-auto-increment (instance)
Writer: (setf column-definition-clause-auto-increment) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

auto-increment.

Reader: column-definition-clause-autoincrement (instance)
Writer: (setf column-definition-clause-autoincrement) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

autoincrement.

Reader: column-definition-clause-column-name (instance)
Writer: (setf column-definition-clause-column-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

column-name.

Reader: column-definition-clause-default (instance)
Writer: (setf column-definition-clause-default) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

default.

Function: column-definition-clause-name (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf column-definition-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: column-definition-clause-not-null (instance)
Writer: (setf column-definition-clause-not-null) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

not-null.

Function: column-definition-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: column-definition-clause-primary-key (instance)
Writer: (setf column-definition-clause-primary-key) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

primary-key.

Reader: column-definition-clause-type (instance)
Writer: (setf column-definition-clause-type) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

type.

Reader: column-definition-clause-unique (instance)
Writer: (setf column-definition-clause-unique) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

unique.

Reader: column-modifier-clause-after (instance)
Writer: (setf column-modifier-clause-after) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

after.

Reader: column-modifier-clause-column-definition (instance)
Writer: (setf column-modifier-clause-column-definition) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

column-definition.

Function: column-modifier-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf column-modifier-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: column-modifier-clause-first (instance)
Writer: (setf column-modifier-clause-first) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

first.

Function: column-modifier-clause-name (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf column-modifier-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: column-modifier-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: composed-statement-p (object)
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Reader: composed-statement-statements (instance)
Writer: (setf composed-statement-statements) (instance)
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Target Slot

statements.

Reader: conjunctive-op-expressions (instance)
Writer: (setf conjunctive-op-expressions) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

expressions.

Function: conjunctive-op-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf conjunctive-op-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: conjunctive-op-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: convert-if-fields-clause (clause)
Package

sxql.

Source

sxql.lisp.

Function: copy-!=-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-%-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-*-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-+-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy---op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-/-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-<-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-<=-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-=-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy->-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy->=-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-a<-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-a>-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-add-column-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-add-primary-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-alter-column-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-alter-table-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-and-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-as-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-asc-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-case-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-change-column-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-column-definition-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-column-modifier-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-composed-statement (instance)
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Function: copy-conjunctive-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-create-index-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-create-table-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-delete-from-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-desc-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-distinct-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-drop-column-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-drop-index-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-drop-primary-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-drop-table-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-else-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-explain-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-expression-clause (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-expression-list-clause (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-fields-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-foreign-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-from-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-function-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-group-by-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-having-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-in-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-infix-list-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-infix-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-infix-splicing-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-insert-into-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-is-distinct-from-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-is-not-distinct-from-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-is-null-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-join-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-like-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-limit-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-modify-column-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-not-in-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-not-null-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-not-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-offset-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-conflict-do-nothing-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-conflict-do-update-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-delete-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-duplicate-key-update-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-on-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-on-update-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-or-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-order-by-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-order-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-pragma-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-primary-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-raw-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-references-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-rename-to-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-returning-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-scoped-clause (instance)
Package

sxql.composed-statement.

Source

composed-statement.lisp.

Function: copy-select-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-set=-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-similar-to-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-splicing-raw-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-sql-atom (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-clause (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-clause-compiled (instance)
Package

sxql.compile.

Source

compile.lisp.

Function: copy-sql-column-type (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-composed-statement (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-expression-list (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-keyword (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-list (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-op-compiled (instance)
Package

sxql.compile.

Source

compile.lisp.

Function: copy-sql-splicing-expression-list (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-splicing-list (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-statement (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-statement-compiled (instance)
Package

sxql.compile.

Source

compile.lisp.

Function: copy-sql-symbol (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-sql-variable (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-statement-clause (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-unary-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-unary-postfix-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-unary-splicing-op (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: copy-union-all-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-union-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-unique-key-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-updatability-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-update-statement (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: copy-values-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: copy-when-op (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: copy-where-clause (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: create-index-statement-columns (instance)
Writer: (setf create-index-statement-columns) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

columns.

Reader: create-index-statement-if-not-exists (instance)
Writer: (setf create-index-statement-if-not-exists) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

if-not-exists.

Reader: create-index-statement-index-name (instance)
Writer: (setf create-index-statement-index-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

index-name.

Reader: create-index-statement-name (instance)
Writer: (setf create-index-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: create-index-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: create-index-statement-table-name (instance)
Writer: (setf create-index-statement-table-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

table-name.

Reader: create-index-statement-unique (instance)
Writer: (setf create-index-statement-unique) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

unique.

Reader: create-index-statement-using (instance)
Writer: (setf create-index-statement-using) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

using.

Function: create-table-statement-children (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: (setf create-table-statement-children) (instance)
Package

sxql.statement.

Source

statement.lisp.

Reader: create-table-statement-if-not-exists (instance)
Writer: (setf create-table-statement-if-not-exists) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

if-not-exists.

Reader: create-table-statement-name (instance)
Writer: (setf create-table-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: create-table-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: create-table-statement-table (instance)
Writer: (setf create-table-statement-table) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

table.

Function: delete-from-statement-children (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: (setf delete-from-statement-children) (instance)
Package

sxql.statement.

Source

statement.lisp.

Reader: delete-from-statement-name (instance)
Writer: (setf delete-from-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: delete-from-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: desc-op-name (instance)
Writer: (setf desc-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: desc-op-nulls (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf desc-op-nulls) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: desc-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: desc-op-var (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf desc-op-var) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: distinct-op-name (instance)
Writer: (setf distinct-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: distinct-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: distinct-op-var (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf distinct-op-var) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: drop-column-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf drop-column-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: drop-column-clause-name (instance)
Writer: (setf drop-column-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: drop-column-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: drop-index-statement-if-exists (instance)
Writer: (setf drop-index-statement-if-exists) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

if-exists.

Reader: drop-index-statement-index-name (instance)
Writer: (setf drop-index-statement-index-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

index-name.

Reader: drop-index-statement-name (instance)
Writer: (setf drop-index-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Reader: drop-index-statement-on (instance)
Writer: (setf drop-index-statement-on) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

on.

Function: drop-index-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: drop-primary-key-clause-name (instance)
Writer: (setf drop-primary-key-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: drop-primary-key-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: drop-table-statement-if-exists (instance)
Writer: (setf drop-table-statement-if-exists) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

if-exists.

Reader: drop-table-statement-name (instance)
Writer: (setf drop-table-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: drop-table-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: drop-table-statement-table (instance)
Writer: (setf drop-table-statement-table) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

table.

Reader: else-op-name (instance)
Writer: (setf else-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: else-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: else-op-var (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf else-op-var) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: expand-expression (expressions)
Package

sxql.

Source

sxql.lisp.

Function: expand-op (object)
Package

sxql.

Source

sxql.lisp.

Reader: explain-statement-analyze (instance)
Writer: (setf explain-statement-analyze) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

analyze.

Reader: explain-statement-name (instance)
Writer: (setf explain-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: explain-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Reader: explain-statement-statement (instance)
Writer: (setf explain-statement-statement) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

statement.

Reader: explain-statement-verbose (instance)
Writer: (setf explain-statement-verbose) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

verbose.

Reader: expression-clause-expression (instance)
Writer: (setf expression-clause-expression) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

expression.

Function: expression-clause-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf expression-clause-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: expression-clause-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Reader: expression-list-clause-expressions (instance)
Writer: (setf expression-list-clause-expressions) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

expressions.

Function: expression-list-clause-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf expression-list-clause-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: expression-list-clause-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Reader: fields-clause-name (instance)
Writer: (setf fields-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: fields-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: fields-clause-statement (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf fields-clause-statement) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: find-make-clause (clause-name &optional package)
Package

sxql.clause.

Source

clause.lisp.

Function: find-make-op (op-name &optional package)
Package

sxql.operator.

Source

operator.lisp.

Function: find-make-statement (statement-name &optional package)
Package

sxql.statement.

Source

statement.lisp.

Reader: foreign-key-clause-column-names (instance)
Writer: (setf foreign-key-clause-column-names) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

column-names.

Function: foreign-key-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf foreign-key-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: foreign-key-clause-name (instance)
Writer: (setf foreign-key-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: foreign-key-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Reader: foreign-key-clause-references (instance)
Writer: (setf foreign-key-clause-references) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

references.

Reader: from-clause-name (instance)
Writer: (setf from-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: from-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: from-clause-statement (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf from-clause-statement) (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: function-op-expressions (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf function-op-expressions) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: function-op-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf function-op-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: function-op-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: group-by-clause-expressions (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf group-by-clause-expressions) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: group-by-clause-name (instance)
Writer: (setf group-by-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: group-by-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: has-lower-case-letters-p (symbol)

Take in a symbol, convert to string, look for presences of lower case letters.

Package

sxql.operator.

Source

operator.lisp.

Function: having-clause-expression (instance)
Package

sxql.clause.

Source

clause.lisp.

Function: (setf having-clause-expression) (instance)
Package

sxql.clause.

Source

clause.lisp.

Reader: having-clause-name (instance)
Writer: (setf having-clause-name) (instance)
Package

sxql.clause.

Source

clause.lisp.

Target Slot

name.

Function: having-clause-p (object)
Package

sxql.clause.

Source

clause.lisp.

Function: in-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf in-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: in-op-name (instance)
Writer: (setf in-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: in-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: in-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf in-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: infix-list-op-left (instance)
Writer: (setf infix-list-op-left) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

left.

Function: infix-list-op-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf infix-list-op-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: infix-list-op-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Reader: infix-list-op-right (instance)
Writer: (setf infix-list-op-right) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

right.

Reader: infix-op-left (instance)
Writer: (setf infix-op-left) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

left.

Function: infix-op-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf infix-op-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: infix-op-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Reader: infix-op-right (instance)
Writer: (setf infix-op-right) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Target Slot

right.

Function: infix-splicing-op-left (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf infix-splicing-op-left) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: infix-splicing-op-name (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf infix-splicing-op-name) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: infix-splicing-op-p (object)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: infix-splicing-op-right (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: (setf infix-splicing-op-right) (instance)
Package

sxql.sql-type.

Source

sql-type.lisp.

Function: insert-into-statement-children (instance)
Package

sxql.statement.

Source

statement.lisp.

Function: (setf insert-into-statement-children) (instance)
Package

sxql.statement.

Source

statement.lisp.

Reader: insert-into-statement-name (instance)
Writer: (setf insert-into-statement-name) (instance)
Package

sxql.statement.

Source

statement.lisp.

Target Slot

name.

Function: insert-into-statement-p (object)
Package

sxql.statement.

Source

statement.lisp.

Function: is-distinct-from-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf is-distinct-from-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: is-distinct-from-op-name (instance)
Writer: (setf is-distinct-from-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: is-distinct-from-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: is-distinct-from-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf is-distinct-from-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: is-not-distinct-from-op-left (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf is-not-distinct-from-op-left) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: is-not-distinct-from-op-name (instance)
Writer: (setf is-not-distinct-from-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: is-not-distinct-from-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: is-not-distinct-from-op-right (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf is-not-distinct-from-op-right) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: is-null-op-name (instance)
Writer: (setf is-null-op-name) (instance)
Package

sxql.operator.

Source

operator.lisp.

Target Slot

name.

Function: is-null-op-p (object)
Package

sxql.operator.

Source

operator.lisp.

Function: is-null-op-var (instance)
Package

sxql.operator.

Source

operator.lisp.

Function: (setf is-null-op-var) (instance)
Package

sxql.operator.

Source

operator.lisp.

Reader: join-clause-kind (instance)