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 Mon Nov 06 15:00:22 2023 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.syntax

Source

syntax.lisp.

Use List

common-lisp.

Used By List
Public Interface

enable-syntax (macro).


5.2 sxql.composed-statement

Source

composed-statement.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.3 sxql.operator

Source

operator.lisp.

Use List
Used By List

sxql.clause.

Public Interface
Internals

5.4 sxql.sql-type

Source

sql-type.lisp.

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

5.5 sxql.statement

Source

statement.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.6 sxql.util

Source

util.lisp.

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

5.7 sxql.clause

Source

clause.lisp.

Use List
Used By List

sxql.

Public Interface
Internals

5.9 sxql

Source

sxql.lisp.

Use List
Public Interface
Internals

5.10 sxql-asd

Source

sxql.asd.

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

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 ((op sql-op) stream)
Source

sql-type.lisp.

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

sql-type.lisp.

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

sql-type.lisp.

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

compile.lisp.

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

compile.lisp.

Method: print-object ((object sql-statement-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)