The sxql Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The sxql Reference Manual

This is the sxql Reference Manual, version 0.0.1, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:23:49 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

SxQL - A SQL generator.

Build Status

Usage

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

(yield *)

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

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

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

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

SQL Statements

select (field &body clauses)

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

(select ((:+ 1 1)))
;=> #<SXQL-STATEMENT: SELECT (1 + 1)>

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

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

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

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

insert-into (table &body clauses)

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

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

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

update (table &body clauses)

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

delete-from (table &body clauses)

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

union-queies (&rest statements)

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

union-all-queries (&rest statements)

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

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

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

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

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

drop-table (table &key if-exists)

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

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

alter-table (table &body clauses)

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

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

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

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

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

SQL Clauses

fields

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

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

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

from

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

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

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

where

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

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

order-by

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

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

group-by

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

having

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

returning

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

limit

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

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

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

offset

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

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

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

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

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

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

primary-key

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

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

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

unique-key

(unique-key '(:name :country))
;=> #<SXQL-CLAUSE: UNIQUE (name, country)>

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

index-key

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

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

foreign-key

(foreign-key '(:project_id) :references '(:project :id))
;=> #<SXQL-CLAUSE: FOREIGN KEY (project_id) REFERENCES project (id)>

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

add-column

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

modify-column

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

alter-column

(alter-column :user :type '(:varchar 64))
;=> #<SXQL-CLAUSE: ALTER COLUMN user TYPE VARCHAR(64)>

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

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

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

change-column

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

drop-column

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

add-primary-key

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

drop-primary-key

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

rename-to

(rename-to :users)
;=> #<SXQL-CLAUSE: RENAME TO `users`>

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

on-duplicate-key-update

Support MySQL's INSERT ... ON DUPLICATE KEY UPDATE syntax.

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

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

SQL Operators

Set a quote character

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

(yield (select :* (from 'table)))
;=> "SELECT * FROM table"
;   NIL

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

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

Author

Copyright

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

License

Licensed under the BSD 3-Clause License.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 sxql

Author

Eitaro Fukamachi

License

BSD 3-Clause

Description

A SQL generator

Long Description

# SxQL - A 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 :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)>
“‘

## SQL Operators

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

## 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.0.1

Dependencies
Source

sxql.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

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


Previous: , Up: Modules   [Contents][Index]

3.1 sxql/src

Parent

sxql (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

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


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 sxql.asd

Location

sxql.asd

Systems

sxql (system)

Packages

sxql-asd


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 sxql/src/sxql.lisp

Dependencies
Parent

src (module)

Location

src/sxql.lisp

Packages

sxql

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 sxql/src/compile.lisp

Dependency

sql-type.lisp (file)

Parent

src (module)

Location

src/compile.lisp

Packages

sxql.compile

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 sxql/src/sql-type.lisp

Parent

src (module)

Location

src/sql-type.lisp

Packages

sxql.sql-type

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 sxql/src/operator.lisp

Dependency

sql-type.lisp (file)

Parent

src (module)

Location

src/operator.lisp

Packages

sxql.operator

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 sxql/src/clause.lisp

Dependency

operator.lisp (file)

Parent

src (module)

Location

src/clause.lisp

Packages

sxql.clause

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 sxql/src/statement.lisp

Dependencies
Parent

src (module)

Location

src/statement.lisp

Packages

sxql.statement

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 sxql/src/composed-statement.lisp

Dependencies
Parent

src (module)

Location

src/composed-statement.lisp

Packages

sxql.composed-statement

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.9 sxql/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Packages

sxql.util

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 sxql-asd

Source

sxql.asd

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 sxql

Source

sxql.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 sxql.compile

Source

compile.lisp (file)

Use List
Exported Definitions

sql-compile (function)

Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 sxql.sql-type

Source

sql-type.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 sxql.operator

Source

operator.lisp (file)

Use List
Used By List

sxql.clause

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.6 sxql.clause

Source

clause.lisp (file)

Use List
Used By List

sxql

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.7 sxql.statement

Source

statement.lisp (file)

Use List
Used By List

sxql

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.8 sxql.composed-statement

Source

composed-statement.lisp (file)

Use List
Used By List

sxql

Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.9 sxql.util

Source

util.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *inside-insert-into*
Package

sxql.clause

Source

clause.lisp (file)

Special Variable: *inside-select*
Package

sxql.operator

Source

operator.lisp (file)

Special Variable: *quote-character*
Package

sxql.sql-type

Source

sql-type.lisp (file)

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

Special Variable: *use-placeholder*
Package

sxql.sql-type

Source

sql-type.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: alter-table TABLE &body CLAUSES
Package

sxql

Source

sxql.lisp (file)

Macro: create-table TABLE COLUMN-DEFINITIONS &body OPTIONS
Package

sxql

Source

sxql.lisp (file)

Macro: delete-from TABLE &body CLAUSES
Package

sxql

Source

sxql.lisp (file)

Macro: drop-table TABLE &key IF-EXISTS
Package

sxql

Source

sxql.lisp (file)

Macro: fields &rest FIELDS
Package

sxql

Source

sxql.lisp (file)

Macro: from &rest STATEMENTS
Package

sxql

Source

sxql.lisp (file)

Macro: full-join TABLE &key ON USING
Package

sxql

Source

sxql.lisp (file)

Macro: group-by &rest EXPRESSIONS
Package

sxql

Source

sxql.lisp (file)

Macro: having EXPRESSION
Package

sxql

Source

sxql.lisp (file)

Macro: inner-join TABLE &key ON USING
Package

sxql

Source

sxql.lisp (file)

Macro: insert-into TABLE &body CLAUSES
Package

sxql

Source

sxql.lisp (file)

Macro: join TABLE &key KIND ON USING
Package

sxql

Source

sxql.lisp (file)

Macro: left-join TABLE &key ON USING
Package

sxql

Source

sxql.lisp (file)

Macro: on-duplicate-key-update &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Macro: order-by &rest EXPRESSIONS
Package

sxql

Source

sxql.lisp (file)

Macro: returning EXPRESSION
Package

sxql

Source

sxql.lisp (file)

Macro: right-join TABLE &key ON USING
Package

sxql

Source

sxql.lisp (file)

Macro: select FIELDS &body CLAUSES
Package

sxql

Source

sxql.lisp (file)

Macro: set= &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Macro: update TABLE &body CLAUSES
Package

sxql

Source

sxql.lisp (file)

Macro: where EXPRESSION
Package

sxql

Source

sxql.lisp (file)

Macro: with-table-name TABLE-NAME &body BODY
Package

sxql.sql-type

Source

sql-type.lisp (file)

Macro: with-yield-binds &body BODY
Package

sxql.sql-type

Source

sql-type.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: add-column COLUMN-NAME &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Function: add-primary-key &rest COLUMN-NAMES
Package

sxql

Source

sxql.lisp (file)

Function: alter-column COLUMN-NAME &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Function: change-column OLD-COLUMN-NAME NEW-COLUMN-NAME &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Function: compose-statements STATEMENT &rest STATEMENTS
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: compute-select-statement-children SELECT-STATEMENT
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index INDEX-NAME &rest ARGS &key UNIQUE USING ON IF-NOT-EXISTS
Package

sxql

Source

sxql.lisp (file)

Function: detect-and-convert OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: drop-column COLUMN-NAME
Package

sxql

Source

sxql.lisp (file)

Function: drop-index INDEX-NAME &key IF-EXISTS ON
Package

sxql

Source

sxql.lisp (file)

Function: drop-primary-key ()
Package

sxql

Source

sxql.lisp (file)

Function: find-constructor NAME SUFFIX &key PACKAGE ERRORP
Package

sxql.operator

Source

operator.lisp (file)

Function: foreign-key COLUMN-NAMES &key REFERENCES ON-DELETE ON-UPDATE
Package

sxql

Source

sxql.lisp (file)

Function: from-clause-table-name FROM
Package

sxql.clause

Source

clause.lisp (file)

Function: group-by KEY SEQUENCE &key TEST
Package

sxql.util

Source

util.lisp (file)

Function: index-key &rest KEY-ARGS
Package

sxql

Source

sxql.lisp (file)

Function: limit COUNT1 &optional COUNT2
Package

sxql

Source

sxql.lisp (file)

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

Function: make-conjunctive-op NAME &rest EXPRESSIONS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-function-op NAME &rest EXPRESSIONS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-infix-list-op &key (NAME NAME) (LEFT LEFT) (RIGHT RIGHT)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-infix-op NAME LEFT RIGHT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-infix-splicing-op NAME LEFT RIGHT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-op OP-NAME &rest ARGS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-sql-column-type NAME &key ARGS ATTRS &aux NAME
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-expression-list &rest ELEMENTS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-keyword NAME
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-list &rest ELEMENTS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-splicing-expression-list &rest ELEMENTS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-splicing-list &rest ELEMENTS
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-symbol NAME
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-variable VALUE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-type-keyword TYPE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-unary-op NAME VAR
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-unary-splicing-op NAME VAR
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: modify-column COLUMN-NAME &rest ARGS
Package

sxql

Source

sxql.lisp (file)

Function: offset OFFSET
Package

sxql

Source

sxql.lisp (file)

Function: pragma NAME &optional VALUE
Package

sxql

Source

sxql.lisp (file)

Function: primary-key &rest KEY-ARGS
Package

sxql

Source

sxql.lisp (file)

Function: rename-to NEW-TABLE-NAME
Package

sxql

Source

sxql.lisp (file)

Function: select-statement-clause-order INSTANCE
Function: (setf select-statement-clause-order) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-fields-clause INSTANCE
Function: (setf select-statement-fields-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-from-clause INSTANCE
Function: (setf select-statement-from-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-group-by-clause INSTANCE
Function: (setf select-statement-group-by-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-having-clause INSTANCE
Function: (setf select-statement-having-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-join-clause INSTANCE
Function: (setf select-statement-join-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-limit-clause INSTANCE
Function: (setf select-statement-limit-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-offset-clause INSTANCE
Function: (setf select-statement-offset-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-order-by-clause INSTANCE
Function: (setf select-statement-order-by-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-returning-clause INSTANCE
Function: (setf select-statement-returning-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-table-name SELECT
Package

sxql.statement

Source

statement.lisp (file)

Function: select-statement-where-clause INSTANCE
Function: (setf select-statement-where-clause) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: sort-clause-types TYPES
Package

sxql.statement

Source

statement.lisp (file)

Function: sql-compile OBJECT
Package

sxql.compile

Source

compile.lisp (file)

Function: sql-composed-statement-children INSTANCE
Function: (setf sql-composed-statement-children) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: sql-expression-list-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: sql-list-elements INSTANCE
Function: (setf sql-list-elements) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: sql-statement-name INSTANCE
Function: (setf sql-statement-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: sql-variable-value INSTANCE
Function: (setf sql-variable-value) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: subdivide SEQUENCE CHUNK-SIZE

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

Package

sxql.util

Source

util.lisp (file)

Function: union-all-queries &rest QUERIES
Package

sxql

Source

sxql.lisp (file)

Function: union-queries &rest QUERIES
Package

sxql

Source

sxql.lisp (file)

Function: unique-key &rest KEY-ARGS
Package

sxql

Source

sxql.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: add-child STATEMENT CHILD
Package

sxql.statement

Source

statement.lisp (file)

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

sxql.operator

Source

operator.lisp (file)

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

Methods
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 join)) &rest ARGS
Method: make-clause CLAUSE-NAME &rest ARGS
Generic Function: make-statement STATEMENT-NAME &rest ARGS
Package

sxql.statement

Source

statement.lisp (file)

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

Methods
Method: yield (STATEMENT composed-statement)
Source

composed-statement.lisp (file)

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

compile.lisp (file)

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

compile.lisp (file)

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

compile.lisp (file)

Method: yield (STATEMENT pragma-statement)
Source

statement.lisp (file)

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

statement.lisp (file)

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

statement.lisp (file)

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

statement.lisp (file)

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

statement.lisp (file)

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

statement.lisp (file)

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

statement.lisp (file)

Method: yield (STATEMENT select-statement) before
Source

statement.lisp (file)

Method: yield (STATEMENT select-statement)
Source

statement.lisp (file)

Method: yield (CLAUSE set=-clause)
Source

clause.lisp (file)

Method: yield (CLAUSE join-clause)
Source

clause.lisp (file)

Method: yield (CLAUSE offset-clause)
Source

clause.lisp (file)

Method: yield (CLAUSE limit-clause)
Source

clause.lisp (file)

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

clause.lisp (file)

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

clause.lisp (file)

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

clause.lisp (file)

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

clause.lisp (file)

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

clause.lisp (file)

Method: yield (CLAUSE on-clause)
Source

clause.lisp (file)

Method: yield (CLAUSE key-clause)
Source

clause.lisp (file)

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

operator.lisp (file)

Method: yield (OP union-op)
Source

operator.lisp (file)

Method: yield (OP as-op)
Source

operator.lisp (file)

Method: yield (RAW raw-op)
Source

operator.lisp (file)

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

operator.lisp (file)

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

operator.lisp (file)

Method: yield OBJECT around
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)

Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Structures

Structure: alter-table-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"alter table"

Readers

alter-table-statement-name (function)

Writers

(setf alter-table-statement-name) (function)

Slot: table
Type

sxql.sql-type:sql-symbol

Readers

alter-table-statement-table (function)

Writers

(setf alter-table-statement-table) (function)

Slot: children
Readers

alter-table-statement-children (function)

Writers

(setf alter-table-statement-children) (function)

Structure: column-definition-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

sql-clause (structure)

Direct methods

yield (method)

Direct slots
Slot: column-name
Readers

column-definition-clause-column-name (function)

Writers

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

Slot: type
Readers

column-definition-clause-type (function)

Writers

(setf column-definition-clause-type) (function)

Slot: not-null
Readers

column-definition-clause-not-null (function)

Writers

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

Slot: default
Readers

column-definition-clause-default (function)

Writers

(setf column-definition-clause-default) (function)

Slot: auto-increment
Readers

column-definition-clause-auto-increment (function)

Writers

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

Slot: autoincrement
Readers

column-definition-clause-autoincrement (function)

Writers

(setf column-definition-clause-autoincrement) (function)

Slot: unique
Readers

column-definition-clause-unique (function)

Writers

(setf column-definition-clause-unique) (function)

Slot: primary-key
Readers

column-definition-clause-primary-key (function)

Writers

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

Structure: composed-statement ()
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
  • yield (method)
  • print-object (method)
Direct slots
Slot: statements
Readers

composed-statement-statements (function)

Writers

(setf composed-statement-statements) (function)

Structure: conjunctive-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-op (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: expressions
Type

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

Readers

conjunctive-op-expressions (function)

Writers

(setf conjunctive-op-expressions) (function)

Structure: create-index-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"create index"

Readers

create-index-statement-name (function)

Writers

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

Slot: index-name
Type

sxql.sql-type:sql-symbol

Readers

create-index-statement-index-name (function)

Writers

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

Slot: table-name
Type

sxql.sql-type:sql-symbol

Readers

create-index-statement-table-name (function)

Writers

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

Slot: columns
Type

sxql.sql-type:sql-list

Readers

create-index-statement-columns (function)

Writers

(setf create-index-statement-columns) (function)

Slot: unique
Type

boolean

Readers

create-index-statement-unique (function)

Writers

(setf create-index-statement-unique) (function)

Slot: using
Type

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

Readers

create-index-statement-using (function)

Writers

(setf create-index-statement-using) (function)

Slot: if-not-exists
Type

boolean

Readers

create-index-statement-if-not-exists (function)

Writers

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

Structure: create-table-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-composed-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"create table"

Readers

create-table-statement-name (function)

Writers

(setf create-table-statement-name) (function)

Slot: table
Readers

create-table-statement-table (function)

Writers

(setf create-table-statement-table) (function)

Slot: if-not-exists
Type

boolean

Readers

create-table-statement-if-not-exists (function)

Writers

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

Structure: delete-from-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-composed-statement (structure)

Direct slots
Slot: name
Type

string

Initform

"delete from"

Readers

delete-from-statement-name (function)

Writers

(setf delete-from-statement-name) (function)

Structure: drop-index-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"drop index"

Readers

drop-index-statement-name (function)

Writers

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

Slot: index-name
Type

sxql.sql-type:sql-symbol

Readers

drop-index-statement-index-name (function)

Writers

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

Slot: if-exists
Type

boolean

Readers

drop-index-statement-if-exists (function)

Writers

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

Slot: on
Type

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

Readers

drop-index-statement-on (function)

Writers

(setf drop-index-statement-on) (function)

Structure: drop-table-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"drop table"

Readers

drop-table-statement-name (function)

Writers

(setf drop-table-statement-name) (function)

Slot: table
Type

sxql.sql-type:sql-symbol

Readers

drop-table-statement-table (function)

Writers

(setf drop-table-statement-table) (function)

Slot: if-exists
Type

boolean

Readers

drop-table-statement-if-exists (function)

Writers

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

Structure: expression-clause ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-clause (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: expression
Type

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

Readers

expression-clause-expression (function)

Writers

(setf expression-clause-expression) (function)

Structure: expression-list-clause ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-clause (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: expressions
Type

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

Readers

expression-list-clause-expressions (function)

Writers

(setf expression-list-clause-expressions) (function)

Structure: fields-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

statement-clause (structure)

Direct slots
Slot: name
Type

string

Initform

""

Readers

fields-clause-name (function)

Writers

(setf fields-clause-name) (function)

Structure: foreign-key-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"foreign key"

Readers

foreign-key-clause-name (function)

Writers

(setf foreign-key-clause-name) (function)

Slot: column-names
Type

sxql.sql-type:sql-list

Readers

foreign-key-clause-column-names (function)

Writers

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

Slot: references
Type

sxql.clause:references-clause

Readers

foreign-key-clause-references (function)

Writers

(setf foreign-key-clause-references) (function)

Structure: from-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

statement-clause (structure)

Direct methods

yield-only-contents (method)

Direct slots
Slot: name
Type

string

Initform

"from"

Readers

from-clause-name (function)

Writers

(setf from-clause-name) (function)

Structure: function-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

conjunctive-op (structure)

Direct methods

yield (method)

Structure: group-by-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-list-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"group by"

Readers

group-by-clause-name (function)

Writers

(setf group-by-clause-name) (function)

Structure: having-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"having"

Readers

having-clause-name (function)

Writers

(setf having-clause-name) (function)

Structure: infix-list-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-op (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: left
Type

sxql.sql-type:sql-expression

Readers

infix-list-op-left (function)

Writers

(setf infix-list-op-left) (function)

Slot: right
Type

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

Readers

infix-list-op-right (function)

Writers

(setf infix-list-op-right) (function)

Structure: infix-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-op (structure)

Direct subclasses
Direct methods

yield (method)

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

Writers

(setf infix-op-left) (function)

Slot: right
Type

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

Readers

infix-op-right (function)

Writers

(setf infix-op-right) (function)

Structure: infix-splicing-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

infix-op (structure)

Direct subclasses

as-op (structure)

Direct methods

yield (method)

Structure: insert-into-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-composed-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"insert into"

Readers

insert-into-statement-name (function)

Writers

(setf insert-into-statement-name) (function)

Structure: join-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

statement-clause (structure)

Direct methods

yield (method)

Direct slots
Slot: kind
Type

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

Initform

:inner

Readers

join-clause-kind (function)

Writers

(setf join-clause-kind) (function)

Slot: on
Type

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

Readers

join-clause-on (function)

Writers

(setf join-clause-on) (function)

Slot: using
Type

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

Readers

join-clause-using (function)

Writers

(setf join-clause-using) (function)

Structure: key-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"key"

Readers

key-clause-name (function)

Writers

(setf key-clause-name) (function)

Slot: key-name
Type

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

Readers

key-clause-key-name (function)

Writers

(setf key-clause-key-name) (function)

Slot: keys
Readers

key-clause-keys (function)

Writers

(setf key-clause-keys) (function)

Structure: limit-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-list-clause (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"limit"

Readers

limit-clause-name (function)

Writers

(setf limit-clause-name) (function)

Slot: count1
Type

sxql.sql-type:sql-variable

Readers

limit-clause-count1 (function)

Writers

(setf limit-clause-count1) (function)

Slot: count2
Type

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

Readers

limit-clause-count2 (function)

Writers

(setf limit-clause-count2) (function)

Structure: offset-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

sql-clause (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"offset"

Readers

offset-clause-name (function)

Writers

(setf offset-clause-name) (function)

Slot: offset
Type

sxql.sql-type:sql-variable

Readers

offset-clause-offset (function)

Writers

(setf offset-clause-offset) (function)

Structure: order-by-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-list-clause (structure)

Direct methods

yield-only-contents (method)

Direct slots
Slot: name
Type

string

Initform

"order by"

Readers

order-by-clause-name (function)

Writers

(setf order-by-clause-name) (function)

Structure: pragma-statement ()

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

Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-statement (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"pragma"

Readers

pragma-statement-name (function)

Writers

(setf pragma-statement-name) (function)

Slot: pragma-name
Readers

pragma-statement-pragma-name (function)

Writers

(setf pragma-statement-pragma-name) (function)

Slot: value
Readers

pragma-statement-value (function)

Writers

(setf pragma-statement-value) (function)

Structure: primary-key-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

key-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"primary key"

Readers

primary-key-clause-name (function)

Writers

(setf primary-key-clause-name) (function)

Structure: references-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"references"

Readers

references-clause-name (function)

Writers

(setf references-clause-name) (function)

Slot: table-name
Type

sxql.sql-type:sql-symbol

Readers

references-clause-table-name (function)

Writers

(setf references-clause-table-name) (function)

Slot: column-names
Type

sxql.sql-type:sql-list

Readers

references-clause-column-names (function)

Writers

(setf references-clause-column-names) (function)

Structure: returning-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"returning"

Readers

returning-clause-name (function)

Writers

(setf returning-clause-name) (function)

Structure: select-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-composed-statement (structure)

Direct methods
Direct slots
Slot: name
Type

string

Initform

"select"

Readers

select-statement-name (function)

Writers

(setf select-statement-name) (function)

Slot: clause-order
Readers

select-statement-clause-order (function)

Writers

(setf select-statement-clause-order) (function)

Slot: fields-clause
Readers

select-statement-fields-clause (function)

Writers

(setf select-statement-fields-clause) (function)

Slot: from-clause
Readers

select-statement-from-clause (function)

Writers

(setf select-statement-from-clause) (function)

Slot: join-clause
Readers

select-statement-join-clause (function)

Writers

(setf select-statement-join-clause) (function)

Slot: where-clause
Readers

select-statement-where-clause (function)

Writers

(setf select-statement-where-clause) (function)

Slot: group-by-clause
Readers

select-statement-group-by-clause (function)

Writers

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

Slot: having-clause
Readers

select-statement-having-clause (function)

Writers

(setf select-statement-having-clause) (function)

Slot: returning-clause
Readers

select-statement-returning-clause (function)

Writers

(setf select-statement-returning-clause) (function)

Slot: order-by-clause
Readers

select-statement-order-by-clause (function)

Writers

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

Slot: limit-clause
Readers

select-statement-limit-clause (function)

Writers

(setf select-statement-limit-clause) (function)

Slot: offset-clause
Readers

select-statement-offset-clause (function)

Writers

(setf select-statement-offset-clause) (function)

Structure: set=-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

sql-clause (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Initform

"set"

Readers

set=-clause-name (function)

Writers

(setf set=-clause-name) (function)

Slot: args
Type

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

Readers

set=-clause-args (function)

Writers

(setf set=-clause-args) (function)

Structure: sql-atom ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Structure: sql-clause ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Initform

""

Readers

sql-clause-name (function)

Writers

(setf sql-clause-name) (function)

Structure: sql-column-type ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Readers

sql-column-type-name (function)

Writers

(setf sql-column-type-name) (function)

Slot: args
Type

list

Readers

sql-column-type-args (function)

Writers

(setf sql-column-type-args) (function)

Slot: attrs
Type

list

Readers

sql-column-type-attrs (function)

Writers

(setf sql-column-type-attrs) (function)

Structure: sql-composed-statement ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-statement (structure)

Direct subclasses
Direct methods
Direct slots
Slot: children
Type

trivial-types:proper-list

Readers

sql-composed-statement-children (function)

Writers

(setf sql-composed-statement-children) (function)

Structure: sql-expression-list ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

sql-splicing-expression-list (structure)

Direct methods

yield (method)

Direct slots
Slot: elements
Type

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

Readers

sql-expression-list-elements (function)

Writers

(setf sql-expression-list-elements) (function)

Structure: sql-keyword ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-atom (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Readers

sql-keyword-name (function)

Writers

(setf sql-keyword-name) (function)

Structure: sql-list ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

sql-splicing-list (structure)

Direct methods

yield (method)

Direct slots
Slot: elements
Type

trivial-types:proper-list

Readers

sql-list-elements (function)

Writers

(setf sql-list-elements) (function)

Structure: sql-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Readers

sql-op-name (function)

Writers

(setf sql-op-name) (function)

Structure: sql-splicing-expression-list ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-expression-list (structure)

Direct methods

yield (method)

Structure: sql-statement ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Initform

""

Readers

sql-statement-name (function)

Writers

(setf sql-statement-name) (function)

Structure: sql-symbol ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-atom (structure)

Direct methods

yield (method)

Direct slots
Slot: name
Type

string

Readers

sql-symbol-name (function)

Writers

(setf sql-symbol-name) (function)

Structure: sql-variable ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-atom (structure)

Direct methods

yield (method)

Direct slots
Slot: value
Type

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

Readers

sql-variable-value (function)

Writers

(setf sql-variable-value) (function)

Structure: statement-clause ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-clause (structure)

Direct subclasses
Direct methods

yield (method)

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

Writers

(setf statement-clause-statement) (function)

Structure: unary-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

sql-op (structure)

Direct subclasses
Direct methods

yield (method)

Direct slots
Slot: var
Type

sxql.sql-type:sql-expression

Readers

unary-op-var (function)

Writers

(setf unary-op-var) (function)

Structure: unary-postfix-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

unary-op (structure)

Direct subclasses
Direct methods

yield (method)

Structure: unary-splicing-op ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Direct superclasses

unary-op (structure)

Direct subclasses

distinct-op (structure)

Direct methods

yield (method)

Structure: unique-key-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

key-clause (structure)

Direct slots
Slot: name
Type

string

Initform

"unique"

Readers

unique-key-clause-name (function)

Writers

(setf unique-key-clause-name) (function)

Structure: update-statement ()
Package

sxql.statement

Source

statement.lisp (file)

Direct superclasses

sql-composed-statement (structure)

Direct slots
Slot: name
Type

string

Initform

"update"

Readers

update-statement-name (function)

Writers

(setf update-statement-name) (function)

Structure: where-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Direct superclasses

expression-clause (structure)

Direct methods

yield-only-contents (method)

Direct slots
Slot: name
Type

string

Initform

"where"

Readers

where-clause-name (function)

Writers

(setf where-clause-name) (function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Types

Type: select-statement-designator ()
Package

sxql

Source

sxql.lisp (file)

Type: sql-clause-list ()
Package

sxql.sql-type

Source

sql-type.lisp (file)

Type: sql-expression ()
Package

sxql.sql-type

Source

sql-type.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *bind-values*
Package

sxql.sql-type

Source

sql-type.lisp (file)

Special Variable: *clause-delimiters*
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Special Variable: *clause-priority*
Package

sxql.statement

Source

statement.lisp (file)

Special Variable: *inside-function-op*
Package

sxql.sql-type

Source

sql-type.lisp (file)

Special Variable: *table-name-scope*
Package

sxql.sql-type

Source

sql-type.lisp (file)

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

sxql.sql-type

Source

sql-type.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: define-compile-struct STRUCTURE-NAME &rest DEFSTRUCT-OPTIONS
Package

sxql.compile

Source

compile.lisp (file)

Macro: define-op (OP-NAME STRUCT-TYPE &key SQL-OP-NAME INCLUDE-SLOTS PACKAGE) &body BODY
Package

sxql.operator

Source

operator.lisp (file)

Macro: yield-for-union-ops KEYWORD
Package

sxql.operator

Source

operator.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: !=-op-left INSTANCE
Function: (setf !=-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: !=-op-name INSTANCE
Function: (setf !=-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: !=-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: !=-op-right INSTANCE
Function: (setf !=-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: %-op-expressions INSTANCE
Function: (setf %-op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: %-op-name INSTANCE
Function: (setf %-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: %-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: %make-column-definition-clause COLUMN-NAME &key TYPE NOT-NULL DEFAULT AUTO-INCREMENT AUTOINCREMENT UNIQUE PRIMARY-KEY
Package

sxql.clause

Source

clause.lisp (file)

Function: %make-on-duplicate-key-update-clause &rest ARGS
Package

sxql.clause

Source

clause.lisp (file)

Function: %make-set=-clause &rest ARGS
Package

sxql.clause

Source

clause.lisp (file)

Function: *-op-expressions INSTANCE
Function: (setf *-op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: *-op-name INSTANCE
Function: (setf *-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: *-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: +-op-expressions INSTANCE
Function: (setf +-op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: +-op-name INSTANCE
Function: (setf +-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: +-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: --op-expressions INSTANCE
Function: (setf --op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: --op-name INSTANCE
Function: (setf --op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: --op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: /-op-expressions INSTANCE
Function: (setf /-op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: /-op-name INSTANCE
Function: (setf /-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: /-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: <-op-left INSTANCE
Function: (setf <-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: <-op-name INSTANCE
Function: (setf <-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: <-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: <-op-right INSTANCE
Function: (setf <-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: <=-op-left INSTANCE
Function: (setf <=-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: <=-op-name INSTANCE
Function: (setf <=-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: <=-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: <=-op-right INSTANCE
Function: (setf <=-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: =-op-left INSTANCE
Function: (setf =-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: =-op-name INSTANCE
Function: (setf =-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: =-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: =-op-right INSTANCE
Function: (setf =-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >-op-left INSTANCE
Function: (setf >-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >-op-name INSTANCE
Function: (setf >-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: >-op-right INSTANCE
Function: (setf >-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >=-op-left INSTANCE
Function: (setf >=-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >=-op-name INSTANCE
Function: (setf >=-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: >=-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: >=-op-right INSTANCE
Function: (setf >=-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a<-op-left INSTANCE
Function: (setf a<-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a<-op-name INSTANCE
Function: (setf a<-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a<-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: a<-op-right INSTANCE
Function: (setf a<-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a>-op-left INSTANCE
Function: (setf a>-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a>-op-name INSTANCE
Function: (setf a>-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: a>-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: a>-op-right INSTANCE
Function: (setf a>-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: add-column-clause-after INSTANCE
Function: (setf add-column-clause-after) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-column-clause-column-definition INSTANCE
Function: (setf add-column-clause-column-definition) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-column-clause-expression INSTANCE
Function: (setf add-column-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-column-clause-first INSTANCE
Function: (setf add-column-clause-first) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-column-clause-name INSTANCE
Function: (setf add-column-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-column-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

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

sxql.clause

Source

clause.lisp (file)

Function: add-primary-key-clause-name INSTANCE
Function: (setf add-primary-key-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: add-primary-key-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-column-name INSTANCE
Function: (setf alter-column-clause-column-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-drop-default INSTANCE
Function: (setf alter-column-clause-drop-default) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-name INSTANCE
Function: (setf alter-column-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-not-null INSTANCE
Function: (setf alter-column-clause-not-null) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-set-default INSTANCE
Function: (setf alter-column-clause-set-default) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-column-clause-type INSTANCE
Function: (setf alter-column-clause-type) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: alter-table-statement-children INSTANCE
Function: (setf alter-table-statement-children) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: alter-table-statement-name INSTANCE
Function: (setf alter-table-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: alter-table-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: alter-table-statement-table INSTANCE
Function: (setf alter-table-statement-table) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: and-op-expressions INSTANCE
Function: (setf and-op-expressions) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: and-op-name INSTANCE
Function: (setf and-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: and-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: as-op-left INSTANCE
Function: (setf as-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: as-op-name INSTANCE
Function: (setf as-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: as-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: as-op-right INSTANCE
Function: (setf as-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: asc-op-name INSTANCE
Function: (setf asc-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: asc-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: asc-op-var INSTANCE
Function: (setf asc-op-var) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: change-column-clause-after INSTANCE
Function: (setf change-column-clause-after) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: change-column-clause-column-definition INSTANCE
Function: (setf change-column-clause-column-definition) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: change-column-clause-expression INSTANCE
Function: (setf change-column-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: change-column-clause-first INSTANCE
Function: (setf change-column-clause-first) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: change-column-clause-name INSTANCE
Function: (setf change-column-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: change-column-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-auto-increment INSTANCE
Function: (setf column-definition-clause-auto-increment) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-autoincrement INSTANCE
Function: (setf column-definition-clause-autoincrement) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-column-name INSTANCE
Function: (setf column-definition-clause-column-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-default INSTANCE
Function: (setf column-definition-clause-default) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-name INSTANCE
Function: (setf column-definition-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-not-null INSTANCE
Function: (setf column-definition-clause-not-null) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-primary-key INSTANCE
Function: (setf column-definition-clause-primary-key) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-type INSTANCE
Function: (setf column-definition-clause-type) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-definition-clause-unique INSTANCE
Function: (setf column-definition-clause-unique) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-after INSTANCE
Function: (setf column-modifier-clause-after) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-column-definition INSTANCE
Function: (setf column-modifier-clause-column-definition) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-expression INSTANCE
Function: (setf column-modifier-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-first INSTANCE
Function: (setf column-modifier-clause-first) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-name INSTANCE
Function: (setf column-modifier-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: column-modifier-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: composed-statement-p OBJECT
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: composed-statement-statements INSTANCE
Function: (setf composed-statement-statements) VALUE INSTANCE
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: conjunctive-op-expressions INSTANCE
Function: (setf conjunctive-op-expressions) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: conjunctive-op-name INSTANCE
Function: (setf conjunctive-op-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: conjunctive-op-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: convert-if-fields-clause CLAUSE
Package

sxql

Source

sxql.lisp (file)

Function: copy-!=-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-%-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-*-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-+-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy---op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-/-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-<-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-<=-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-=-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy->-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy->=-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-a<-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-a>-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-add-column-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-add-primary-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-alter-column-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-alter-table-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-and-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-as-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-asc-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-change-column-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-column-definition-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-column-modifier-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-composed-statement INSTANCE
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: copy-conjunctive-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-create-index-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-create-table-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-delete-from-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-desc-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-distinct-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-drop-column-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-drop-index-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-drop-primary-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-drop-table-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-expression-clause INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-expression-list-clause INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-fields-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-foreign-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-from-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-function-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-group-by-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-having-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-in-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-infix-list-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-infix-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-infix-splicing-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-insert-into-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-is-null-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-join-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-like-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-limit-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-modify-column-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-not-in-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-not-null-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-not-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-offset-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-on-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-on-delete-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-on-duplicate-key-update-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-on-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-on-update-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-or-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-order-by-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-pragma-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-primary-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-raw-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-references-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-rename-to-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-returning-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-scoped-clause INSTANCE
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: copy-select-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-set=-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-sql-atom INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-clause INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-clause-compiled INSTANCE
Package

sxql.compile

Source

compile.lisp (file)

Function: copy-sql-column-type INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-composed-statement INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-expression-list INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-keyword INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-list INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-op-compiled INSTANCE
Package

sxql.compile

Source

compile.lisp (file)

Function: copy-sql-splicing-expression-list INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-splicing-list INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-statement INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-statement-compiled INSTANCE
Package

sxql.compile

Source

compile.lisp (file)

Function: copy-sql-symbol INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-sql-variable INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-statement-clause INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-unary-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-unary-postfix-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-unary-splicing-op INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: copy-union-all-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-union-op INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: copy-unique-key-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: copy-update-statement INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: copy-where-clause INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: create-index-statement-columns INSTANCE
Function: (setf create-index-statement-columns) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-if-not-exists INSTANCE
Function: (setf create-index-statement-if-not-exists) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-index-name INSTANCE
Function: (setf create-index-statement-index-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-name INSTANCE
Function: (setf create-index-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-table-name INSTANCE
Function: (setf create-index-statement-table-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-unique INSTANCE
Function: (setf create-index-statement-unique) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-index-statement-using INSTANCE
Function: (setf create-index-statement-using) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-table-statement-children INSTANCE
Function: (setf create-table-statement-children) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-table-statement-if-not-exists INSTANCE
Function: (setf create-table-statement-if-not-exists) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-table-statement-name INSTANCE
Function: (setf create-table-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: create-table-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: create-table-statement-table INSTANCE
Function: (setf create-table-statement-table) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: delete-from-statement-children INSTANCE
Function: (setf delete-from-statement-children) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: delete-from-statement-name INSTANCE
Function: (setf delete-from-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: delete-from-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: desc-op-name INSTANCE
Function: (setf desc-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: desc-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: desc-op-var INSTANCE
Function: (setf desc-op-var) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: distinct-op-name INSTANCE
Function: (setf distinct-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: distinct-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: distinct-op-var INSTANCE
Function: (setf distinct-op-var) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: drop-column-clause-expression INSTANCE
Function: (setf drop-column-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: drop-column-clause-name INSTANCE
Function: (setf drop-column-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: drop-column-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: drop-index-statement-if-exists INSTANCE
Function: (setf drop-index-statement-if-exists) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-index-statement-index-name INSTANCE
Function: (setf drop-index-statement-index-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-index-statement-name INSTANCE
Function: (setf drop-index-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-index-statement-on INSTANCE
Function: (setf drop-index-statement-on) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-index-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-primary-key-clause-name INSTANCE
Function: (setf drop-primary-key-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: drop-primary-key-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: drop-table-statement-if-exists INSTANCE
Function: (setf drop-table-statement-if-exists) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-table-statement-name INSTANCE
Function: (setf drop-table-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-table-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: drop-table-statement-table INSTANCE
Function: (setf drop-table-statement-table) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: expand-expression EXPRESSIONS
Package

sxql

Source

sxql.lisp (file)

Function: expand-op OBJECT
Package

sxql

Source

sxql.lisp (file)

Function: expression-clause-expression INSTANCE
Function: (setf expression-clause-expression) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: expression-clause-name INSTANCE
Function: (setf expression-clause-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: expression-clause-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: expression-list-clause-expressions INSTANCE
Function: (setf expression-list-clause-expressions) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: expression-list-clause-name INSTANCE
Function: (setf expression-list-clause-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: expression-list-clause-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: fields-clause-name INSTANCE
Function: (setf fields-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: fields-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: fields-clause-statement INSTANCE
Function: (setf fields-clause-statement) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: find-make-clause CLAUSE-NAME &optional PACKAGE
Package

sxql.clause

Source

clause.lisp (file)

Function: find-make-op OP-NAME &optional PACKAGE
Package

sxql.operator

Source

operator.lisp (file)

Function: find-make-statement STATEMENT-NAME &optional PACKAGE
Package

sxql.statement

Source

statement.lisp (file)

Function: foreign-key-clause-column-names INSTANCE
Function: (setf foreign-key-clause-column-names) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: foreign-key-clause-expression INSTANCE
Function: (setf foreign-key-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: foreign-key-clause-name INSTANCE
Function: (setf foreign-key-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: foreign-key-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: foreign-key-clause-references INSTANCE
Function: (setf foreign-key-clause-references) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: from-clause-name INSTANCE
Function: (setf from-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: from-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: from-clause-statement INSTANCE
Function: (setf from-clause-statement) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: function-op-expressions INSTANCE
Function: (setf function-op-expressions) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: function-op-name INSTANCE
Function: (setf function-op-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: function-op-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: group-by-clause-expressions INSTANCE
Function: (setf group-by-clause-expressions) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: group-by-clause-name INSTANCE
Function: (setf group-by-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: group-by-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

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

Function: having-clause-expression INSTANCE
Function: (setf having-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: having-clause-name INSTANCE
Function: (setf having-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: having-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: in-op-left INSTANCE
Function: (setf in-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: in-op-name INSTANCE
Function: (setf in-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: in-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: in-op-right INSTANCE
Function: (setf in-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: infix-list-op-left INSTANCE
Function: (setf infix-list-op-left) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-list-op-name INSTANCE
Function: (setf infix-list-op-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-list-op-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-list-op-right INSTANCE
Function: (setf infix-list-op-right) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-op-left INSTANCE
Function: (setf infix-op-left) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-op-name INSTANCE
Function: (setf infix-op-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-op-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-op-right INSTANCE
Function: (setf infix-op-right) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-splicing-op-left INSTANCE
Function: (setf infix-splicing-op-left) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-splicing-op-name INSTANCE
Function: (setf infix-splicing-op-name) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-splicing-op-p OBJECT
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: infix-splicing-op-right INSTANCE
Function: (setf infix-splicing-op-right) VALUE INSTANCE
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: insert-into-statement-children INSTANCE
Function: (setf insert-into-statement-children) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: insert-into-statement-name INSTANCE
Function: (setf insert-into-statement-name) VALUE INSTANCE
Package

sxql.statement

Source

statement.lisp (file)

Function: insert-into-statement-p OBJECT
Package

sxql.statement

Source

statement.lisp (file)

Function: is-null-op-name INSTANCE
Function: (setf is-null-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: is-null-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: is-null-op-var INSTANCE
Function: (setf is-null-op-var) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: join-clause-kind INSTANCE
Function: (setf join-clause-kind) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: join-clause-name INSTANCE
Function: (setf join-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: join-clause-on INSTANCE
Function: (setf join-clause-on) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: join-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: join-clause-statement INSTANCE
Function: (setf join-clause-statement) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: join-clause-using INSTANCE
Function: (setf join-clause-using) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: key-clause-expand TYPE KEY-ARGS
Package

sxql

Source

sxql.lisp (file)

Function: key-clause-expression INSTANCE
Function: (setf key-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: key-clause-key-name INSTANCE
Function: (setf key-clause-key-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: key-clause-keys INSTANCE
Function: (setf key-clause-keys) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: key-clause-name INSTANCE
Function: (setf key-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: key-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: like-op-left INSTANCE
Function: (setf like-op-left) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: like-op-name INSTANCE
Function: (setf like-op-name) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: like-op-p OBJECT
Package

sxql.operator

Source

operator.lisp (file)

Function: like-op-right INSTANCE
Function: (setf like-op-right) VALUE INSTANCE
Package

sxql.operator

Source

operator.lisp (file)

Function: limit-clause-count1 INSTANCE
Function: (setf limit-clause-count1) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: limit-clause-count2 INSTANCE
Function: (setf limit-clause-count2) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: limit-clause-expressions INSTANCE
Function: (setf limit-clause-expressions) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: limit-clause-name INSTANCE
Function: (setf limit-clause-name) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: limit-clause-p OBJECT
Package

sxql.clause

Source

clause.lisp (file)

Function: make-!=-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-%-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-*-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-+-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make---op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-/-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-<-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-<=-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-=-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make->-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make->=-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-a<-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-a>-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-add-column-clause COLUMN-DEFINITION &key AFTER FIRST &aux EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-add-primary-key-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-alter-column-clause COLUMN-NAME &key TYPE SET-DEFAULT DROP-DEFAULT NOT-NULL
Package

sxql.clause

Source

clause.lisp (file)

Function: make-alter-table-statement TABLE &rest CHILDREN &aux CHILDREN
Package

sxql.statement

Source

statement.lisp (file)

Function: make-and-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-as-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-asc-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-change-column-clause OLD-COLUMN-NAME COLUMN-DEFINITION &key AFTER FIRST &aux EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-column-modifier-clause FN OLD-COLUMN-NAME COLUMN-NAME &rest ARGS &key TYPE NOT-NULL DEFAULT AUTO-INCREMENT UNIQUE PRIMARY-KEY AFTER FIRST
Package

sxql.clause

Source

clause.lisp (file)

Function: make-composed-statement &rest STATEMENTS
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: make-create-index-statement INDEX-NAME TABLE-NAME COLUMNS &key UNIQUE USING IF-NOT-EXISTS
Package

sxql.statement

Source

statement.lisp (file)

Function: make-create-table-statement TABLE &key IF-NOT-EXISTS CHILDREN
Package

sxql.statement

Source

statement.lisp (file)

Function: make-delete-from-statement &rest CHILDREN
Package

sxql.statement

Source

statement.lisp (file)

Function: make-desc-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-distinct-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-drop-column-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-drop-index-statement INDEX-NAME &key IF-EXISTS ON
Package

sxql.statement

Source

statement.lisp (file)

Function: make-drop-primary-key-clause ()
Package

sxql.clause

Source

clause.lisp (file)

Function: make-drop-table-statement TABLE &key IF-EXISTS
Package

sxql.statement

Source

statement.lisp (file)

Function: make-expression-clause &key (NAME NAME) (EXPRESSION EXPRESSION)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-expression-list-clause &key (NAME NAME) (EXPRESSIONS EXPRESSIONS)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-fields-clause &rest FIELDS &aux STATEMENT
Package

sxql.clause

Source

clause.lisp (file)

Function: make-foreign-key-clause COLUMN-NAMES REFERENCES ON-DELETE ON-UPDATE &aux EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-from-clause &rest TABLES &aux STATEMENT
Package

sxql.clause

Source

clause.lisp (file)

Function: make-group-by-clause &rest EXPRESSIONS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-having-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-in-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-insert-into-statement &rest CHILDREN
Package

sxql.statement

Source

statement.lisp (file)

Function: make-is-null-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-join-clause &key (NAME NAME) (STATEMENT STATEMENT) (KIND KIND) (ON ON) (USING USING)
Package

sxql.clause

Source

clause.lisp (file)

Function: make-key-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-key-clause-for-all FN &rest KEY-ARGS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-like-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-limit-clause COUNT1 &optional COUNT2 &aux EXPRESSIONS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-modify-column-clause COLUMN-DEFINITION &key AFTER FIRST &aux EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-not-in-op LEFT RIGHT
Package

sxql.operator

Source

operator.lisp (file)

Function: make-not-null-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-not-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-offset-clause OFFSET
Package

sxql.clause

Source

clause.lisp (file)

Function: make-on-clause &key (NAME NAME) (ACTION ACTION)
Package

sxql.clause

Source

clause.lisp (file)

Function: make-on-delete-clause &key (NAME NAME) (ACTION ACTION)
Package

sxql.clause

Source

clause.lisp (file)

Function: make-on-duplicate-key-update-clause &rest ARGS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-on-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-on-update-clause &key (NAME NAME) (ACTION ACTION)
Package

sxql.clause

Source

clause.lisp (file)

Function: make-or-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-order-by-clause &rest EXPRESSIONS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-pragma-statement PRAGMA-NAME &optional VALUE
Package

sxql.statement

Source

statement.lisp (file)

Function: make-primary-key-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-raw-op VAR
Package

sxql.operator

Source

operator.lisp (file)

Function: make-references-clause TABLE-NAME COLUMN-NAMES &aux EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-rename-to-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-returning-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-scoped-clause CLAUSE STATEMENT
Package

sxql.composed-statement

Source

composed-statement.lisp (file)

Function: make-select-statement &rest CLAUSES &key FIELDS-CLAUSE FROM-CLAUSE JOIN-CLAUSE WHERE-CLAUSE GROUP-BY-CLAUSE HAVING-CLAUSE RETURNING-CLAUSE ORDER-BY-CLAUSE LIMIT-CLAUSE OFFSET-CLAUSE &aux CLAUSE-ORDER
Package

sxql.statement

Source

statement.lisp (file)

Function: make-set=-clause &rest ARGS
Package

sxql.clause

Source

clause.lisp (file)

Function: make-sql-atom &key
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-clause &key (NAME NAME)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-clause-compiled &key (NAME NAME) (SQL SQL) (BIND BIND)
Package

sxql.compile

Source

compile.lisp (file)

Function: make-sql-column-type-from-list VAL
Package

sxql.clause

Source

clause.lisp (file)

Function: make-sql-composed-statement &key (NAME NAME) (CHILDREN CHILDREN)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-op &key (NAME NAME)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-op-compiled &key (NAME NAME) (SQL SQL) (BIND BIND)
Package

sxql.compile

Source

compile.lisp (file)

Function: make-sql-statement &key (NAME NAME)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-sql-statement-compiled &key (NAME NAME) (SQL SQL) (BIND BIND)
Package

sxql.compile

Source

compile.lisp (file)

Function: make-statement-clause &key (NAME NAME) (STATEMENT STATEMENT)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-unary-postfix-op &key (NAME NAME) (VAR VAR)
Package

sxql.sql-type

Source

sql-type.lisp (file)

Function: make-union-all-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-union-op &rest EXPRESSIONS
Package

sxql.operator

Source

operator.lisp (file)

Function: make-unique-key-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: make-update-statement &rest CHILDREN
Package

sxql.statement

Source

statement.lisp (file)

Function: make-where-clause EXPRESSION
Package

sxql.clause

Source

clause.lisp (file)

Function: modify-column-clause-after INSTANCE
Function: (setf modify-column-clause-after) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: modify-column-clause-column-definition INSTANCE
Function: (setf modify-column-clause-column-definition) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)

Function: modify-column-clause-expression INSTANCE
Function: (setf modify-column-clause-expression) VALUE INSTANCE
Package

sxql.clause

Source

clause.lisp (file)