├── .gitignore
├── 5CD2-02-Foundation-2006-01.txt
├── 5WD-02-Foundation-2003-09.txt
├── 7IWD2-02-Foundation-2011-12.txt
├── AddLinks.lhs
├── GrammarToAsciidoc.lhs
├── README
├── Setup.hs
├── ansi-iso-9075-2-1999.txt
├── fix_lines.pl
├── index.asciidoc
├── make_website.sh
├── sql-1999-grammar.txt
├── sql-2003-foundation-grammar.txt
├── sql-2008-foundation-grammar.txt
├── sql-2011-foundation-grammar.txt
├── sql-2011-psm-grammar.txt
├── sql-2016-foundation-grammar.txt
├── sql-92-grammar.txt
├── sql-overview.cabal
└── sql1992.txt


/.gitignore:
--------------------------------------------------------------------------------
1 | /.cabal-sandbox/
2 | /GrammarToAsciidoc
3 | *.hi
4 | *.o
5 | /cabal.sandbox.config
6 | /build/
7 | /dist-newstyle/
8 | 
9 | 


--------------------------------------------------------------------------------
/AddLinks.lhs:
--------------------------------------------------------------------------------
 1 | 
 2 | Little hack to add links to the navigation bars
 3 | 
 4 | > main :: IO ()
 5 | > main = interact addLinks
 6 | 
 7 | 
 8 | > addLinks :: String -> String
 9 | > addLinks [] = error "not found"
10 | > addLinks ('<':'/':'u':'l':'>':'\n':'<':'/':'d':'i':'v':'>':xs) =
11 | >     "</ul>" ++ linkSection ++ "\n</div>" ++ xs
12 | > addLinks (x:xs) = x : addLinks xs
13 | 
14 | > linkSection :: String
15 | > linkSection =
16 | >   "<hr />\n\
17 | >   \<ul class=\"sectlevel1\">\n\
18 | >   \<div id=\"toctitle\">Links</div>\n\
19 | >   \<li><a href=\"index.html\">Index</a></li>\n\
20 | >   \<li><a href='sql-92-grammar.html'>SQL-92</li>\n\
21 | >   \<li><a href='sql-1999-grammar.html'>SQL:1999</li>\n\
22 | >   \<li><a href='sql-2003-foundation-grammar.html'>SQL:2003</li>\n\
23 | >   \<li><a href='sql-2008-foundation-grammar.html'>SQL:2008</li>\n\
24 | >   \<li><a href='sql-2011-foundation-grammar.html'>SQL:2011</li>\n\
25 | >   \<li><a href='sql-2011-psm-grammar.html'>SQL:2011 SQL/PSM</li>\n\
26 | >   \<li><a href='sql-2016-foundation-grammar.html'>SQL:2016</li>\n\
27 | >   \</ul>\n\
28 | >   \<br />\n\
29 | >   \<ul class=\"sectlevel1\">\n\
30 | >   \<li><a href=\"http://jakewheat.github.io/sql-overview\" class=\"bare\">Homepage</a></li>\n\
31 | >   \<li><a href=\"https://github.com/JakeWheat/sql-overview\" class=\"bare\">Repository</a></li>\n\
32 | >   \<li><a href=\"https://github.com/JakeWheat/sql-overview/issues\" class=\"bare\">Bug tracker</a></li>\n\
33 | >   \<li><a href=\"http://jakewheat.github.io/\" class=\"bare\">Parent project</a>\n\
34 | >   \</li><li>jakewheatmail@gmail.com</li>\n\
35 | >   \</ul>\n"
36 | 


--------------------------------------------------------------------------------
/GrammarToAsciidoc.lhs:
--------------------------------------------------------------------------------
  1 | 
  2 | This file converts the text grammar files into asciidoc
  3 | 
  4 | creates asciidoc headings from the text headings (==, ===)
  5 | changes 'Function' and 'Format' into local headings (.Function)
  6 | adds anchors to the start of each grammar def
  7 | adds anchor links in the grammar def bodies
  8 | adds blocks around the grammar defs
  9 | 
 10 | TODO:
 11 | 
 12 | add backreferences from grammer def names to usage sites (in
 13 | side bar?)
 14 | 
 15 | get links working e.g. from psm to foundation doc
 16 | 
 17 | > import Data.Char
 18 | > --import System.Environment
 19 | > --import Data.List
 20 | > import Text.Regex
 21 | 
 22 | > --import Debug.Trace
 23 | 
 24 | > main :: IO ()
 25 | > main = do
 26 | >   str <- getContents
 27 | >   let ls = lines str
 28 | >       ls' = addBlocks False ls
 29 | >   putStrLn ":toc: right\n\n= Document\n"
 30 | >   putStrLn $ unlines ls'
 31 | 
 32 | 
 33 | start a pre block:
 34 | add the anchor and start the block
 35 | 
 36 | > addBlocks :: Bool -> [String] -> [String]
 37 | > addBlocks False (x@('<':t):xs) = --trace (show ("g",x)) $
 38 | >     let t' = hyphenize $ takeWhile (/='>') t
 39 | >     in ("[[" ++ t' ++ "]]")
 40 | >        :"[subs=\"specialcharacters,macros\"]"
 41 | >        :"----":x:addBlocks True xs
 42 | >   where
 43 | >     hyphenize = map $ \c -> case c of
 44 | >         ' ' -> '-'
 45 | >         _ -> c
 46 | 
 47 | inside a pre block, check if this is the end of the block
 48 | 
 49 | special case for the keywords which have empty lines inside the
 50 | grammar defs
 51 | 
 52 | > addBlocks True (x:y:xs) | trim x == ""
 53 | >                           && startsWithPipe (trim y)
 54 | >      = x:addBlocks True (y:xs)
 55 | >   where
 56 | >     startsWithPipe ('|':_) = True
 57 | >     startsWithPipe _ = False
 58 | 
 59 | regular end of grammar def - an empty line
 60 | 
 61 | > addBlocks True (x:xs) | trim x == "" = "----":x:addBlocks False xs
 62 | 
 63 | 
 64 | inside a pre block, change a grammar reference into an anchorlink
 65 | line with grammar defs, add links
 66 | 
 67 | (<([^>]*)>) ->  <<replace-space-with-hyphen \2, \1 >
 68 | 
 69 | example:
 70 | <SQL language character>
 71 | ->
 72 | <<SQL-language-character, <SQL language character> >>
 73 | 
 74 | > {-addBlocks True (x@(' ':_):xs)
 75 | >   | trace (show (grammarLine x, x)) False = undefined
 76 | >   where
 77 | >     grammarLine y = case dropWhile isSpace y of
 78 | >         '<':_ -> True
 79 | >         _ -> False-}
 80 | 
 81 | > addBlocks True (x@(' ':_):xs) =
 82 | >     fixLinks (
 83 | >       subRegex (mkRegex "(<([^>]*)>)") x "<<\\2, \\1 >>")
 84 | >     : addBlocks True xs
 85 | >   where
 86 | >     {-grammarLine y = case dropWhile isSpace y of
 87 | >         '<':_ -> True
 88 | >         _ -> False-}
 89 | >     fixLinks ('<':'<':ts) = '<':'<': hyph ts
 90 | >     fixLinks (t:ts) = t : fixLinks ts
 91 | >     fixLinks [] = []
 92 | >     hyph (',':ts) = ',':fixLinks ts
 93 | >     hyph (' ':ts) = '-' : hyph ts
 94 | >     hyph (t:ts) = t : hyph ts
 95 | >     hyph [] = []
 96 | 
 97 | 
 98 | > addBlocks True (x:xs) = x:addBlocks True xs
 99 | 
100 | add a newline after function,format headers so they render nicely
101 | 
102 | > addBlocks False (x:xs) | trim x `elem` headers =
103 | >     ('.':x):"":addBlocks False xs
104 | >   where headers = ["Function","Format"]
105 | 
106 | section titles
107 | 
108 | > addBlocks False (x@(c1:_):xs) | isDigit c1 =
109 | >     (case dropWhile isDigit x of
110 | >          '.':_ -> "=== " ++ x
111 | >          _ -> "== " ++ x)
112 | >     : addBlocks False xs
113 | 
114 | 
115 | any other line: todo, check for anchor links
116 | 
117 | > addBlocks False (x:xs) = x:addBlocks False xs
118 | 
119 | finished the document
120 | 
121 | > addBlocks True [] = ["----"]
122 | > addBlocks False [] = []
123 | 
124 | 
125 | 
126 | > trim :: String -> String
127 | > trim = f . f
128 | >    where f = reverse . dropWhile isSpace
129 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | This project contains grammars for the ANSI SQL Standards (taken from
  2 | the drafts).
  3 | 
  4 | See the HTML rendered grammars here:
  5 | 
  6 | http://jakewheat.github.io/sql-overview/
  7 | 
  8 | TODO
  9 | Cover most of the SQL Standard:
 10 | 
 11 | explain what the concepts are. Document the names for these in the SQL
 12 | standard, and what names products use.
 13 | 
 14 | Focus mostly on grammar, but also on semantics. Explain and give
 15 | examples of sql source, and cover the availability of these in sql
 16 | products, mentioning the compatibility with the standard and other
 17 | products, and the jargon used for each product.
 18 | 
 19 | The reader should go away with:
 20 | 
 21 | * an understanding of what is in the standard and what the names of
 22 |   things really mean
 23 | 
 24 | * an understanding of which bits of the standard are widely supported,
 25 |   which bits are widely supported but with varying syntax or
 26 |   behaviour, and which bits exist only in the minds of the sql
 27 |   standards people and don't relate to reality
 28 | 
 29 | * an understanding of why features exist and what purpose they are for
 30 | 
 31 | * an understanding of which features are supported in a range of
 32 |   common products
 33 | 
 34 | * a good and in depth appreciation for sql's strengths and weaknesses
 35 | 
 36 | Provisional product list ideas: db2, oracle, sql server, sap dbmss,
 37 | postgresql, mysql.
 38 | 
 39 | TODO: cross referenced grammar
 40 | 
 41 | What kinds of features are in the standards:
 42 | 
 43 | 1 syntax which everyone supports
 44 | 2 syntax which many dbmss support
 45 | 3 features which many dbmss support with different syntax
 46 | 4 features which many dbmss support, possibly with different syntax,
 47 |   with not very similar semantics
 48 | 5 features which no or very few dbmss support
 49 | 
 50 | -------
 51 | 
 52 | TOC ideas:
 53 | databases, tables, queries, updates
 54 | 
 55 | scalar types
 56 | type constructors: row, array, multiset
 57 | scalar expressions
 58 | dml
 59 |   queries
 60 | 
 61 |     queries
 62 |     select list
 63 |     table ref, joins
 64 |     aggregates, group by, grouping sets
 65 |     window functions
 66 |     where, having
 67 |     limit, offset
 68 |     order by
 69 |     set operations
 70 |     cte
 71 |     array unnest and variations?
 72 |     subqueries, csq, lateral
 73 | 
 74 |   updates
 75 |     delete
 76 |     truncate
 77 |     insert
 78 |     merge
 79 |     update
 80 |   cursors
 81 |   temporary tables ??
 82 | ddl, schemas
 83 |     tables, columns
 84 |     defaults, identity, sequences
 85 |     constraints, unique/pk, not null, referential, check
 86 |     alter table
 87 |     table periods, system versioning
 88 |     other schema objects
 89 | 
 90 | locators??
 91 | transaction management
 92 | session management
 93 | catalog
 94 | access control
 95 | 
 96 | clients, servers, sessions, connections
 97 | databases, 'catalog clusters', and schemas
 98 | 
 99 | control statements
100 | connection management
101 | diagnostics
102 | 
103 | dynamic sql
104 | embedded sql
105 | direct invocation
106 | 
107 | procedural sql
108 | external data
109 | extensibility
110 | 
111 | call level interface
112 | persistent stored modules
113 | management of external data
114 | object language bindings (java?)
115 | information and definition schema
116 | java
117 | xml
118 | 
119 | 
120 | --------------------------
121 | 
122 | postgres manual says that there are 179 mandatory features for 2011
123 | core conformance, postgres does 160, and no database product does all
124 | of these
125 | 
126 | 


--------------------------------------------------------------------------------
/Setup.hs:
--------------------------------------------------------------------------------
1 | import Distribution.Simple
2 | main = defaultMain
3 | 


--------------------------------------------------------------------------------
/fix_lines.pl:
--------------------------------------------------------------------------------
 1 | #read stdin as a single string and not a line at a time
 2 | my $whole_file; { local $/; $whole_file = <STDIN> };
 3 | 
 4 | # line wrapped in the middle of reference <like this>
 5 | # This:
 6 | # some text <about
 7 | #    a thing> really references <about a thing>
 8 | # Turns into:
 9 | # some text <about a thing> really references <about a thing>
10 | #
11 | # first capture group gets an unclosed < that looks like a reference
12 | # then uncaptured whitespace around a newline
13 | # second capture group gets the rest of the reference and its closing >
14 | # the replacement has a space in the middle to replace the whitespace that was a newline
15 | $whole_file =~ s/(<[a-z][a-zA-Z: ]*)\s*\n\s*([a-zA-Z: ]+[a-z]>)/$1 $2/g;
16 | 
17 | # remove linebreaks in paragraph text that put a reference at the beginning of a line
18 | # the only allowed references at the beginning of the line are actual definitions with ::= on the same line
19 | $whole_file =~ s/(\w)\s*\n(<[a-z][a-zA-Z: ]+[a-z]>(?!.*::=))/$1 $2/g;
20 | 
21 | # print the processed file back out for further processing
22 | print $whole_file;
23 | 


--------------------------------------------------------------------------------
/index.asciidoc:
--------------------------------------------------------------------------------
  1 | 
  2 | :toc: right
  3 | :toclevels: 8
  4 | 
  5 | = SQL overview
  6 | 
  7 | == Overview
  8 | 
  9 | WIP
 10 | 
 11 | This is a project to review SQL: run through the standard and explain
 12 | what each feature is, explain the jargon terms, explain why the
 13 | feature exists, and explain the relationship with real sql products -
 14 | standard feature, possibly with different syntax/ different semantics/
 15 | different names/jargon; or one of those SQL Standard things which
 16 | bears no relationship to reality.
 17 | 
 18 | Maybe provide a little history and context also, with a little bit of
 19 | relational theory.
 20 | 
 21 | Glossary for SQL
 22 | 
 23 | == SQL recommended reading
 24 | 
 25 | SQL: The Complete Reference, 3rd Edition, James R. Groff, Paul
 26 | N. Weinberg, Andrew J. Oppel
 27 | 
 28 | This is a comprehensive book which covers up to the SQL:1999 standard.
 29 |  +
 30 |  +
 31 |  +
 32 | SQL in a Nutshell, Kevin Kline, Brand Hunt, Daniel Kline
 33 | 
 34 | This is another good book which covers some of the SQL:2003 and
 35 | SQL:2008 standards. This means it covers a few newer things like
 36 | window functions which 'SQL: The Complete Reference' doesn't. It also
 37 | compares some main SQL product dialects.
 38 |  +
 39 |  +
 40 |  +
 41 | SQL A Comparative Survey, Hugh Darwen +
 42 | http://bookboon.com/en/sql-a-comparative-survey-ebook
 43 | 
 44 | This is a book about SQL from a relational theory perspective.
 45 |  +
 46 |  +
 47 |  +
 48 | SQL and Relational Theory, 2nd Edition, Chris Date
 49 | 
 50 | This also covers SQL from a partly theoretical perspective.
 51 |  +
 52 |  +
 53 |  +
 54 | A Guide to the SQL Standard, C. J. Date, Hugh Darwen
 55 | 
 56 | This is a fantastic book for covering all the little details of the
 57 | SQL standard in depth. It only covers up to SQL:92.
 58 |  +
 59 |  +
 60 |  +
 61 | There are several other good books by Chris Date, some with Hugh
 62 | Darwen and others, for instance 'Introduction to Database Systems',
 63 | 'Temporal Data & the Relational Model, Databases', 'Types and the
 64 | Relational Model'. Only the first one (Introduction to
 65 | Database Systems) really relates to SQL.
 66 |  +
 67 |  +
 68 |  +
 69 | Database Systems: The Complete Book, Hector Garcia-Molina, Jeff Ullman, and Jennifer Widom.
 70 | 
 71 | This book is very comprehensive and has some interesting sections.
 72 |  +
 73 |  +
 74 |  +
 75 | Some of the SQL draft standards are available to download for free
 76 | (follow the links on the wikipedia page for SQL or try google). They
 77 | are a little tricky to read and understand. You can find some stuff at
 78 | these links. There is also the grammars from the draft standards
 79 | below on this page.
 80 | 
 81 | http://savage.net.au/SQL/index.html
 82 | 
 83 | http://www.wiscorp.com/SQLStandards.html
 84 |  +
 85 |  +
 86 |  +
 87 | //TODO: add stuff about transactions, cbo, newsql?
 88 | 
 89 | == SQL products' manuals
 90 | 
 91 | IBM DB2 10.5 SQL Reference Volume 1
 92 | 
 93 | http://public.dhe.ibm.com/ps/products/db2/info/vr105/pdf/en_US/DB2SQLRefVol1-db2s1e1050.pdf
 94 |  +
 95 |  +
 96 |  +
 97 | Oracle SQL Reference 12c release 1
 98 | 
 99 | http://docs.oracle.com/cd/E16655_01/server.121/e17209.pdf
100 |  +
101 |  +
102 |  +
103 | Teradata:
104 | 
105 | TODO
106 |  +
107 |  +
108 |  +
109 | Microsoft SQL Server 2012 TSQL reference online. I didn't find a PDF
110 | for this.
111 | 
112 | http://technet.microsoft.com/en-us/library/bb510741.aspx
113 |  +
114 |  +
115 |  +
116 | PostgreSQL 9.4 manual:
117 | 
118 | http://www.postgresql.org/docs/9.4/interactive/index.html
119 | 
120 | No PDF for the Postgres manual either, but the web pages are very
121 | readable.
122 |  +
123 |  +
124 |  +
125 | TODO: MySQL, Redshift, Netezza, Vertica, Vectorwise,
126 | Infobright, MemSQL, FoundationDB, Dataphor, EnterpriseDB, Pivotal,
127 | Informix, Ingres, MariaDB, SQLite, Firebird, MonetDB, Nonstop SQL?,
128 | some small subset of the SAP SQL DBMSs (maxdb, anywhere, hana?).
129 | 
130 | == SQL Grammars
131 | 
132 | link:sql-92-grammar.html[]
133 | 
134 | link:sql-1999-grammar.html[]
135 | 
136 | link:sql-2003-foundation-grammar.html[]
137 | 
138 | link:sql-2008-foundation-grammar.html[]
139 | 
140 | link:sql-2011-foundation-grammar.html[]
141 | 
142 | link:sql-2011-psm-grammar.html[]
143 | 


--------------------------------------------------------------------------------
/make_website.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | 
 3 | # instructions: have a recent version of cabal-install and ghc in your path
 4 | # and perl, asciidoctor
 5 | # run this file and it will generate the html to the build dir
 6 | # tested with cabal-install 3.0.0.0 and ghc 8.10.1
 7 | # should work with earlier versions of both (and later)
 8 | # last ran with asciidoctor 1.5.8
 9 | 
10 | set -e
11 | 
12 | mkdir -p build
13 | 
14 | asciidoctor index.asciidoc -o -| cabal run -v0 AddLinks > build/index.html
15 | 
16 | for i in sql-92-grammar sql-1999-grammar sql-2003-foundation-grammar sql-2008-foundation-grammar sql-2011-foundation-grammar sql-2011-psm-grammar sql-2016-foundation-grammar; do
17 |     echo $i
18 |     perl fix_lines.pl < $i.txt | cabal run -v0 GrammarToAsciidoc | asciidoctor - | cabal run -v0 AddLinks > build/$i.html
19 | done
20 | 
21 | 


--------------------------------------------------------------------------------
/sql-2011-psm-grammar.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | 5 Lexical elements
  3 | 
  4 | This Clause modifies Clause 5, "Lexical elements", in ISO/IEC 9075-2.
  5 | 
  6 | 
  7 | 
  8 | 5.1      <token> and <separator>
  9 | 
 10 | Function
 11 | Specify lexical units (tokens and separators) that participate in SQL language.
 12 | 
 13 | 
 14 | Format
 15 | <non-reserved word> ::=
 16 |     !! All alternatives from ISO/IEC 9075-2
 17 | 
 18 |   | CONDITION_IDENTIFIER
 19 | 
 20 |   | EXIT
 21 | 
 22 |   | STACKED
 23 | 
 24 |   | UNDO
 25 | 
 26 | <reserved word> ::=
 27 |     !! All alternatives from ISO/IEC 9075-2
 28 | 
 29 |   | DO
 30 | 
 31 |   | ELSEIF
 32 | 
 33 |   | HANDLER
 34 | 
 35 |   | IF | ITERATE
 36 | 
 37 |   | LEAVE | LOOP
 38 | 
 39 |   | REPEAT | RESIGNAL
 40 | 
 41 |   | SIGNAL
 42 | 
 43 |   | UNTIL
 44 | 
 45 |   | WHILE
 46 | 
 47 | 5.2        Names and identifiers
 48 | 
 49 | Function
 50 | Specify names.
 51 | 
 52 | 
 53 | Format
 54 | <SQL-server module name> ::=
 55 |   <schema qualified name>
 56 | 
 57 | <SQL variable name> ::=
 58 |   <identifier>
 59 | 
 60 | <condition name> ::=
 61 |   <identifier>
 62 | 
 63 | 6 Scalar expressions
 64 | 
 65 | 6.1      <value specification> and <target specification>
 66 | 
 67 | Function
 68 | Specify one or more values, host parameters, SQL parameters, dynamic parameters, host variables, or SQL
 69 | variables.
 70 | 
 71 | 
 72 | Format
 73 | <general value specification> ::=
 74 |     !! All alternatives from ISO/IEC 9075-2
 75 |   | <SQL variable reference>
 76 | 
 77 | <simple value specification> ::=
 78 |     !! All alternatives from ISO/IEC 9075-2
 79 |   | <SQL variable reference>
 80 | 
 81 | <target specification> ::=
 82 |     !! All alternatives from ISO/IEC 9075-2
 83 |   | <SQL variable reference>
 84 | 
 85 | <simple target specification> ::=
 86 |     !! All alternatives from ISO/IEC 9075-2
 87 |   | <SQL variable reference>
 88 | 
 89 | <target array reference> ::=
 90 |     !! All alternatives from ISO/IEC 9075-2
 91 |   | <SQL variable reference>
 92 | 
 93 | 6.4      <SQL variable reference>
 94 | 
 95 | Function
 96 | Reference an SQL variable.
 97 | 
 98 | 
 99 | Format
100 | <SQL variable reference> ::=
101 |   <basic identifier chain>
102 | 
103 | 8 Persistent Stored Modules (SQL/PSM)
104 | 
105 | 8.2        <sqlstate value>
106 | 
107 | Function
108 | Specify an SQLSTATE value.
109 | 
110 | 
111 | Format
112 | <sqlstate value> ::=
113 |   SQLSTATE [ VALUE ] <character string literal>
114 | 
115 | 9 Schema definition and manipulation
116 | 
117 | 9.1      <schema definition>
118 | 
119 | Function
120 | Define a schema.
121 | 
122 | 
123 | Format
124 | <schema element> ::=
125 |     !! All alternatives from ISO/IEC 9075-2
126 |   | <SQL-server module definition>
127 | 
128 | 9.19 <trigger definition>
129 | 
130 | Function
131 | Defined triggered SQL-statements.
132 | 
133 | 
134 | Format
135 | <triggered SQL statement> ::=
136 |   <SQL procedure statement>
137 |      NOTE 12 - The preceding production defining <triggered SQL statement> completely supersedes the definition in [ISO9075-2].
138 | 
139 | 9.21 <SQL-server module definition>
140 | 
141 | Function
142 | Define an SQL-server module.
143 | 
144 | 
145 | Format
146 | <SQL-server module definition> ::=
147 |   CREATE MODULE <SQL-server module name>
148 |       [ <SQL-server module character set specification> ]
149 |       [ <SQL-server module schema clause> ]
150 |       [ <SQL-server module path specification> ]
151 |       [ <temporary table declaration>... ]
152 |       <SQL-server module contents>...
153 |       END MODULE
154 | 
155 | <SQL-server module character set specification> ::=
156 |   NAMES ARE <character set specification>
157 | 
158 | <SQL-server module schema clause> ::=
159 |   SCHEMA <default schema name>
160 | 
161 | <default schema name> ::=
162 |   <schema name>
163 | 
164 | <SQL-server module path specification> ::=
165 |   <path specification>
166 | 
167 | <SQL-server module contents> ::=
168 |   <SQL-invoked routine> <semicolon>
169 | 
170 | 9.22 <drop module statement>
171 | 
172 | Function
173 | Destroy an SQL-server module.
174 | 
175 | 
176 | Format
177 | <drop module statement> ::=
178 |   DROP MODULE <SQL-server module name> <drop behavior>
179 | 
180 | 9.24 <SQL-invoked routine>
181 | 
182 | Function
183 | Define an SQL-invoked routine.
184 | 
185 | 
186 | Format
187 | <SQL-invoked routine> ::=
188 |     !! All alternatives from ISO/IEC 9075-2
189 |   | <module routine>
190 | 
191 | <module routine> ::=
192 |     <module procedure>
193 |   | <module function>
194 | 
195 | <module procedure> ::=
196 |   [ DECLARE ] <SQL-invoked procedure>
197 | 
198 | <module function> ::=
199 |   [ DECLARE ] <SQL-invoked function>
200 | 
201 | 10 Access control
202 | 
203 | 10.2 <privileges>
204 | 
205 | This Subclause modifies Subclause 12.3, "<privileges>", in ISO/IEC 9075-2.
206 | 
207 | 
208 | Function
209 | Specify privileges.
210 | 
211 | 
212 | Format
213 | <object name> ::=
214 |     !! All alternatives from ISO/IEC 9075-2
215 |   | MODULE <SQL-server module name>
216 | 
217 | 11 SQL-client modules
218 | 
219 | 11.2 <SQL procedure statement>
220 | 
221 | Function
222 | Define all of the SQL-statements that are <SQL procedure statement>s.
223 | 
224 | 
225 | Format
226 | <SQL schema definition statement> ::=
227 |     !! All alternatives from ISO/IEC 9075-2
228 |   | <SQL-server module definition>
229 | 
230 | <SQL schema manipulation statement> ::=
231 |     !! All alternatives from ISO/IEC 9075-2
232 |   | <drop module statement>
233 | 
234 | <SQL control statement> ::=
235 |     !! All alternatives from ISO/IEC 9075-2
236 |   | <assignment statement>
237 |   | <compound statement>
238 |   | <case statement>
239 |   | <if statement>
240 |   | <iterate statement>
241 |   | <leave statement>
242 |   | <loop statement>
243 |   | <while statement>
244 |   | <repeat statement>
245 |   | <for statement>
246 | 
247 | <SQL diagnostics statement> ::=
248 |     !! All alternatives from ISO/IEC 9075-2
249 |   | <signal statement>
250 |   | <resignal statement>
251 | 
252 | 14 Control statements
253 | 
254 | 14.1 <compound statement>
255 | 
256 | Function
257 | Specify a statement that groups other statements together.
258 | 
259 | 
260 | Format
261 | <compound statement> ::=
262 |   [ <beginning label> <colon> ] BEGIN [ [ NOT ] ATOMIC ]
263 |       [ <local declaration list> ] [ <local cursor declaration list> ]
264 |       [ <local handler declaration list> ]
265 |       [ <SQL statement list> ]
266 |       END [ <ending label> ]
267 | 
268 | <beginning label> ::=
269 |   <statement label>
270 | 
271 | <ending label> ::=
272 |   <statement label>
273 | 
274 | <statement label> ::=
275 |   <identifier>
276 | 
277 | <local declaration list> ::=
278 |   <terminated local declaration>...
279 | 
280 | <terminated local declaration> ::=
281 |   <local declaration> <semicolon>
282 | 
283 | <local declaration> ::=
284 |     <SQL variable declaration>
285 |   | <condition declaration>
286 | 
287 | <local cursor declaration list> ::=
288 |   <terminated local cursor declaration>...
289 | 
290 | <terminated local cursor declaration> ::=
291 |   <declare cursor> <semicolon>
292 | 
293 | <local handler declaration list> ::=
294 |   <terminated local handler declaration>...
295 | 
296 | <terminated local handler declaration> ::=
297 |   <handler declaration> <semicolon>
298 | 
299 | <SQL statement list> ::=
300 |   <terminated SQL statement>...
301 | 
302 | <terminated SQL statement> ::=
303 |   <SQL procedure statement> <semicolon>
304 | 
305 | 14.2 <handler declaration>
306 | 
307 | Function
308 | Associate a handler with exception or completion conditions to be handled in a module or compound statement.
309 | 
310 | 
311 | Format
312 | <handler declaration> ::=
313 |   DECLARE <handler type> HANDLER FOR <condition value list> <handler action>
314 | 
315 | <handler type> ::=
316 |     CONTINUE
317 |   | EXIT
318 |   | UNDO
319 | 
320 | <handler action> ::=
321 |   <SQL procedure statement>
322 | 
323 | <condition value list> ::=
324 |   <condition value> [ { <comma> <condition value> }... ]
325 | 
326 | <condition value> ::=
327 |     <sqlstate value>
328 |   | <condition name>
329 |   | SQLEXCEPTION
330 |   | SQLWARNING
331 |   | NOT FOUND
332 | 
333 | 14.3 <condition declaration>
334 | 
335 | Function
336 | Declare a condition name and an optional corresponding SQLSTATE value.
337 | 
338 | 
339 | Format
340 | <condition declaration> ::=
341 |   DECLARE <condition name> CONDITION [ FOR <sqlstate value> ]
342 | 
343 | 14.4 <SQL variable declaration>
344 | 
345 | Function
346 | Declare one or more variables.
347 | 
348 | 
349 | Format
350 | <SQL variable declaration> ::=
351 |   DECLARE <SQL variable name list> <data type> [ <default clause> ]
352 | 
353 | <SQL variable name list> ::=
354 |   <SQL variable name> [ { <comma> <SQL variable name> }... ]
355 | 
356 | 14.5 <assignment statement>
357 | 
358 | Function
359 | Assign a value to an SQL variable, SQL parameter, host parameter, or host variable.
360 | 
361 | 
362 | Format
363 | <assignment statement> ::=
364 |     <singleton variable assignment>
365 |   | <multiple variable assignment>
366 | 
367 | <multiple variable assignment> ::=
368 |   SET <assignment target list> <equals operator> <assigned row>
369 | 
370 | <assignment target list> ::=
371 |   <left paren> <assignment target> [ { <comma> <assignment target> }... ] <right paren>
372 | 
373 | <singleton variable assignment> ::=
374 |   SET <assignment target> <equals operator> <assignment source>
375 | 
376 | <assignment target> ::=
377 |     <target specification>
378 |   | <modified field reference>
379 |   | <mutator reference>
380 | 
381 | <assignment source> ::=
382 |     <value expression>
383 |   | <contextually typed source>
384 | 
385 | <contextually typed source> ::=
386 |     <implicitly typed value specification>
387 |   | <contextually typed row value expression>
388 | 
389 | <modified field reference> ::=
390 |   <modified field target> <period> <field name>
391 | 
392 | <modified field target> ::=
393 |     <target specification>
394 |   | <left paren> <target specification> <right paren>
395 |   | <modified field reference>
396 | 
397 | <mutator reference> ::=
398 |   <mutated target specification> <period> <method name>
399 | 
400 | <mutated target specification> ::=
401 |     <target specification>
402 |   | <left paren> <target specification> <right paren>
403 |   | <mutator reference>
404 | 
405 | 14.6 <case statement>
406 | 
407 | Function
408 | Provide conditional execution based on truth of <search condition>s or on equality of operands.
409 | 
410 | 
411 | Format
412 | <case statement> ::=
413 |     <simple case statement>
414 |   | <searched case statement>
415 | 
416 | <simple case statement> ::=
417 |   CASE <case operand>
418 |       <simple case statement when clause>...
419 |       [ <case statement else clause> ]
420 |       END CASE
421 | 
422 | <searched case statement> ::=
423 |   CASE <searched case statement when clause>...
424 |       [ <case statement else clause> ]
425 |       END CASE
426 | 
427 | <simple case statement when clause> ::=
428 |   WHEN <when operand list>
429 |       THEN <SQL statement list>
430 | 
431 | <searched case statement when clause> ::=
432 |   WHEN <search condition>
433 |       THEN <SQL statement list>
434 | 
435 | <case statement else clause> ::=
436 |   ELSE <SQL statement list>
437 | 
438 | 14.7 <if statement>
439 | 
440 | Function
441 | Provide conditional execution based on the truth value of a condition.
442 | 
443 | 
444 | Format
445 | <if statement> ::=
446 |   IF <search condition>
447 |       <if statement then clause>
448 |       [ <if statement elseif clause>... ]
449 |       [ <if statement else clause> ]
450 |       END IF
451 | 
452 | <if statement then clause> ::=
453 |   THEN <SQL statement list>
454 | 
455 | <if statement elseif clause> ::=
456 |   ELSEIF <search condition> THEN <SQL statement list>
457 | 
458 | <if statement else clause> ::=
459 |   ELSE <SQL statement list>
460 | 
461 | 14.8 <iterate statement>
462 | 
463 | Function
464 | Terminate the execution of an iteration of an iterated SQL-statement.
465 | 
466 | 
467 | Format
468 | <iterate statement> ::=
469 |   ITERATE <statement label>
470 | 
471 | 14.9 <leave statement>
472 | 
473 | Function
474 | Continue execution by leaving a labeled statement.
475 | 
476 | 
477 | Format
478 | <leave statement> ::=
479 |   LEAVE <statement label>
480 | 
481 | 14.10 <loop statement>
482 | 
483 | Function
484 | Repeat the execution of a statement.
485 | 
486 | 
487 | Format
488 | <loop statement> ::=
489 |   [ <beginning label> <colon> ]
490 |       LOOP
491 |       <SQL statement list>
492 |       END LOOP [ <ending label> ]
493 | 
494 | 14.11 <while statement>
495 | 
496 | Function
497 | While a specified condition is True, repeat the execution of a statement.
498 | 
499 | 
500 | Format
501 | <while statement> ::=
502 |   [ <beginning label> <colon> ]
503 |       WHILE <search condition> DO
504 |       <SQL statement list>
505 |       END WHILE [ <ending label> ]
506 | 
507 | 14.12 <repeat statement>
508 | 
509 | Function
510 | Repeat the execution of a statement.
511 | 
512 | 
513 | Format
514 | <repeat statement> ::=
515 |   [ <beginning label> <colon> ]
516 |       REPEAT
517 |       <SQL statement list>
518 |       UNTIL <search condition>
519 |       END REPEAT [ <ending label> ]
520 | 
521 | 14.13 <for statement>
522 | 
523 | Function
524 | Execute a statement for each row of a table.
525 | 
526 | 
527 | Format
528 | <for statement> ::=
529 |   [ <beginning label> <colon> ]
530 |       FOR [ <for loop variable name> AS ]
531 |       [ <cursor name> [ <cursor sensitivity> ] CURSOR FOR ]
532 |       <cursor specification>
533 |       DO <SQL statement list>
534 |       END FOR [ <ending label> ]
535 | 
536 | <for loop variable name> ::=
537 |   <identifier>
538 | 
539 | 17 Diagnostics management
540 | 
541 | 17.1 <get diagnostics statement>
542 | 
543 | Function
544 | Get exception or completion condition information from the diagnostics area.
545 | 
546 | 
547 | Format
548 | <get diagnostics statement> ::=
549 |   GET [ <which area> ] DIAGNOSTICS <SQL diagnostics information>
550 | 
551 | <which area> ::=
552 |     CURRENT
553 |   | STACKED
554 | 
555 | <condition information item name> ::=
556 |     !! All alternatives from [ISO9075-2]
557 |   | CONDITION_IDENTIFIER
558 | 
559 | 17.2 <signal statement>
560 | 
561 | Function
562 | Signal an exception condition.
563 | 
564 | 
565 | Format
566 | <signal statement> ::=
567 |   SIGNAL <signal value> [ <set signal information> ]
568 | 
569 | <signal value> ::=
570 |     <condition name>
571 |   | <sqlstate value>
572 | 
573 | <set signal information> ::=
574 |   SET <signal information item list>
575 | 
576 | <signal information item list> ::=
577 |   <signal information item> [ { <comma> <signal information item> }... ]
578 | 
579 | <signal information item> ::=
580 |   <condition information item name> <equals operator> <simple value specification>
581 | 
582 | 17.3 <resignal statement>
583 | 
584 | Function
585 | Resignal an exception condition.
586 | 
587 | 
588 | Format
589 | <resignal statement> ::=
590 |   RESIGNAL [ <signal value> ] [ <set signal information> ]
591 | 


--------------------------------------------------------------------------------
/sql-92-grammar.txt:
--------------------------------------------------------------------------------
   1 | 5  Lexical elements
   2 | 
   3 | 
   4 | 
   5 | 5.1  <SQL terminal character>
   6 | 
   7 | Function
   8 | 
   9 | Define the terminal symbols of the SQL language and the elements of
  10 | strings.
  11 | 
  12 | Format
  13 | 
  14 | <SQL terminal character> ::=
  15 |        <SQL language character>
  16 |      | <SQL embedded language character>
  17 | 
  18 | <SQL embedded language character> ::=
  19 |        <left bracket>
  20 |      | <right bracket>
  21 | 
  22 | <SQL language character> ::=
  23 |        <simple Latin letter>
  24 |      | <digit>
  25 |      | <SQL special character>
  26 | 
  27 | <simple Latin letter> ::=
  28 |        <simple Latin upper case letter>
  29 |      | <simple Latin lower case letter>
  30 | 
  31 | <simple Latin upper case letter> ::=
  32 |            A | B | C | D | E | F | G | H | I | J | K | L | M | N | O
  33 |      | P | Q | R | S | T | U | V | W | X | Y | Z
  34 | 
  35 | <simple Latin lower case letter> ::=
  36 |            a | b | c | d | e | f | g | h | i | j | k | l | m | n | o
  37 |      | p | q | r | s | t | u | v | w | x | y | z
  38 | 
  39 | <digit> ::=
  40 |      0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  41 | 
  42 | <SQL special character> ::=
  43 |        <space>
  44 |      | <double quote>
  45 |      | <percent>
  46 |      | <ampersand>
  47 |      | <quote>
  48 |      | <left paren>
  49 |      | <right paren>
  50 |      | <asterisk>
  51 |      | <plus sign>
  52 |      | <comma>
  53 |      | <minus sign>
  54 |      | <period>
  55 |      | <solidus>
  56 |      | <colon>
  57 |      | <semicolon>
  58 |      | <less than operator>
  59 |      | <equals operator>
  60 |      | <greater than operator>
  61 |      | <question mark>
  62 |      | <underscore>
  63 |      | <vertical bar>
  64 | 
  65 | <space> ::= !! space character in character set in use
  66 | 
  67 | <double quote> ::= "
  68 | 
  69 | <percent> ::= %
  70 | 
  71 | <ampersand> ::= &
  72 | 
  73 | <quote> ::= '
  74 | 
  75 | <left paren> ::= (
  76 | 
  77 | <right paren> ::= )
  78 | 
  79 | <asterisk> ::= *
  80 | 
  81 | <plus sign> ::= +
  82 | 
  83 | <comma> ::= ,
  84 | 
  85 | <minus sign> ::= -
  86 | 
  87 | <period> ::= .
  88 | 
  89 | <solidus> ::= /
  90 | 
  91 | <colon> ::= :
  92 | 
  93 | <semicolon> ::= ;
  94 | 
  95 | <less than operator> ::= <
  96 | 
  97 | <equals operator> ::= =
  98 | 
  99 | <greater than operator> ::= >
 100 | 
 101 | <question mark> ::= ?
 102 | 
 103 | <left bracket> ::= [
 104 | 
 105 | <right bracket> ::= ]
 106 | 
 107 | <underscore> ::= _
 108 | 
 109 | <vertical bar> ::= |
 110 | 
 111 | 5.2  <token> and <separator>
 112 | 
 113 | Function
 114 | 
 115 | Specify lexical units (tokens and separators) that participate in
 116 | SQL language.
 117 | 
 118 | Format
 119 | 
 120 | <token> ::=
 121 |        <nondelimiter token>
 122 |      | <delimiter token>
 123 | 
 124 | <nondelimiter token> ::=
 125 |        <regular identifier>
 126 |      | <key word>
 127 |      | <unsigned numeric literal>
 128 |      | <national character string literal>
 129 |      | <bit string literal>
 130 |      | <hex string literal>
 131 | 
 132 | <regular identifier> ::= <identifier body>
 133 | 
 134 | <identifier body> ::=
 135 |      <identifier start> [ { <underscore> | <identifier part> }... ]
 136 | 
 137 | 
 138 | <identifier start> ::= !! See the Syntax Rules
 139 | 
 140 | <identifier part> ::=
 141 |        <identifier start>
 142 |      | <digit>
 143 | 
 144 | <delimited identifier> ::=
 145 |      <double quote> <delimited identifier body> <double quote>
 146 | 
 147 | <delimited identifier body> ::= <delimited identifier part>...
 148 | 
 149 | <delimited identifier part> ::=
 150 |        <nondoublequote character>
 151 |      | <doublequote symbol>
 152 | 
 153 | <nondoublequote character> ::= !! See the Syntax Rules
 154 | 
 155 | <doublequote symbol> ::= <double quote><double quote>
 156 | 
 157 | <delimiter token> ::=
 158 |        <character string literal>
 159 |      | <date string>
 160 |      | <time string>
 161 |      | <timestamp string>
 162 |      | <interval string>
 163 |      | <delimited identifier>
 164 |      | <SQL special character>
 165 |      | <not equals operator>
 166 |      | <greater than or equals operator>
 167 |      | <less than or equals operator>
 168 |      | <concatenation operator>
 169 |      | <double period>
 170 |      | <left bracket>
 171 |      | <right bracket>
 172 | 
 173 | <not equals operator> ::= <>
 174 | 
 175 | <greater than or equals operator> ::= >=
 176 | 
 177 | <less than or equals operator> ::= <=
 178 | 
 179 | <concatenation operator> ::= ||
 180 | 
 181 | <double period> ::= ..
 182 | 
 183 | <separator> ::= { <comment> | <space> | <newline> }...
 184 | 
 185 | <comment> ::=
 186 |      <comment introducer> [ <comment character>... ] <newline>
 187 | 
 188 | <comment character> ::=
 189 |        <nonquote character>
 190 |      | <quote>
 191 | 
 192 | <comment introducer> ::= <minus sign><minus sign>[<minus sign>...]
 193 | 
 194 | <newline> ::= !! implementation-defined end-of-line indicator
 195 | 
 196 | <key word> ::=
 197 |        <reserved word>
 198 |      | <non-reserved word>
 199 | 
 200 | <non-reserved word> ::=
 201 |        ADA
 202 |      | C | CATALOG_NAME | CHARACTER_SET_CATALOG | CHARACTER_SET_
 203 |      NAME
 204 |      | CHARACTER_SET_SCHEMA | CLASS_ORIGIN | COBOL | COLLATION_
 205 |      CATALOG
 206 |      | COLLATION_NAME | COLLATION_SCHEMA | COLUMN_NAME | COMMAND_
 207 |      FUNCTION | COMMITTED
 208 |      | CONDITION_NUMBER | CONNECTION_NAME | CONSTRAINT_CATALOG | CONSTRAINT_
 209 |      NAME
 210 |      | CONSTRAINT_SCHEMA | CURSOR_NAME
 211 |      | DATA | DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_
 212 |      PRECISION | DYNAMIC_FUNCTION
 213 |      | FORTRAN
 214 |      | LENGTH
 215 |      | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | MORE | MUMPS
 216 | 
 217 |      | NAME | NULLABLE | NUMBER
 218 |      | PASCAL | PLI
 219 |      | REPEATABLE | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_
 220 |      SQLSTATE
 221 |      | ROW_COUNT
 222 |      | SCALE | SCHEMA_NAME | SERIALIZABLE | SERVER_NAME | SUBCLASS_
 223 |      ORIGIN
 224 |      | TABLE_NAME | TYPE
 225 |      | UNCOMMITTED | UNNAMED
 226 | 
 227 | <reserved word> ::=
 228 |        ABSOLUTE | ACTION | ADD | ALL | ALLOCATE | ALTER | AND
 229 |      | ANY | ARE | AS | ASC
 230 |      | ASSERTION | AT | AUTHORIZATION | AVG
 231 |      | BEGIN | BETWEEN | BIT | BIT_LENGTH | BOTH | BY
 232 |      | CASCADE | CASCADED | CASE | CAST | CATALOG | CHAR | CHARACTER | CHAR_
 233 |      LENGTH
 234 |      | CHARACTER_LENGTH | CHECK | CLOSE | COALESCE | COLLATE | COLLATION
 235 | 
 236 |      | COLUMN | COMMIT | CONNECT | CONNECTION | CONSTRAINT
 237 |      | CONSTRAINTS | CONTINUE
 238 |      | CONVERT | CORRESPONDING | COUNT | CREATE | CROSS | CURRENT
 239 |      | CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | CURRENT_
 240 |      USER | CURSOR
 241 |      | DATE | DAY | DEALLOCATE | DEC | DECIMAL | DECLARE | DEFAULT | DEFERRABLE
 242 | 
 243 |      | DEFERRED | DELETE | DESC | DESCRIBE | DESCRIPTOR | DIAGNOSTICS
 244 | 
 245 |      | DISCONNECT | DISTINCT | DOMAIN | DOUBLE | DROP
 246 |      | ELSE | END | END-EXEC | ESCAPE | EXCEPT | EXCEPTION
 247 |      | EXEC | EXECUTE | EXISTS
 248 |      | EXTERNAL | EXTRACT
 249 |      | FALSE | FETCH | FIRST | FLOAT | FOR | FOREIGN | FOUND | FROM | FULL
 250 | 
 251 |      | GET | GLOBAL | GO | GOTO | GRANT | GROUP
 252 |      | HAVING | HOUR
 253 |      | IDENTITY | IMMEDIATE | IN | INDICATOR | INITIALLY | INNER | INPUT
 254 | 
 255 |      | INSENSITIVE | INSERT | INT | INTEGER | INTERSECT | INTERVAL | INTO | IS
 256 | 
 257 |      | ISOLATION
 258 |      | JOIN
 259 |      | KEY
 260 |      | LANGUAGE | LAST | LEADING | LEFT | LEVEL | LIKE | LOCAL | LOWER
 261 | 
 262 |      | MATCH | MAX | MIN | MINUTE | MODULE | MONTH
 263 |      | NAMES | NATIONAL | NATURAL | NCHAR | NEXT | NO | NOT | NULL
 264 | 
 265 |      | NULLIF | NUMERIC
 266 |      | OCTET_LENGTH | OF | ON | ONLY | OPEN | OPTION | OR
 267 |      | ORDER | OUTER
 268 |      | OUTPUT | OVERLAPS
 269 | 
 270 |      | PAD | PARTIAL | POSITION | PRECISION | PREPARE | PRESERVE | PRIMARY
 271 | 
 272 |      | PRIOR | PRIVILEGES | PROCEDURE | PUBLIC
 273 |      | READ | REAL | REFERENCES | RELATIVE | RESTRICT | REVOKE | RIGHT
 274 | 
 275 |      | ROLLBACK | ROWS
 276 |      | SCHEMA | SCROLL | SECOND | SECTION | SELECT | SESSION | SESSION_
 277 |      USER | SET
 278 |      | SIZE | SMALLINT | SOME | SPACE | SQL | SQLCODE | SQLERROR | SQLSTATE
 279 | 
 280 |      | SUBSTRING | SUM | SYSTEM_USER
 281 |      | TABLE | TEMPORARY | THEN | TIME | TIMESTAMP | TIMEZONE_
 282 |      HOUR | TIMEZONE_MINUTE
 283 |      | TO | TRAILING | TRANSACTION | TRANSLATE | TRANSLATION | TRIM | TRUE
 284 | 
 285 |      | UNION | UNIQUE | UNKNOWN | UPDATE | UPPER | USAGE | USER | USING
 286 | 
 287 |      | VALUE | VALUES | VARCHAR | VARYING | VIEW
 288 |      | WHEN | WHENEVER | WHERE | WITH | WORK | WRITE
 289 |      | YEAR
 290 |      | ZONE
 291 | 
 292 | 5.3  <literal>
 293 | 
 294 | Function
 295 | 
 296 | Specify a non-null value.
 297 | 
 298 | Format
 299 | 
 300 | <literal> ::=
 301 |        <signed numeric literal>
 302 |      | <general literal>
 303 | 
 304 | <unsigned literal> ::=
 305 |        <unsigned numeric literal>
 306 |      | <general literal>
 307 | 
 308 | <general literal> ::=
 309 |        <character string literal>
 310 |      | <national character string literal>
 311 |      | <bit string literal>
 312 |      | <hex string literal>
 313 |      | <datetime literal>
 314 |      | <interval literal>
 315 | 
 316 | <character string literal> ::=
 317 |      [ <introducer><character set specification> ]
 318 |      <quote> [ <character representation>... ] <quote>
 319 |        [ { <separator>... <quote> [ <character representation>... ] <quote> }... ]
 320 | 
 321 | 
 322 | <introducer> ::= <underscore>
 323 | 
 324 | <character representation> ::=
 325 |        <nonquote character>
 326 |      | <quote symbol>
 327 | 
 328 | <nonquote character> ::= !! See the Syntax Rules.
 329 | 
 330 | <quote symbol> ::= <quote><quote>
 331 | 
 332 | <national character string literal> ::=
 333 |      N <quote> [ <character representation>... ] <quote>
 334 |        [ { <separator>... <quote> [ <character representation>... ] <quote> }... ]
 335 | 
 336 | 
 337 | <bit string literal> ::=
 338 |      B <quote> [ <bit>... ] <quote>
 339 |        [ { <separator>... <quote> [ <bit>... ] <quote> }... ]
 340 | 
 341 | <hex string literal> ::=
 342 |      X <quote> [ <hexit>... ] <quote>
 343 |        [ { <separator>... <quote> [ <hexit>... ] <quote> }... ]
 344 | 
 345 | <bit> ::= 0 | 1
 346 | 
 347 | <hexit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f
 348 | 
 349 | 
 350 | <signed numeric literal> ::=
 351 |      [ <sign> ] <unsigned numeric literal>
 352 | 
 353 | <unsigned numeric literal> ::=
 354 |        <exact numeric literal>
 355 |      | <approximate numeric literal>
 356 | 
 357 | <exact numeric literal> ::=
 358 |        <unsigned integer> [ <period> [ <unsigned integer> ] ]
 359 |      | <period> <unsigned integer>
 360 | 
 361 | <sign> ::= <plus sign> | <minus sign>
 362 | 
 363 | <approximate numeric literal> ::= <mantissa> E <exponent>
 364 | 
 365 | <mantissa> ::= <exact numeric literal>
 366 | 
 367 | <exponent> ::= <signed integer>
 368 | 
 369 | <signed integer> ::= [ <sign> ] <unsigned integer>
 370 | 
 371 | <unsigned integer> ::= <digit>...
 372 | 
 373 | <datetime literal> ::=
 374 |        <date literal>
 375 |      | <time literal>
 376 |      | <timestamp literal>
 377 | 
 378 | <date literal> ::=
 379 |      DATE <date string>
 380 | 
 381 | <time literal> ::=
 382 |      TIME <time string>
 383 | 
 384 | <timestamp literal> ::=
 385 |      TIMESTAMP <timestamp string>
 386 | 
 387 | <date string> ::=
 388 |      <quote> <date value> <quote>
 389 | 
 390 | <time string> ::=
 391 |      <quote> <time value> [ <time zone interval> ] <quote>
 392 | 
 393 | <timestamp string> ::=
 394 |      <quote> <date value> <space> <time value> [ <time zone interval> ] <quote>
 395 | 
 396 | 
 397 | <time zone interval> ::=
 398 |      <sign> <hours value> <colon> <minutes value>
 399 | 
 400 | <date value> ::=
 401 |      <years value> <minus sign> <months value> <minus sign> <days value>
 402 | 
 403 | 
 404 | <time value> ::=
 405 |      <hours value> <colon> <minutes value> <colon> <seconds value>
 406 | 
 407 | 
 408 | <interval literal> ::=
 409 |      INTERVAL [ <sign> ] <interval string> <interval qualifier>
 410 | 
 411 | <interval string> ::=
 412 |      <quote> { <year-month literal> | <day-time literal> } <quote>
 413 | 
 414 | 
 415 | <year-month literal> ::=
 416 |        <years value>
 417 |      | [ <years value> <minus sign> ] <months value>
 418 | 
 419 | <day-time literal> ::=
 420 |        <day-time interval>
 421 |      | <time interval>
 422 | 
 423 | <day-time interval> ::=
 424 |      <days value>
 425 |        [ <space> <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ] ]
 426 | 
 427 | 
 428 | <time interval> ::=
 429 |        <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]
 430 | 
 431 |      | <minutes value> [ <colon> <seconds value> ]
 432 |      | <seconds value>
 433 | 
 434 | <years value> ::= <datetime value>
 435 | 
 436 | <months value> ::= <datetime value>
 437 | 
 438 | <days value> ::= <datetime value>
 439 | 
 440 | <hours value> ::= <datetime value>
 441 | 
 442 | <minutes value> ::= <datetime value>
 443 | 
 444 | <seconds value> ::=
 445 |        <seconds integer value> [ <period> [ <seconds fraction> ] ]
 446 | 
 447 | 
 448 | <seconds integer value> ::= <unsigned integer>
 449 | 
 450 | <seconds fraction> ::= <unsigned integer>
 451 | 
 452 | <datetime value> ::= <unsigned integer>
 453 | 
 454 | 5.4  Names and identifiers
 455 | 
 456 | Function
 457 | 
 458 | Specify names.
 459 | 
 460 | Format
 461 | 
 462 | <identifier> ::=
 463 |      [ <introducer><character set specification> ] <actual identifier>
 464 | 
 465 | 
 466 | <actual identifier> ::=
 467 |        <regular identifier>
 468 |      | <delimited identifier>
 469 | 
 470 | <SQL language identifier> ::=
 471 |      <SQL language identifier start>
 472 |        [ { <underscore> | <SQL language identifier part> }... ]
 473 | 
 474 | <SQL language identifier start> ::= <simple Latin letter>
 475 | 
 476 | <SQL language identifier part> ::=
 477 |        <simple Latin letter>
 478 |      | <digit>
 479 | 
 480 | <authorization identifier> ::= <identifier>
 481 | 
 482 | <table name> ::=
 483 |        <qualified name>
 484 |      | <qualified local table name>
 485 | 
 486 | <qualified local table name> ::=
 487 |      MODULE <period> <local table name>
 488 | 
 489 | <local table name> ::= <qualified identifier>
 490 | 
 491 | <domain name> ::= <qualified name>
 492 | 
 493 | <schema name> ::=
 494 |      [ <catalog name> <period> ] <unqualified schema name>
 495 | 
 496 | <unqualified schema name> ::= <identifier>
 497 | 
 498 | <catalog name> ::= <identifier>
 499 | 
 500 | <qualified name> ::=
 501 |      [ <schema name> <period> ] <qualified identifier>
 502 | 
 503 | <qualified identifier> ::= <identifier>
 504 | 
 505 | <column name> ::= <identifier>
 506 | 
 507 | <correlation name> ::= <identifier>
 508 | 
 509 | <module name> ::= <identifier>
 510 | 
 511 | <cursor name> ::= <identifier>
 512 | 
 513 | <procedure name> ::= <identifier>
 514 | 
 515 | <SQL statement name> ::=
 516 |        <statement name>
 517 |      | <extended statement name>
 518 | 
 519 | <statement name> ::= <identifier>
 520 | 
 521 | <extended statement name> ::=
 522 |      [ <scope option> ] <simple value specification>
 523 | 
 524 | <dynamic cursor name> ::=
 525 |        <cursor name>
 526 |      | <extended cursor name>
 527 | 
 528 | <extended cursor name> ::=
 529 |      [ <scope option> ] <simple value specification>
 530 | 
 531 | <descriptor name> ::=
 532 |      [ <scope option> ] <simple value specification>
 533 | 
 534 | <scope option> ::=
 535 |        GLOBAL
 536 |      | LOCAL
 537 | 
 538 | <parameter name> ::= <colon> <identifier>
 539 | 
 540 | <constraint name> ::= <qualified name>
 541 | 
 542 | <collation name> ::= <qualified name>
 543 | 
 544 | <character set name> ::= [ <schema name> <period> ] <SQL language identifier>
 545 | 
 546 | 
 547 | <translation name> ::= <qualified name>
 548 | 
 549 | <form-of-use conversion name> ::= <qualified name>
 550 | 
 551 | <connection name> ::= <simple value specification>
 552 | 
 553 | <SQL-server name> ::= <simple value specification>
 554 | 
 555 | <user name> ::= <simple value specification>
 556 | 
 557 | 
 558 | 6  Scalar expressions
 559 | 
 560 | 
 561 | 
 562 | 6.1  <data type>
 563 | 
 564 | Function
 565 | 
 566 | Specify a data type.
 567 | 
 568 | Format
 569 | 
 570 | <data type> ::=
 571 |        <character string type> [ CHARACTER SET <character set specification> ]
 572 | 
 573 |      | <national character string type>
 574 |      | <bit string type>
 575 |      | <numeric type>
 576 |      | <datetime type>
 577 |      | <interval type>
 578 | 
 579 | <character string type> ::=
 580 |        CHARACTER [ <left paren> <length> <right paren> ]
 581 |      | CHAR [ <left paren> <length> <right paren> ]
 582 |      | CHARACTER VARYING <left paren> <length> <right paren>
 583 |      | CHAR VARYING <left paren> <length> <right paren>
 584 |      | VARCHAR <left paren> <length> <right paren>
 585 | 
 586 | <national character string type> ::=
 587 |        NATIONAL CHARACTER [ <left paren> <length> <right paren> ]
 588 |      | NATIONAL CHAR [ <left paren> <length> <right paren> ]
 589 |      | NCHAR [ <left paren> <length> <right paren> ]
 590 |      | NATIONAL CHARACTER VARYING <left paren> <length> <right paren>
 591 | 
 592 |      | NATIONAL CHAR VARYING <left paren> <length> <right paren>
 593 |      | NCHAR VARYING <left paren> <length> <right paren>
 594 | 
 595 | <bit string type> ::=
 596 |        BIT [ <left paren> <length> <right paren> ]
 597 |      | BIT VARYING <left paren> <length> <right paren>
 598 | 
 599 | <numeric type> ::=
 600 |        <exact numeric type>
 601 |      | <approximate numeric type>
 602 | 
 603 | <exact numeric type> ::=
 604 |        NUMERIC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
 605 | 
 606 |      | DECIMAL [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
 607 | 
 608 |      | DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
 609 | 
 610 |      | INTEGER
 611 |      | INT
 612 |      | SMALLINT
 613 | 
 614 | <approximate numeric type> ::=
 615 |        FLOAT [ <left paren> <precision> <right paren> ]
 616 |      | REAL
 617 |      | DOUBLE PRECISION
 618 | 
 619 | <length> ::= <unsigned integer>
 620 | 
 621 | <precision> ::= <unsigned integer>
 622 | 
 623 | <scale> ::= <unsigned integer>
 624 | 
 625 | <datetime type> ::=
 626 |        DATE
 627 |      | TIME [ <left paren> <time precision> <right paren> ]
 628 |      [ WITH TIME ZONE ]
 629 |      | TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
 630 |      [ WITH TIME ZONE ]
 631 | 
 632 | <time precision> ::= <time fractional seconds precision>
 633 | 
 634 | <timestamp precision> ::= <time fractional seconds precision>
 635 | 
 636 | <time fractional seconds precision> ::= <unsigned integer>
 637 | 
 638 | <interval type> ::= INTERVAL <interval qualifier>
 639 | 
 640 | 6.2  <value specification> and <target specification>
 641 | 
 642 | Function
 643 | 
 644 | Specify one or more values, parameters, or variables.
 645 | 
 646 | Format
 647 | 
 648 | <value specification> ::=
 649 |        <literal>
 650 |      | <general value specification>
 651 | 
 652 | <unsigned value specification> ::=
 653 |        <unsigned literal>
 654 |      | <general value specification>
 655 | 
 656 | <general value specification> ::=
 657 |        <parameter specification>
 658 |      | <dynamic parameter specification>
 659 |      | <variable specification>
 660 |      | USER
 661 |      | CURRENT_USER
 662 |      | SESSION_USER
 663 |      | SYSTEM_USER
 664 |      | VALUE
 665 | 
 666 | <simple value specification> ::=
 667 |        <parameter name>
 668 |      | <embedded variable name>
 669 |      | <literal>
 670 | 
 671 | <target specification> ::=
 672 |        <parameter specification>
 673 |      | <variable specification>
 674 | 
 675 | <simple target specification> ::=
 676 |        <parameter name>
 677 |      | <embedded variable name>
 678 | 
 679 | <parameter specification> ::=
 680 |      <parameter name> [ <indicator parameter> ]
 681 | 
 682 | <indicator parameter> ::=
 683 |      [ INDICATOR ] <parameter name>
 684 | 
 685 | <dynamic parameter specification> ::= <question mark>
 686 | 
 687 | <variable specification> ::=
 688 |      <embedded variable name> [ <indicator variable> ]
 689 | 
 690 | <indicator variable> ::=
 691 |      [ INDICATOR ] <embedded variable name>
 692 | 
 693 | 6.3  <table reference>
 694 | 
 695 | Function
 696 | 
 697 | Reference a table.
 698 | 
 699 | Format
 700 | 
 701 | <table reference> ::=
 702 |        <table name> [ [ AS ] <correlation name>
 703 |            [ <left paren> <derived column list> <right paren> ] ]
 704 |      | <derived table> [ AS ] <correlation name>
 705 |            [ <left paren> <derived column list> <right paren> ]
 706 |      | <joined table>
 707 | 
 708 | <derived table> ::= <table subquery>
 709 | 
 710 | <derived column list> ::= <column name list>
 711 | 
 712 | <column name list> ::=
 713 |      <column name> [ { <comma> <column name> }... ]
 714 | 
 715 | 6.4  <column reference>
 716 | 
 717 | Function
 718 | 
 719 | Reference a column.
 720 | 
 721 | Format
 722 | 
 723 | <column reference> ::= [ <qualifier> <period> ] <column name>
 724 | 
 725 | <qualifier> ::=
 726 |        <table name>
 727 |      | <correlation name>
 728 | 
 729 | 6.5  <set function specification>
 730 | 
 731 | Function
 732 | 
 733 | Specify a value derived by the application of a function to an
 734 | argument.
 735 | 
 736 | Format
 737 | 
 738 | <set function specification> ::=
 739 |        COUNT <left paren> <asterisk> <right paren>
 740 |      | <general set function>
 741 | 
 742 | <general set function> ::=
 743 |        <set function type>
 744 |            <left paren> [ <set quantifier> ] <value expression> <right paren>
 745 | 
 746 | 
 747 | <set function type> ::=
 748 |      AVG | MAX | MIN | SUM | COUNT
 749 | 
 750 | <set quantifier> ::= DISTINCT | ALL
 751 | 
 752 | 6.6  <numeric value function>
 753 | 
 754 | Function
 755 | 
 756 | Specify a function yielding a value of type numeric.
 757 | 
 758 | Format
 759 | 
 760 | <numeric value function> ::=
 761 |        <position expression>
 762 |      | <extract expression>
 763 |      | <length expression>
 764 | 
 765 | <position expression> ::=
 766 |      POSITION <left paren> <character value expression>
 767 |          IN <character value expression> <right paren>
 768 | 
 769 | <length expression> ::=
 770 |        <char length expression>
 771 |      | <octet length expression>
 772 |      | <bit length expression>
 773 | 
 774 | <char length expression> ::=
 775 |      { CHAR_LENGTH | CHARACTER_LENGTH }
 776 |          <left paren> <string value expression> <right paren>
 777 | 
 778 | <octet length expression> ::=
 779 |      OCTET_LENGTH <left paren> <string value expression> <right paren>
 780 | 
 781 | 
 782 | <bit length expression> ::=
 783 |      BIT_LENGTH <left paren> <string value expression> <right paren>
 784 | 
 785 | 
 786 | <extract expression> ::=
 787 |      EXTRACT <left paren> <extract field>
 788 |          FROM <extract source> <right paren>
 789 | 
 790 | <extract field> ::=
 791 |        <datetime field>
 792 |      | <time zone field>
 793 | 
 794 | <time zone field> ::=
 795 |        TIMEZONE_HOUR
 796 |      | TIMEZONE_MINUTE
 797 | 
 798 | <extract source> ::=
 799 |        <datetime value expression>
 800 |      | <interval value expression>
 801 | 
 802 | 6.7  <string value function>
 803 | 
 804 | Function
 805 | 
 806 | Specify a function yielding a value of type character string or bit
 807 | string.
 808 | 
 809 | Format
 810 | 
 811 | <string value function> ::=
 812 |        <character value function>
 813 |      | <bit value function>
 814 | 
 815 | <character value function> ::=
 816 |        <character substring function>
 817 |      | <fold>
 818 |      | <form-of-use conversion>
 819 |      | <character translation>
 820 |      | <trim function>
 821 | 
 822 | <character substring function> ::=
 823 |      SUBSTRING <left paren> <character value expression> FROM <start position>
 824 | 
 825 |                  [ FOR <string length> ] <right paren>
 826 | 
 827 | <fold> ::= { UPPER | LOWER } <left paren> <character value expression> <right paren>
 828 | 
 829 | 
 830 | <form-of-use conversion> ::=
 831 |      CONVERT <left paren> <character value expression>
 832 |          USING <form-of-use conversion name> <right paren>
 833 | 
 834 | <character translation> ::=
 835 |      TRANSLATE <left paren> <character value expression>
 836 |          USING <translation name> <right paren>
 837 | 
 838 | <trim function> ::=
 839 |      TRIM <left paren> <trim operands> <right paren>
 840 | 
 841 | <trim operands> ::=
 842 |      [ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>
 843 | 
 844 | 
 845 | <trim source> ::= <character value expression>
 846 | 
 847 | <trim specification> ::=
 848 |        LEADING
 849 |      | TRAILING
 850 |      | BOTH
 851 | 
 852 | <trim character> ::= <character value expression>
 853 | 
 854 | <bit value function> ::=
 855 |      <bit substring function>
 856 | 
 857 | <bit substring function> ::=
 858 |      SUBSTRING <left paren> <bit value expression> FROM <start position>
 859 | 
 860 |          [ FOR <string length> ] <right paren>
 861 | 
 862 | <start position> ::= <numeric value expression>
 863 | 
 864 | <string length> ::= <numeric value expression>
 865 | 
 866 | 6.8  <datetime value function>
 867 | 
 868 | Function
 869 | 
 870 | Specify a function yielding a value of type datetime.
 871 | 
 872 | Format
 873 | 
 874 | <datetime value function> ::=
 875 |        <current date value function>
 876 |      | <current time value function>
 877 |      | <current timestamp value function>
 878 | 
 879 | <current date value function> ::= CURRENT_DATE
 880 | 
 881 | <current time value function> ::=
 882 |        CURRENT_TIME [ <left paren> <time precision> <right paren> ]
 883 | 
 884 | 
 885 | <current timestamp value function> ::=
 886 |        CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
 887 | 
 888 | 6.9  <case expression>
 889 | 
 890 | Function
 891 | 
 892 | Specify a conditional value.
 893 | 
 894 | Format
 895 | 
 896 | <case expression> ::=
 897 |        <case abbreviation>
 898 |      | <case specification>
 899 | 
 900 | <case abbreviation> ::=
 901 |        NULLIF <left paren> <value expression> <comma>
 902 |              <value expression> <right paren>
 903 |      | COALESCE <left paren> <value expression>
 904 |              { <comma> <value expression> }... <right paren>
 905 | 
 906 | <case specification> ::=
 907 |        <simple case>
 908 |      | <searched case>
 909 | 
 910 | <simple case> ::=
 911 |      CASE <case operand>
 912 |        <simple when clause>...
 913 |        [ <else clause> ]
 914 |      END
 915 | 
 916 | <searched case> ::=
 917 |      CASE
 918 |        <searched when clause>...
 919 |        [ <else clause> ]
 920 |      END
 921 | 
 922 | <simple when clause> ::= WHEN <when operand> THEN <result>
 923 | 
 924 | <searched when clause> ::= WHEN <search condition> THEN <result>
 925 | 
 926 | <else clause> ::= ELSE <result>
 927 | 
 928 | <case operand> ::= <value expression>
 929 | 
 930 | <when operand> ::= <value expression>
 931 | 
 932 | <result> ::= <result expression> | NULL
 933 | 
 934 | <result expression> ::= <value expression>
 935 | 
 936 | 6.10  <cast specification>
 937 | 
 938 | Function
 939 | 
 940 | Specify a data conversion.
 941 | 
 942 | Format
 943 | 
 944 | <cast specification> ::=
 945 |      CAST <left paren> <cast operand> AS <cast target> <right paren>
 946 | 
 947 | 
 948 | <cast operand> ::=
 949 |        <value expression>
 950 |      | NULL
 951 | 
 952 | <cast target> ::=
 953 |        <domain name>
 954 |      | <data type>
 955 | 
 956 | 
 957 | 6.11  <value expression>
 958 | 
 959 | Function
 960 | 
 961 | Specify a value.
 962 | 
 963 | Format
 964 | 
 965 | <value expression> ::=
 966 |        <numeric value expression>
 967 |      | <string value expression>
 968 |      | <datetime value expression>
 969 |      | <interval value expression>
 970 | 
 971 | <value expression primary> ::=
 972 |        <unsigned value specification>
 973 |      | <column reference>
 974 |      | <set function specification>
 975 |      | <scalar subquery>
 976 |      | <case expression>
 977 |      | <left paren> <value expression> <right paren>
 978 |      | <cast specification>
 979 | 
 980 | 
 981 | 6.12  <numeric value expression>
 982 | 
 983 | Function
 984 | 
 985 | Specify a numeric value.
 986 | 
 987 | Format
 988 | 
 989 | <numeric value expression> ::=
 990 |        <term>
 991 |      | <numeric value expression> <plus sign> <term>
 992 |      | <numeric value expression> <minus sign> <term>
 993 | 
 994 | <term> ::=
 995 |        <factor>
 996 |      | <term> <asterisk> <factor>
 997 |      | <term> <solidus> <factor>
 998 | 
 999 | <factor> ::=
1000 |      [ <sign> ] <numeric primary>
1001 | 
1002 | <numeric primary> ::=
1003 |        <value expression primary>
1004 |      | <numeric value function>
1005 | 
1006 | 
1007 | 6.13  <string value expression>
1008 | 
1009 | Function
1010 | 
1011 | Specify a character string value or a bit string value.
1012 | 
1013 | Format
1014 | 
1015 | <string value expression> ::=
1016 |        <character value expression>
1017 |      | <bit value expression>
1018 | 
1019 | <character value expression> ::=
1020 |        <concatenation>
1021 |      | <character factor>
1022 | 
1023 | <concatenation> ::=
1024 |      <character value expression> <concatenation operator>
1025 |      <character factor>
1026 | 
1027 | <character factor> ::=
1028 |      <character primary> [ <collate clause> ]
1029 | 
1030 | <character primary> ::=
1031 |        <value expression primary>
1032 |      | <string value function>
1033 | 
1034 | <bit value expression> ::=
1035 |        <bit concatenation>
1036 |      | <bit factor>
1037 | 
1038 | <bit concatenation> ::=
1039 |      <bit value expression> <concatenation operator> <bit factor>
1040 | 
1041 | <bit factor> ::= <bit primary>
1042 | 
1043 | <bit primary> ::=
1044 |        <value expression primary>
1045 |      | <string value function>
1046 | 
1047 | 
1048 | 6.14  <datetime value expression>
1049 | 
1050 | Function
1051 | 
1052 | Specify a datetime value.
1053 | 
1054 | Format
1055 | 
1056 | <datetime value expression> ::=
1057 |        <datetime term>
1058 |      | <interval value expression> <plus sign> <datetime term>
1059 |      | <datetime value expression> <plus sign> <interval term>
1060 |      | <datetime value expression> <minus sign> <interval term>
1061 | 
1062 | <datetime term> ::=
1063 |        <datetime factor>
1064 | 
1065 | <datetime factor> ::=
1066 |        <datetime primary> [ <time zone> ]
1067 | 
1068 | <datetime primary> ::=
1069 |        <value expression primary>
1070 |      | <datetime value function>
1071 | 
1072 | <time zone> ::=
1073 |      AT <time zone specifier>
1074 | 
1075 | <time zone specifier> ::=
1076 |        LOCAL
1077 |      | TIME ZONE <interval value expression>
1078 | 
1079 | 
1080 | 6.15  <interval value expression>
1081 | 
1082 | Function
1083 | 
1084 | Specify an interval value.
1085 | 
1086 | Format
1087 | 
1088 | <interval value expression> ::=
1089 |        <interval term>
1090 |      | <interval value expression 1> <plus sign> <interval term 1>
1091 | 
1092 |      | <interval value expression 1> <minus sign> <interval term 1>
1093 | 
1094 |      | <left paren> <datetime value expression> <minus sign>
1095 |            <datetime term> <right paren> <interval qualifier>
1096 | 
1097 | <interval term> ::=
1098 |        <interval factor>
1099 |      | <interval term 2> <asterisk> <factor>
1100 |      | <interval term 2> <solidus> <factor>
1101 |      | <term> <asterisk> <interval factor>
1102 | 
1103 | <interval factor> ::=
1104 |      [ <sign> ] <interval primary>
1105 | 
1106 | <interval primary> ::=
1107 |        <value expression primary> [ <interval qualifier> ]
1108 | 
1109 | <interval value expression 1> ::= <interval value expression>
1110 | 
1111 | <interval term 1> ::= <interval term>
1112 | 
1113 | <interval term 2> ::= <interval term>
1114 | 
1115 | 
1116 | 7  Query expressions
1117 | 
1118 | 
1119 | 
1120 | 7.1  <row value constructor>
1121 | 
1122 | Function
1123 | 
1124 | Specify an ordered set of values to be constructed into a row or
1125 | partial row.
1126 | 
1127 | Format
1128 | 
1129 | <row value constructor> ::=
1130 |        <row value constructor element>
1131 |      | <left paren> <row value constructor list> <right paren>
1132 |      | <row subquery>
1133 | 
1134 | <row value constructor list> ::=
1135 |      <row value constructor element>
1136 |          [ { <comma> <row value constructor element> }... ]
1137 | 
1138 | <row value constructor element> ::=
1139 |        <value expression>
1140 |      | <null specification>
1141 |      | <default specification>
1142 | 
1143 | <null specification> ::=
1144 |      NULL
1145 | 
1146 | <default specification> ::=
1147 |      DEFAULT
1148 | 
1149 | 
1150 | 7.2  <table value constructor>
1151 | 
1152 | Function
1153 | 
1154 | Specify a set of <row value constructor>s to be constructed into a
1155 | table.
1156 | 
1157 | Format
1158 | 
1159 | <table value constructor> ::=
1160 |      VALUES <table value constructor list>
1161 | 
1162 | <table value constructor list> ::=
1163 |      <row value constructor> [ { <comma> <row value constructor> }... ]
1164 | 
1165 | 
1166 | 7.3  <table expression>
1167 | 
1168 | Function
1169 | 
1170 | Specify a table or a grouped table.
1171 | 
1172 | Format
1173 | 
1174 | <table expression> ::=
1175 |      <from clause>
1176 |      [ <where clause> ]
1177 |      [ <group by clause> ]
1178 |      [ <having clause> ]
1179 | 
1180 | 
1181 | 7.4  <from clause>
1182 | 
1183 | Function
1184 | 
1185 | Specify a table derived from one or more named tables.
1186 | 
1187 | Format
1188 | 
1189 | <from clause> ::= FROM <table reference> [ { <comma> <table reference> }... ]
1190 | 
1191 | 
1192 | 7.5  <joined table>
1193 | 
1194 | Function
1195 | 
1196 | Specify a table derived from a Cartesian product, inner or outer
1197 | join, or union join.
1198 | 
1199 | Format
1200 | 
1201 | <joined table> ::=
1202 |        <cross join>
1203 |      | <qualified join>
1204 |      | <left paren> <joined table> <right paren>
1205 | 
1206 | <cross join> ::=
1207 |      <table reference> CROSS JOIN <table reference>
1208 | 
1209 | <qualified join> ::=
1210 |      <table reference> [ NATURAL ] [ <join type> ] JOIN
1211 |        <table reference> [ <join specification> ]
1212 | 
1213 | <join specification> ::=
1214 |        <join condition>
1215 |      | <named columns join>
1216 | 
1217 | <join condition> ::= ON <search condition>
1218 | 
1219 | <named columns join> ::=
1220 |      USING <left paren> <join column list> <right paren>
1221 | 
1222 | <join type> ::=
1223 |        INNER
1224 |      | <outer join type> [ OUTER ]
1225 |      | UNION
1226 | 
1227 | <outer join type> ::=
1228 |        LEFT
1229 |      | RIGHT
1230 |      | FULL
1231 | 
1232 | <join column list> ::= <column name list>
1233 | 
1234 | 
1235 | 7.6  <where clause>
1236 | 
1237 | Function
1238 | 
1239 | Specify a table derived by the application of a <search condition>
1240 | to the result of the preceding <from clause>.
1241 | 
1242 | Format
1243 | 
1244 | <where clause> ::= WHERE <search condition>
1245 | 
1246 | 
1247 | 7.7  <group by clause>
1248 | 
1249 | Function
1250 | 
1251 | Specify a grouped table derived by the application of the <group by
1252 | clause> to the result of the previously specified clause.
1253 | 
1254 | Format
1255 | 
1256 | <group by clause> ::=
1257 |      GROUP BY <grouping column reference list>
1258 | 
1259 | <grouping column reference list> ::=
1260 |      <grouping column reference> [ { <comma> <grouping column reference> }... ]
1261 | 
1262 | 
1263 | <grouping column reference> ::=
1264 |      <column reference> [ <collate clause> ]
1265 | 
1266 | 
1267 | 7.8  <having clause>
1268 | 
1269 | Function
1270 | 
1271 | Specify a grouped table derived by the elimination of groups from
1272 | the result of the previously specified clause that do not meet the
1273 | <search condition>.
1274 | 
1275 | Format
1276 | 
1277 | <having clause> ::= HAVING <search condition>
1278 | 
1279 | 
1280 | 7.9  <query specification>
1281 | 
1282 | Function
1283 | 
1284 | Specify a table derived from the result of a <table expression>.
1285 | 
1286 | Format
1287 | 
1288 | <query specification> ::=
1289 |      SELECT [ <set quantifier> ] <select list> <table expression>
1290 | 
1291 | <select list> ::=
1292 |        <asterisk>
1293 |      | <select sublist> [ { <comma> <select sublist> }... ]
1294 | 
1295 | <select sublist> ::=
1296 |        <derived column>
1297 |      | <qualifier> <period> <asterisk>
1298 | 
1299 | <derived column> ::= <value expression> [ <as clause> ]
1300 | 
1301 | <as clause> ::= [ AS ] <column name>
1302 | 
1303 | 
1304 | 7.10  <query expression>
1305 | 
1306 | Function
1307 | 
1308 | Specify a table.
1309 | 
1310 | Format
1311 | 
1312 | <query expression> ::=
1313 |        <non-join query expression>
1314 |      | <joined table>
1315 | 
1316 | <non-join query expression> ::=
1317 |        <non-join query term>
1318 |      | <query expression> UNION  [ ALL ] [ <corresponding spec> ] <query term>
1319 | 
1320 |      | <query expression> EXCEPT [ ALL ] [ <corresponding spec> ] <query term>
1321 | 
1322 | 
1323 | <query term> ::=
1324 |        <non-join query term>
1325 |      | <joined table>
1326 | 
1327 | <non-join query term> ::=
1328 |        <non-join query primary>
1329 |      | <query term> INTERSECT [ ALL ] [ <corresponding spec> ] <query primary>
1330 | 
1331 | 
1332 | <query primary> ::=
1333 |        <non-join query primary>
1334 |      | <joined table>
1335 | 
1336 | <non-join query primary> ::=
1337 |        <simple table>
1338 |      | <left paren> <non-join query expression> <right paren>
1339 | 
1340 | <simple table> ::=
1341 |        <query specification>
1342 |      | <table value constructor>
1343 |      | <explicit table>
1344 | 
1345 | <explicit table> ::= TABLE <table name>
1346 | 
1347 | <corresponding spec> ::=
1348 |      CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]
1349 | 
1350 | 
1351 | <corresponding column list> ::= <column name list>
1352 | 
1353 | 
1354 | 7.11  <scalar subquery>, <row subquery>, and <table subquery>
1355 | 
1356 | Function
1357 | 
1358 | Specify a scalar value, a row, or a table derived from a <query
1359 | expression>.
1360 | 
1361 | Format
1362 | 
1363 | <scalar subquery> ::= <subquery>
1364 | 
1365 | <row subquery> ::= <subquery>
1366 | 
1367 | <table subquery> ::= <subquery>
1368 | 
1369 | <subquery> ::= <left paren> <query expression> <right paren>
1370 | 
1371 | 
1372 | 8  Predicates
1373 | 
1374 | 
1375 | 
1376 | 8.1  <predicate>
1377 | 
1378 | Function
1379 | 
1380 | Specify a condition that can be evaluated to give a truth value of
1381 | true, false, or unknown.
1382 | 
1383 | Format
1384 | 
1385 | <predicate> ::=
1386 |        <comparison predicate>
1387 |      | <between predicate>
1388 |      | <in predicate>
1389 |      | <like predicate>
1390 |      | <null predicate>
1391 |      | <quantified comparison predicate>
1392 |      | <exists predicate>
1393 |      | <unique predicate>
1394 |      | <match predicate>
1395 |      | <overlaps predicate>
1396 | 
1397 | 
1398 | 8.2  <comparison predicate>
1399 | 
1400 | Function
1401 | 
1402 | Specify a comparison of two row values.
1403 | 
1404 | Format
1405 | 
1406 | <comparison predicate> ::=
1407 |      <row value constructor> <comp op> <row value constructor>
1408 | 
1409 | <comp op> ::=
1410 |        <equals operator>
1411 |      | <not equals operator>
1412 |      | <less than operator>
1413 |      | <greater than operator>
1414 |      | <less than or equals operator>
1415 |      | <greater than or equals operator>
1416 | 
1417 | 
1418 | 8.3  <between predicate>
1419 | 
1420 | Function
1421 | 
1422 | Specify a range comparison.
1423 | 
1424 | Format
1425 | 
1426 | <between predicate> ::=
1427 |      <row value constructor> [ NOT ] BETWEEN
1428 |        <row value constructor> AND <row value constructor>
1429 | 
1430 | 
1431 | 8.4  <in predicate>
1432 | 
1433 | Function
1434 | 
1435 | Specify a quantified comparison.
1436 | 
1437 | Format
1438 | 
1439 | <in predicate> ::=
1440 |      <row value constructor>
1441 |        [ NOT ] IN <in predicate value>
1442 | 
1443 | <in predicate value> ::=
1444 |        <table subquery>
1445 |      | <left paren> <in value list> <right paren>
1446 | 
1447 | <in value list> ::=
1448 |      <value expression> { <comma> <value expression> }...
1449 | 
1450 | 
1451 | 8.5  <like predicate>
1452 | 
1453 | Function
1454 | 
1455 | Specify a pattern-match comparison.
1456 | 
1457 | Format
1458 | 
1459 | <like predicate> ::=
1460 |      <match value> [ NOT ] LIKE <pattern>
1461 |        [ ESCAPE <escape character> ]
1462 | 
1463 | <match value> ::= <character value expression>
1464 | 
1465 | <pattern> ::= <character value expression>
1466 | 
1467 | <escape character> ::= <character value expression>
1468 | 
1469 | 
1470 | 8.6  <null predicate>
1471 | 
1472 | Function
1473 | 
1474 | Specify a test for a null value.
1475 | 
1476 | Format
1477 | 
1478 | <null predicate> ::= <row value constructor> IS [ NOT ] NULL
1479 | 
1480 | 
1481 | 8.7  <quantified comparison predicate>
1482 | 
1483 | Function
1484 | 
1485 | Specify a quantified comparison.
1486 | 
1487 | Format
1488 | 
1489 | <quantified comparison predicate> ::=
1490 |      <row value constructor> <comp op> <quantifier> <table subquery>
1491 | 
1492 | 
1493 | <quantifier> ::= <all> | <some>
1494 | 
1495 | <all> ::= ALL
1496 | 
1497 | <some> ::= SOME | ANY
1498 | 
1499 | 
1500 | 8.8  <exists predicate>
1501 | 
1502 | Function
1503 | 
1504 | Specify a test for a non-empty set.
1505 | 
1506 | Format
1507 | 
1508 | <exists predicate> ::= EXISTS <table subquery>
1509 | 
1510 | 
1511 | 8.9  <unique predicate>
1512 | 
1513 | Function
1514 | 
1515 | Specify a test for the absence of duplicate rows.
1516 | 
1517 | Format
1518 | 
1519 | <unique predicate> ::= UNIQUE <table subquery>
1520 | 
1521 | 
1522 | 8.10  <match predicate>
1523 | 
1524 | Function
1525 | 
1526 | Specify a test for matching rows.
1527 | 
1528 | Format
1529 | 
1530 | <match predicate> ::=
1531 |      <row value constructor> MATCH [ UNIQUE ] [ PARTIAL | FULL ] <table subquery>
1532 | 
1533 | 
1534 | 8.11  <overlaps predicate>
1535 | 
1536 | Function
1537 | 
1538 | Specify a test for an overlap between two events.
1539 | 
1540 | Format
1541 | 
1542 | <overlaps predicate> ::=
1543 |      <row value constructor 1> OVERLAPS <row value constructor 2>
1544 | 
1545 | <row value constructor 1> ::= <row value constructor>
1546 | 
1547 | <row value constructor 2> ::= <row value constructor>
1548 | 
1549 | 
1550 | 8.12  <search condition>
1551 | 
1552 | Function
1553 | 
1554 | Specify a condition that has the truth value true, false, or
1555 | unknown, depending on the result of applying boolean operators
1556 | to specified conditions.
1557 | 
1558 | Format
1559 | 
1560 | <search condition> ::=
1561 |        <boolean term>
1562 |      | <search condition> OR <boolean term>
1563 | 
1564 | <boolean term> ::=
1565 |        <boolean factor>
1566 |      | <boolean term> AND <boolean factor>
1567 | 
1568 | <boolean factor> ::=
1569 |      [ NOT ] <boolean test>
1570 | 
1571 | <boolean test> ::=
1572 |      <boolean primary> [ IS [ NOT ] <truth value> ]
1573 | 
1574 | <truth value> ::=
1575 |        TRUE
1576 |      | FALSE
1577 |      | UNKNOWN
1578 | 
1579 | <boolean primary> ::=
1580 |        <predicate>
1581 |      | <left paren> <search condition> <right paren>
1582 | 
1583 | 
1584 | 10  Additional common elements
1585 | 
1586 | 
1587 | 
1588 | 10.1  <interval qualifier>
1589 | 
1590 | Function
1591 | 
1592 | Specify the precision of an interval data type.
1593 | 
1594 | Format
1595 | 
1596 | <interval qualifier> ::=
1597 |        <start field> TO <end field>
1598 |      | <single datetime field>
1599 | 
1600 | <start field> ::=
1601 |      <non-second datetime field>
1602 |          [ <left paren> <interval leading field precision> <right paren> ]
1603 | 
1604 | 
1605 | <end field> ::=
1606 |        <non-second datetime field>
1607 |      | SECOND [ <left paren> <interval fractional seconds precision> <right paren> ]
1608 | 
1609 | 
1610 | <single datetime field> ::=
1611 |        <non-second datetime field>
1612 |            [ <left paren> <interval leading field precision> <right paren> ]
1613 | 
1614 |      | SECOND [ <left paren> <interval leading field precision>
1615 |            [ <comma> <interval fractional seconds precision> ] <right paren> ]
1616 | 
1617 | 
1618 | <datetime field> ::=
1619 |        <non-second datetime field>
1620 |      | SECOND
1621 | 
1622 | <non-second datetime field> ::= YEAR | MONTH | DAY | HOUR | MINUTE
1623 | 
1624 | <interval fractional seconds precision> ::= <unsigned integer>
1625 | 
1626 | <interval leading field precision> ::= <unsigned integer>
1627 | 
1628 | 10.2  <language clause>
1629 | 
1630 | Function
1631 | 
1632 | Specify a standard programming language.
1633 | 
1634 | Format
1635 | 
1636 | <language clause> ::=
1637 |      LANGUAGE <language name>
1638 | 
1639 | <language name> ::=
1640 |      ADA | C | COBOL | FORTRAN | MUMPS | PASCAL | PLI
1641 | 
1642 | 
1643 | 10.3  <privileges>
1644 | 
1645 | Function
1646 | 
1647 | Specify privileges.
1648 | 
1649 | Format
1650 | 
1651 | <privileges> ::=
1652 |        ALL PRIVILEGES
1653 |      | <action list>
1654 | 
1655 | <action list> ::= <action> [ { <comma> <action> }... ]
1656 | 
1657 | 
1658 | <action> ::=
1659 |        SELECT
1660 |      | DELETE
1661 |      | INSERT [ <left paren> <privilege column list> <right paren> ]
1662 | 
1663 |      | UPDATE [ <left paren> <privilege column list> <right paren> ]
1664 | 
1665 |      | REFERENCES [ <left paren> <privilege column list> <right paren> ]
1666 | 
1667 |      | USAGE
1668 | 
1669 | <privilege column list> ::= <column name list>
1670 | 
1671 | <grantee> ::=
1672 |        PUBLIC
1673 |      | <authorization identifier>
1674 | 
1675 | 
1676 | 10.4  <character set specification>
1677 | 
1678 | Function
1679 | 
1680 | Identify a character set.
1681 | 
1682 | Format
1683 | 
1684 | <character set specification> ::=
1685 |        <standard character repertoire name>
1686 |      | <implementation-defined character repertoire name>
1687 |      | <user-defined character repertoire name>
1688 |      | <standard universal character form-of-use name>
1689 |      | <implementation-defined universal character form-of-
1690 |      use name>
1691 | 
1692 | <standard character repertoire name> ::= <character set name>
1693 | 
1694 | <implementation-defined character repertoire name> ::= <character set name>
1695 | 
1696 | 
1697 | <user-defined character repertoire name> ::= <character set name>
1698 | 
1699 | <standard universal character form-of-use name> ::=
1700 |      <character set name>
1701 | 
1702 | <implementation-defined universal character form-of-use name> ::=
1703 |      <character set name>
1704 | 
1705 | 
1706 | 10.5  <collate clause>
1707 | 
1708 | Function
1709 | 
1710 | Specify a collating sequence.
1711 | 
1712 | Format
1713 | 
1714 | <collate clause> ::= COLLATE <collation name>
1715 | 
1716 | 
1717 | 10.6  <constraint name definition> and <constraint attributes>
1718 | 
1719 | Function
1720 | 
1721 | Specify the name of a constraint and its attributes.
1722 | 
1723 | Format
1724 | 
1725 | <constraint name definition> ::= CONSTRAINT <constraint name>
1726 | 
1727 | <constraint attributes> ::=
1728 |        <constraint check time> [ [ NOT ] DEFERRABLE ]
1729 |      | [ NOT ] DEFERRABLE [ <constraint check time> ]
1730 | 
1731 | <constraint check time> ::=   INITIALLY DEFERRED
1732 |      | INITIALLY IMMEDIATE
1733 | 
1734 | 
1735 | 11  Schema definition and manipulation
1736 | 
1737 | 
1738 | 
1739 | 11.1  <schema definition>
1740 | 
1741 | Function
1742 | 
1743 | Define a schema.
1744 | 
1745 | Format
1746 | 
1747 | <schema definition> ::=
1748 |      CREATE SCHEMA <schema name clause>
1749 |        [ <schema character set specification> ]
1750 |        [ <schema element>... ]
1751 | 
1752 | 
1753 | 
1754 | <schema name clause> ::=
1755 |        <schema name>
1756 |      | AUTHORIZATION <schema authorization identifier>
1757 |      | <schema name> AUTHORIZATION <schema authorization identifier>
1758 | 
1759 | 
1760 | <schema authorization identifier> ::=
1761 |      <authorization identifier>
1762 | 
1763 | <schema character set specification> ::=
1764 |      DEFAULT CHARACTER SET <character set specification>
1765 | 
1766 | <schema element> ::=
1767 |        <domain definition>
1768 |      | <table definition>
1769 |      | <view definition>
1770 |      | <grant statement>
1771 |      | <assertion definition>
1772 |      | <character set definition>
1773 |      | <collation definition>
1774 |      | <translation definition>
1775 | 
1776 | 
1777 | 11.2  <drop schema statement>
1778 | 
1779 | Function
1780 | 
1781 | Destroy a schema.
1782 | 
1783 | Format
1784 | 
1785 | <drop schema statement> ::=
1786 |      DROP SCHEMA <schema name> <drop behavior>
1787 | 
1788 | <drop behavior> ::= CASCADE | RESTRICT
1789 | 
1790 | 
1791 | 11.3  <table definition>
1792 | 
1793 | Function
1794 | 
1795 | Define a persistent base table, a created local temporary table, or
1796 | a global temporary table.
1797 | 
1798 | Format
1799 | 
1800 | <table definition> ::=
1801 |      CREATE [ { GLOBAL | LOCAL } TEMPORARY ] TABLE <table name>
1802 |        <table element list>
1803 |        [ ON COMMIT { DELETE | PRESERVE } ROWS ]
1804 | 
1805 | <table element list> ::=
1806 |        <left paren> <table element> [ { <comma> <table element> }... ] <right paren>
1807 | 
1808 | 
1809 | <table element> ::=
1810 |        <column definition>
1811 |      | <table constraint definition>
1812 | 
1813 | 
1814 | 11.4  <column definition>
1815 | 
1816 | Function
1817 | 
1818 | Define a column of a table.
1819 | 
1820 | Format
1821 | 
1822 | <column definition> ::=
1823 |      <column name> { <data type> | <domain name> }
1824 |      [ <default clause> ]
1825 |      [ <column constraint definition>... ]
1826 |      [ <collate clause> ]
1827 | 
1828 | <column constraint definition> ::=
1829 |      [ <constraint name definition> ]
1830 |      <column constraint>
1831 |        [ <constraint attributes> ]
1832 | 
1833 | <column constraint> ::=
1834 |        NOT NULL
1835 |      | <unique specification>
1836 |      | <references specification>
1837 |      | <check constraint definition>
1838 | 
1839 | 
1840 | 11.5  <default clause>
1841 | 
1842 | Function
1843 | 
1844 | Specify the default for a column or domain.
1845 | 
1846 | Format
1847 | 
1848 | <default clause> ::=
1849 |        DEFAULT <default option>
1850 | 
1851 | <default option> ::=
1852 |        <literal>
1853 |      | <datetime value function>
1854 |      | USER
1855 |      | CURRENT_USER
1856 |      | SESSION_USER
1857 |      | SYSTEM_USER
1858 |      | NULL
1859 | 
1860 | 
1861 | 11.6  <table constraint definition>
1862 | 
1863 | Function
1864 | 
1865 | Specify an integrity constraint.
1866 | 
1867 | Format
1868 | 
1869 | <table constraint definition> ::=
1870 |      [ <constraint name definition> ]
1871 |      <table constraint> [ <constraint attributes> ]
1872 | 
1873 | <table constraint> ::=
1874 |        <unique constraint definition>
1875 |      | <referential constraint definition>
1876 |      | <check constraint definition>
1877 | 
1878 | 
1879 | 11.7  <unique constraint definition>
1880 | 
1881 | Function
1882 | 
1883 | Specify a uniqueness constraint for a table.
1884 | 
1885 | Format
1886 | 
1887 | <unique constraint definition> ::=
1888 |      <unique specification>
1889 |        <left paren> <unique column list> <right paren>
1890 | 
1891 | <unique specification> ::=
1892 |      UNIQUE | PRIMARY KEY
1893 | 
1894 | <unique column list> ::= <column name list>
1895 | 
1896 | 
1897 | 11.8  <referential constraint definition>
1898 | 
1899 | Function
1900 | 
1901 | Specify a referential constraint.
1902 | 
1903 | Format
1904 | 
1905 | <referential constraint definition> ::=
1906 |      FOREIGN KEY <left paren> <referencing columns> <right paren>
1907 |        <references specification>
1908 | 
1909 | <references specification> ::=
1910 |      REFERENCES <referenced table and columns>
1911 |        [ MATCH <match type> ]
1912 |        [ <referential triggered action> ]
1913 | 
1914 | <match type> ::=
1915 |        FULL
1916 |      | PARTIAL
1917 | 
1918 | <referencing columns> ::=
1919 |      <reference column list>
1920 | 
1921 | <referenced table and columns> ::=
1922 |      <table name> [ <left paren> <reference column list> <right paren> ]
1923 | 
1924 | 
1925 | <reference column list> ::= <column name list>
1926 | 
1927 | <referential triggered action> ::=
1928 |        <update rule> [ <delete rule> ]
1929 |      | <delete rule> [ <update rule> ]
1930 | 
1931 | <update rule> ::= ON UPDATE <referential action>
1932 | 
1933 | <delete rule> ::= ON DELETE <referential action>
1934 | 
1935 | <referential action> ::=
1936 |        CASCADE
1937 |      | SET NULL
1938 |      | SET DEFAULT
1939 |      | NO ACTION
1940 | 
1941 | 
1942 | 11.9  <check constraint definition>
1943 | 
1944 | Function
1945 | 
1946 | Specify a condition for the SQL-data.
1947 | 
1948 | Format
1949 | 
1950 | <check constraint definition> ::=
1951 |      CHECK <left paren> <search condition> <right paren>
1952 | 
1953 | 
1954 | 11.10  <alter table statement>
1955 | 
1956 | Function
1957 | 
1958 | Change the definition of a table.
1959 | 
1960 | Format
1961 | 
1962 | <alter table statement> ::=
1963 |      ALTER TABLE <table name> <alter table action>
1964 | 
1965 | <alter table action> ::=
1966 |        <add column definition>
1967 |      | <alter column definition>
1968 |      | <drop column definition>
1969 |      | <add table constraint definition>
1970 |      | <drop table constraint definition>
1971 | 
1972 | 
1973 | 11.11  <add column definition>
1974 | 
1975 | Function
1976 | 
1977 | Add a column to a table.
1978 | 
1979 | Format
1980 | 
1981 | <add column definition> ::=
1982 |      ADD [ COLUMN ] <column definition>
1983 | 
1984 | 
1985 | 11.12  <alter column definition>
1986 | 
1987 | Function
1988 | 
1989 | Change a column and its definition.
1990 | 
1991 | Format
1992 | 
1993 | <alter column definition> ::=
1994 |      ALTER [ COLUMN ] <column name> <alter column action>
1995 | 
1996 | <alter column action> ::=
1997 |        <set column default clause>
1998 |      | <drop column default clause>
1999 | 
2000 | 
2001 | 11.13  <set column default clause>
2002 | 
2003 | Function
2004 | 
2005 | Set the default clause for a column.
2006 | 
2007 | Format
2008 | 
2009 | <set column default clause> ::=
2010 |      SET <default clause>
2011 | 
2012 | 
2013 | 11.14  <drop column default clause>
2014 | 
2015 | Function
2016 | 
2017 | Drop the default clause from a column.
2018 | 
2019 | Format
2020 | 
2021 | <drop column default clause> ::=
2022 |      DROP DEFAULT
2023 | 
2024 | 
2025 | 11.15  <drop column definition>
2026 | 
2027 | Function
2028 | 
2029 | Destroy a column.
2030 | 
2031 | Format
2032 | 
2033 | <drop column definition> ::=
2034 |      DROP [ COLUMN ] <column name> <drop behavior>
2035 | 
2036 | 
2037 | 11.16  <add table constraint definition>
2038 | 
2039 | Function
2040 | 
2041 | Add a constraint to a table.
2042 | 
2043 | Format
2044 | 
2045 | <add table constraint definition> ::=
2046 |      ADD <table constraint definition>
2047 | 
2048 | 
2049 | 11.17  <drop table constraint definition>
2050 | 
2051 | Function
2052 | 
2053 | Destroy a constraint on a table.
2054 | 
2055 | Format
2056 | 
2057 | <drop table constraint definition> ::=
2058 |      DROP CONSTRAINT <constraint name> <drop behavior>
2059 | 
2060 | 
2061 | 11.18  <drop table statement>
2062 | 
2063 | Function
2064 | 
2065 | Destroy a table.
2066 | 
2067 | Format
2068 | 
2069 | <drop table statement> ::=
2070 |      DROP TABLE <table name> <drop behavior>
2071 | 
2072 | 
2073 | 11.19  <view definition>
2074 | 
2075 | Function
2076 | 
2077 | Define a viewed table.
2078 | 
2079 | Format
2080 | 
2081 | <view definition> ::=
2082 |      CREATE VIEW <table name> [ <left paren> <view column list>
2083 |      <right paren> ]
2084 |        AS <query expression>
2085 |        [ WITH [ <levels clause> ] CHECK OPTION ]
2086 | 
2087 | <levels clause> ::=
2088 |      CASCADED | LOCAL
2089 | 
2090 | <view column list> ::= <column name list>
2091 | 
2092 | 
2093 | 11.20  <drop view statement>
2094 | 
2095 | Function
2096 | 
2097 | Destroy a view.
2098 | 
2099 | Format
2100 | 
2101 | <drop view statement> ::=
2102 |      DROP VIEW <table name> <drop behavior>
2103 | 
2104 | 
2105 | 11.21  <domain definition>
2106 | 
2107 | Function
2108 | 
2109 | Define a domain.
2110 | 
2111 | Format
2112 | 
2113 | <domain definition> ::=
2114 |      CREATE DOMAIN <domain name> [ AS ] <data type>
2115 |        [ <default clause> ]
2116 |        [ <domain constraint>... ]
2117 |        [ <collate clause> ]
2118 | 
2119 | <domain constraint> ::=
2120 |      [ <constraint name definition> ]
2121 |      <check constraint definition> [ <constraint attributes> ]
2122 | 
2123 | 
2124 | 11.22  <alter domain statement>
2125 | 
2126 | Function
2127 | 
2128 | Change a domain and its definition.
2129 | 
2130 | Format
2131 | 
2132 | <alter domain statement> ::=
2133 |      ALTER DOMAIN <domain name> <alter domain action>
2134 | 
2135 | <alter domain action> ::=
2136 |        <set domain default clause>
2137 |      | <drop domain default clause>
2138 |      | <add domain constraint definition>
2139 |      | <drop domain constraint definition>
2140 | 
2141 | 
2142 | 11.23  <set domain default clause>
2143 | 
2144 | Function
2145 | 
2146 | Set the default value in a domain.
2147 | 
2148 | Format
2149 | 
2150 | <set domain default clause> ::= SET <default clause>
2151 | 
2152 | 
2153 | 11.24  <drop domain default clause>
2154 | 
2155 | Function
2156 | 
2157 | Remove the default clause of a domain.
2158 | 
2159 | Format
2160 | 
2161 | <drop domain default clause> ::= DROP DEFAULT
2162 | 
2163 | 
2164 | 11.25  <add domain constraint definition>
2165 | 
2166 | Function
2167 | 
2168 | Add a constraint to a domain.
2169 | 
2170 | Format
2171 | 
2172 | <add domain constraint definition> ::=
2173 |      ADD <domain constraint>
2174 | 
2175 | 
2176 | 11.26  <drop domain constraint definition>
2177 | 
2178 | Function
2179 | 
2180 | Destroy a constraint on a domain.
2181 | 
2182 | Format
2183 | 
2184 | <drop domain constraint definition> ::=
2185 |      DROP CONSTRAINT <constraint name>
2186 | 
2187 | 
2188 | 11.27  <drop domain statement>
2189 | 
2190 | Function
2191 | 
2192 | Destroy a domain.
2193 | 
2194 | Format
2195 | 
2196 | <drop domain statement> ::=
2197 |      DROP DOMAIN <domain name> <drop behavior>
2198 | 
2199 | 
2200 | 11.28  <character set definition>
2201 | 
2202 | Function
2203 | 
2204 | Define a character set.
2205 | 
2206 | Format
2207 | 
2208 | <character set definition> ::=
2209 |      CREATE CHARACTER SET <character set name> [ AS ]
2210 |        <character set source>
2211 |        [ <collate clause> | <limited collation definition> ]
2212 | 
2213 | <character set source> ::=
2214 |        GET <existing character set name>
2215 | 
2216 | <existing character set name> ::=
2217 |        <standard character repertoire name>
2218 |      | <implementation-defined character repertoire name>
2219 |      | <schema character set name>
2220 | 
2221 | <schema character set name> ::= <character set name>
2222 | 
2223 | <limited collation definition> ::=
2224 |      COLLATION FROM <collation source>
2225 | 
2226 | 
2227 | 11.29  <drop character set statement>
2228 | 
2229 | Function
2230 | 
2231 | Destroy a character set.
2232 | 
2233 | Format
2234 | 
2235 | <drop character set statement> ::=
2236 |      DROP CHARACTER SET <character set name>
2237 | 
2238 | 
2239 | 11.30  <collation definition>
2240 | 
2241 | Function
2242 | 
2243 | Define a collating sequence.
2244 | 
2245 | Format
2246 | 
2247 | <collation definition> ::=
2248 |      CREATE COLLATION <collation name> FOR <character set specification>
2249 | 
2250 |        FROM <collation source>
2251 |          [ <pad attribute> ]
2252 | 
2253 | <pad attribute> ::=
2254 |        NO PAD
2255 |      | PAD SPACE
2256 | 
2257 | <collation source> ::=
2258 |        <collating sequence definition>
2259 |      | <translation collation>
2260 | 
2261 | <collating sequence definition> ::=
2262 |        <external collation>
2263 |      | <schema collation name>
2264 |      | DESC <left paren> <collation name> <right paren>
2265 |      | DEFAULT
2266 | 
2267 | <translation collation> ::=
2268 |      TRANSLATION <translation name>
2269 |          [ THEN COLLATION <collation name> ]
2270 | 
2271 | <external collation> ::=
2272 |      EXTERNAL <left paren> <quote> <external collation name> <quote> <right paren>
2273 | 
2274 | 
2275 | <schema collation name> ::= <collation name>
2276 | 
2277 | <external collation name> ::=
2278 |        <standard collation name>
2279 |      | <implementation-defined collation name>
2280 | 
2281 | <standard collation name> ::= <collation name>
2282 | 
2283 | <implementation-defined collation name> ::= <collation name>
2284 | 
2285 | 
2286 | 11.31  <drop collation statement>
2287 | 
2288 | Function
2289 | 
2290 | Destroy a collating sequence.
2291 | 
2292 | Format
2293 | 
2294 | <drop collation statement> ::=
2295 |      DROP COLLATION <collation name>
2296 | 
2297 | 
2298 | 11.32  <translation definition>
2299 | 
2300 | Function
2301 | 
2302 | Define a character translation.
2303 | 
2304 | Format
2305 | 
2306 | <translation definition> ::=
2307 |      CREATE TRANSLATION <translation name>
2308 |        FOR <source character set specification>
2309 |          TO <target character set specification>
2310 |        FROM <translation source>
2311 | 
2312 | <source character set specification> ::= <character set specification>
2313 | 
2314 | 
2315 | <target character set specification> ::= <character set specification>
2316 | 
2317 | 
2318 | <translation source> ::=
2319 |        <translation specification>
2320 | 
2321 | <translation specification> ::=
2322 |        <external translation>
2323 |      | IDENTITY
2324 |      | <schema translation name>
2325 | 
2326 | <external translation> ::=
2327 |      EXTERNAL <left paren> <quote> <external translation name> <quote> <right paren>
2328 | 
2329 | 
2330 | <external translation name> ::=
2331 |        <standard translation name>
2332 |      | <implementation-defined translation name>
2333 | 
2334 | <standard translation name> ::= <translation name>
2335 | 
2336 | <implementation-defined translation name> ::= <translation name>
2337 | 
2338 | <schema translation name> ::= <translation name>
2339 | 
2340 | 
2341 | 11.33  <drop translation statement>
2342 | 
2343 | Function
2344 | 
2345 | Destroy a character translation.
2346 | 
2347 | Format
2348 | 
2349 | <drop translation statement> ::=
2350 |      DROP TRANSLATION <translation name>
2351 | 
2352 | 
2353 | 11.34  <assertion definition>
2354 | 
2355 | Function
2356 | 
2357 | Specify an integrity constraint by means of an assertion and spec-
2358 | ify the initial default time for checking the assertion.
2359 | 
2360 | Format
2361 | 
2362 | <assertion definition> ::=
2363 |      CREATE ASSERTION <constraint name> <assertion check>
2364 |      [ <constraint attributes> ]
2365 | 
2366 | <assertion check> ::=
2367 |      CHECK <left paren> <search condition> <right paren>
2368 | 
2369 | 
2370 | 11.35  <drop assertion statement>
2371 | 
2372 | Function
2373 | 
2374 | Destroy an assertion.
2375 | 
2376 | Format
2377 | 
2378 | <drop assertion statement> ::=
2379 |      DROP ASSERTION <constraint name>
2380 | 
2381 | 
2382 | 11.36  <grant statement>
2383 | 
2384 | Function
2385 | 
2386 | Define privileges.
2387 | 
2388 | Format
2389 | 
2390 | <grant statement> ::=
2391 |      GRANT <privileges> ON <object name>
2392 |        TO <grantee> [ { <comma> <grantee> }... ]
2393 |          [ WITH GRANT OPTION ]
2394 | 
2395 | <object name> ::=
2396 |        [ TABLE ] <table name>
2397 |      | DOMAIN <domain name>
2398 |      | COLLATION <collation name>
2399 |      | CHARACTER SET <character set name>
2400 |      | TRANSLATION <translation name>
2401 | 
2402 | 
2403 | 11.37  <revoke statement>
2404 | 
2405 | Function
2406 | 
2407 | Destroy privileges.
2408 | 
2409 | Format
2410 | 
2411 | <revoke statement> ::=
2412 |      REVOKE [ GRANT OPTION FOR ] <privileges>
2413 |          ON <object name>
2414 |        FROM <grantee> [ { <comma> <grantee> }... ] <drop behavior>
2415 | 
2416 | 
2417 | 12  Module
2418 | 
2419 | 
2420 | 
2421 | 12.1  <module>
2422 | 
2423 | Function
2424 | 
2425 | Define a module.
2426 | 
2427 | Format
2428 | 
2429 | <module> ::=
2430 |      <module name clause>
2431 |      <language clause>
2432 |      <module authorization clause>
2433 |      [ <temporary table declaration>... ]
2434 |      <module contents>...
2435 | 
2436 | <module authorization clause> ::=
2437 |        SCHEMA <schema name>
2438 |      | AUTHORIZATION <module authorization identifier>
2439 |      | SCHEMA <schema name> AUTHORIZATION <module authorization identifier>
2440 | 
2441 | 
2442 | <module authorization identifier> ::=
2443 |      <authorization identifier>
2444 | 
2445 | <module contents> ::=
2446 |        <declare cursor>
2447 |      | <dynamic declare cursor>
2448 |      | <procedure>
2449 | 
2450 | 
2451 | 12.2  <module name clause>
2452 | 
2453 | Function
2454 | 
2455 | Name a <module>.
2456 | 
2457 | Format
2458 | 
2459 | <module name clause> ::=
2460 |      MODULE [ <module name> ]
2461 |        [ <module character set specification> ]
2462 | 
2463 | <module character set specification> ::=
2464 |      NAMES ARE <character set specification>
2465 | 
2466 | 
2467 | 12.3  <procedure>
2468 | 
2469 | Function
2470 | 
2471 | Define a procedure.
2472 | 
2473 | Format
2474 | 
2475 | <procedure> ::=
2476 |      PROCEDURE <procedure name> <parameter declaration list> <semicolon>
2477 | 
2478 |        <SQL procedure statement> <semicolon>
2479 | 
2480 | <parameter declaration list> ::=
2481 |        <left paren> <parameter declaration>
2482 |            [ { <comma> <parameter declaration> }... ] <right paren>
2483 | 
2484 |      | <parameter declaration>...
2485 | 
2486 | <parameter declaration> ::=
2487 |        <parameter name> <data type>
2488 |      | <status parameter>
2489 | 
2490 | <status parameter> ::=
2491 |      SQLCODE | SQLSTATE
2492 | 
2493 | 
2494 | 12.5  <SQL procedure statement>
2495 | 
2496 | Function
2497 | 
2498 | Define all of the SQL-statements that are <SQL procedure state-
2499 | ment>s.
2500 | 
2501 | Format
2502 | 
2503 | <SQL procedure statement> ::=
2504 |        <SQL schema statement>
2505 |      | <SQL data statement>
2506 |      | <SQL transaction statement>
2507 |      | <SQL connection statement>
2508 |      | <SQL session statement>
2509 |      | <SQL dynamic statement>
2510 |      | <SQL diagnostics statement>
2511 | 
2512 | <SQL schema statement> ::=
2513 |        <SQL schema definition statement>
2514 |      | <SQL schema manipulation statement>
2515 | 
2516 | <SQL schema definition statement> ::=
2517 |        <schema definition>
2518 |      | <table definition>
2519 |      | <view definition>
2520 |      | <grant statement>
2521 |      | <domain definition>
2522 |      | <character set definition>
2523 |      | <collation definition>
2524 |      | <translation definition>
2525 |      | <assertion definition>
2526 | 
2527 | <SQL schema manipulation statement> ::=
2528 |        <drop schema statement>
2529 |      | <alter table statement>
2530 |      | <drop table statement>
2531 |      | <drop view statement>
2532 |      | <revoke statement>
2533 |      | <alter domain statement>
2534 |      | <drop domain statement>
2535 |      | <drop character set statement>
2536 |      | <drop collation statement>
2537 |      | <drop translation statement>
2538 |      | <drop assertion statement>
2539 | 
2540 | <SQL data statement> ::=
2541 |        <open statement>
2542 |      | <fetch statement>
2543 |      | <close statement>
2544 |      | <select statement: single row>
2545 |      | <SQL data change statement>
2546 | 
2547 | <SQL data change statement> ::=
2548 |        <delete statement: positioned>
2549 |      | <delete statement: searched>
2550 |      | <insert statement>
2551 |      | <update statement: positioned>
2552 |      | <update statement: searched>
2553 | 
2554 | <SQL transaction statement> ::=
2555 |        <set transaction statement>
2556 |      | <set constraints mode statement>
2557 |      | <commit statement>
2558 |      | <rollback statement>
2559 | 
2560 | <SQL connection statement> ::=
2561 |        <connect statement>
2562 |      | <set connection statement>
2563 |      | <disconnect statement>
2564 | 
2565 | <SQL session statement> ::=
2566 |        <set catalog statement>
2567 |      | <set schema statement>
2568 |      | <set names statement>
2569 |      | <set session authorization identifier statement>
2570 |      | <set local time zone statement>
2571 | 
2572 | <SQL dynamic statement> ::=
2573 |        <system descriptor statement>
2574 |      | <prepare statement>
2575 |      | <deallocate prepared statement>
2576 |      | <describe statement>
2577 |      | <execute statement>
2578 |      | <execute immediate statement>
2579 |      | <SQL dynamic data statement>
2580 | 
2581 | <SQL dynamic data statement> ::=
2582 |        <allocate cursor statement>
2583 |      | <dynamic open statement>
2584 |      | <dynamic fetch statement>
2585 |      | <dynamic close statement>
2586 |      | <dynamic delete statement: positioned>
2587 |      | <dynamic update statement: positioned>
2588 | 
2589 | <system descriptor statement> ::=
2590 |        <allocate descriptor statement>
2591 |      | <deallocate descriptor statement>
2592 |      | <set descriptor statement>
2593 |      | <get descriptor statement>
2594 | 
2595 | <SQL diagnostics statement> ::=
2596 |      <get diagnostics statement>
2597 | 
2598 | 13  Data manipulation
2599 | 
2600 | 
2601 | 
2602 | 13.1  <declare cursor>
2603 | 
2604 | Function
2605 | 
2606 | Define a cursor.
2607 | 
2608 | Format
2609 | 
2610 | <declare cursor> ::=
2611 |      DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR
2612 |        FOR <cursor specification>
2613 | 
2614 | <cursor specification> ::=
2615 |      <query expression> [ <order by clause> ]
2616 |        [ <updatability clause> ]
2617 | 
2618 | <updatability clause> ::=
2619 |      FOR { READ ONLY | UPDATE [ OF <column name list> ] }
2620 | 
2621 | <order by clause> ::=
2622 |      ORDER BY <sort specification list>
2623 | 
2624 | <sort specification list> ::=
2625 |      <sort specification> [ { <comma> <sort specification> }... ]
2626 | 
2627 | <sort specification> ::=
2628 |      <sort key> [ <collate clause > ] [ <ordering specification> ]
2629 | 
2630 | 
2631 | <sort key> ::=
2632 |        <column name>
2633 |      | <unsigned integer>
2634 | 
2635 | <ordering specification> ::= ASC | DESC
2636 | 
2637 | 
2638 | 13.2  <open statement>
2639 | 
2640 | Function
2641 | 
2642 | Open a cursor.
2643 | 
2644 | Format
2645 | 
2646 | <open statement> ::=
2647 |      OPEN <cursor name>
2648 | 
2649 | 
2650 | 13.3  <fetch statement>
2651 | 
2652 | Function
2653 | 
2654 | Position a cursor on a specified row of a table and retrieve values
2655 | from that row.
2656 | 
2657 | Format
2658 | 
2659 | <fetch statement> ::=
2660 |      FETCH [ [ <fetch orientation> ] FROM ]
2661 |        <cursor name> INTO <fetch target list>
2662 | 
2663 | <fetch orientation> ::=
2664 |        NEXT
2665 |      | PRIOR
2666 |      | FIRST
2667 |      | LAST
2668 |      | { ABSOLUTE | RELATIVE } <simple value specification>
2669 | 
2670 | <fetch target list> ::=
2671 |      <target specification> [ { <comma> <target specification> }... ]
2672 | 
2673 | 
2674 | 13.4  <close statement>
2675 | 
2676 | Function
2677 | 
2678 | Close a cursor.
2679 | 
2680 | Format
2681 | 
2682 | <close statement> ::=
2683 |      CLOSE <cursor name>
2684 | 
2685 | 
2686 | 13.5  <select statement: single row>
2687 | 
2688 | Function
2689 | 
2690 | Retrieve values from a specified row of a table.
2691 | 
2692 | Format
2693 | 
2694 | <select statement: single row> ::=
2695 |      SELECT [ <set quantifier> ] <select list>
2696 |        INTO <select target list>
2697 |          <table expression>
2698 | 
2699 | <select target list> ::=
2700 |      <target specification> [ { <comma> <target specification> }... ]
2701 | 
2702 | 
2703 | 13.6  <delete statement: positioned>
2704 | 
2705 | Function
2706 | 
2707 | Delete a row of a table.
2708 | 
2709 | Format
2710 | 
2711 | <delete statement: positioned> ::=
2712 |      DELETE FROM <table name>
2713 |        WHERE CURRENT OF <cursor name>
2714 | 
2715 | 
2716 | 13.7  <delete statement: searched>
2717 | 
2718 | Function
2719 | 
2720 | Delete rows of a table.
2721 | 
2722 | Format
2723 | 
2724 | <delete statement: searched> ::=
2725 |      DELETE FROM <table name>
2726 |        [ WHERE <search condition> ]
2727 | 
2728 | 
2729 | 13.8  <insert statement>
2730 | 
2731 | Function
2732 | 
2733 | Create new rows in a table.
2734 | 
2735 | Format
2736 | 
2737 | <insert statement> ::=
2738 |      INSERT INTO <table name>
2739 |        <insert columns and source>
2740 | 
2741 | <insert columns and source> ::=
2742 |        [ <left paren> <insert column list> <right paren> ]
2743 |      <query expression>
2744 |      | DEFAULT VALUES
2745 | 
2746 | <insert column list> ::= <column name list>
2747 | 
2748 | 
2749 | 13.9  <update statement: positioned>
2750 | 
2751 | Function
2752 | 
2753 | Update a row of a table.
2754 | 
2755 | Format
2756 | 
2757 | <update statement: positioned> ::=
2758 |      UPDATE <table name>
2759 |        SET <set clause list>
2760 |          WHERE CURRENT OF <cursor name>
2761 | 
2762 | <set clause list> ::=
2763 |      <set clause> [ { <comma> <set clause> }... ]
2764 | 
2765 | <set clause> ::=
2766 |      <object column> <equals operator> <update source>
2767 | 
2768 | <update source> ::=
2769 |        <value expression>
2770 |      | <null specification>
2771 |      | DEFAULT
2772 | 
2773 | <object column> ::= <column name>
2774 | 
2775 | 
2776 | 13.10  <update statement: searched>
2777 | 
2778 | Function
2779 | 
2780 | Update rows of a table.
2781 | 
2782 | Format
2783 | 
2784 | <update statement: searched> ::=
2785 |      UPDATE <table name>
2786 |        SET <set clause list>
2787 |        [ WHERE <search condition> ]
2788 | 
2789 | 
2790 | 13.11  <temporary table declaration>
2791 | 
2792 | Function
2793 | 
2794 | Declare a declared local temporary table that will be effectively
2795 | materialized the first time that any <procedure> in the <module>
2796 | that contains the <temporary table declaration> is executed and
2797 | whose scope is all the <procedure>s of that <module> executed
2798 | within the same SQL-session.
2799 | 
2800 | Format
2801 | 
2802 | <temporary table declaration> ::=
2803 |      DECLARE LOCAL TEMPORARY TABLE <qualified local table name>
2804 |        <table element list>
2805 |        [ ON COMMIT { PRESERVE | DELETE } ROWS ]
2806 | 
2807 | 
2808 | 14  Transaction management
2809 | 
2810 | 
2811 | 
2812 | 14.1  <set transaction statement>
2813 | 
2814 | Function
2815 | 
2816 | Set the attributes of the next SQL-transaction for the SQL-agent.
2817 | 
2818 | Format
2819 | 
2820 | <set transaction statement> ::=
2821 |      SET TRANSACTION <transaction mode> [ { <comma> <transaction mode> }... ]
2822 | 
2823 | 
2824 | <transaction mode> ::=
2825 |        <isolation level>
2826 |      | <transaction access mode>
2827 |      | <diagnostics size>
2828 | 
2829 | <transaction access mode> ::=
2830 |        READ ONLY
2831 |      | READ WRITE
2832 | 
2833 | <isolation level> ::=
2834 |      ISOLATION LEVEL <level of isolation>
2835 | 
2836 | <level of isolation> ::=
2837 |        READ UNCOMMITTED
2838 |      | READ COMMITTED
2839 |      | REPEATABLE READ
2840 |      | SERIALIZABLE
2841 | 
2842 | <diagnostics size> ::=
2843 |      DIAGNOSTICS SIZE <number of conditions>
2844 | 
2845 | <number of conditions> ::= <simple value specification>
2846 | 
2847 | 
2848 | 
2849 | 14.2  <set constraints mode statement>
2850 | 
2851 | Function
2852 | 
2853 | If an SQL-transaction is currently active, then set the constraint
2854 | mode for that SQL-transaction in the current SQL-session. If no
2855 | SQL-transaction is currently active, then set the constraint mode
2856 | for the next SQL-transaction in the current SQL-session for the
2857 | SQL-agent.
2858 | 
2859 | Format
2860 | 
2861 | <set constraints mode statement> ::=
2862 |      SET CONSTRAINTS <constraint name list> { DEFERRED | IMMEDIATE }
2863 | 
2864 | 
2865 | <constraint name list> ::=
2866 |        ALL
2867 |      | <constraint name> [ { <comma> <constraint name> }... ]
2868 | 
2869 | 
2870 | 14.3  <commit statement>
2871 | 
2872 | Function
2873 | 
2874 | Terminate the current SQL-transaction with commit.
2875 | 
2876 | Format
2877 | 
2878 | <commit statement> ::=
2879 |      COMMIT [ WORK ]
2880 | 
2881 | 
2882 | 14.4  <rollback statement>
2883 | 
2884 | Function
2885 | 
2886 | Terminate the current SQL-transaction with rollback.
2887 | 
2888 | Format
2889 | 
2890 | <rollback statement> ::=
2891 |      ROLLBACK [ WORK ]
2892 | 
2893 | 
2894 | 15  Connection management
2895 | 
2896 | 
2897 | 
2898 | 15.1  <connect statement>
2899 | 
2900 | Function
2901 | 
2902 | Establish an SQL-connection.
2903 | 
2904 | Format
2905 | 
2906 | <connect statement> ::=
2907 |      CONNECT TO <connection target>
2908 | 
2909 | <connection target> ::=
2910 |        <SQL-server name>
2911 |          [ AS <connection name> ]
2912 |          [ USER <user name> ]
2913 |      | DEFAULT
2914 | 
2915 | 
2916 | 15.2  <set connection statement>
2917 | 
2918 | Function
2919 | 
2920 | Select an SQL-connection from the available SQL-connections.
2921 | 
2922 | Format
2923 | 
2924 | <set connection statement> ::=
2925 |      SET CONNECTION <connection object>
2926 | 
2927 | <connection object> ::=
2928 |        DEFAULT
2929 |      | <connection name>
2930 | 
2931 | 15.3  <disconnect statement>
2932 | 
2933 | Function
2934 | 
2935 | Terminate an SQL-connection.
2936 | 
2937 | Format
2938 | 
2939 | <disconnect statement> ::=
2940 |      DISCONNECT <disconnect object>
2941 | 
2942 | <disconnect object> ::=
2943 |        <connection object>
2944 |      | ALL
2945 |      | CURRENT
2946 | 
2947 | 
2948 | 16  Session management
2949 | 
2950 | 
2951 | 
2952 | 16.1  <set catalog statement>
2953 | 
2954 | Function
2955 | 
2956 | Set the default catalog name for unqualified <schema name>s in
2957 | <preparable statement>s that are prepared in the current SQL-
2958 | session by an <execute immediate statement> or a <prepare state-
2959 | ment> and in <direct SQL statement>s that are invoked directly.
2960 | 
2961 | Format
2962 | 
2963 | 
2964 | <set catalog statement> ::=
2965 |      SET CATALOG <value specification>
2966 | 
2967 | 
2968 | 16.2  <set schema statement>
2969 | 
2970 | Function
2971 | 
2972 | Set the default schema name for unqualified <qualified name>s in
2973 | <preparable statement>s that are prepared in the current SQL-
2974 | session by an <execute immediate statement> or a <prepare state-
2975 | ment> and in <direct SQL statement>s that are invoked directly.
2976 | 
2977 | Format
2978 | 
2979 | 
2980 | <set schema statement> ::=
2981 |      SET SCHEMA <value specification>
2982 | 
2983 | 
2984 | 16.3  <set names statement>
2985 | 
2986 | Function
2987 | 
2988 | Set the default character set name for <identifier>s and <character
2989 | string literal>s in <preparable statement>s that are prepared in
2990 | the current SQL-session by an <execute immediate statement> or a
2991 | <prepare statement> and in <direct SQL statement>s that are invoked
2992 | directly.
2993 | 
2994 | Format
2995 | 
2996 | <set names statement> ::=
2997 |      SET NAMES <value specification>
2998 | 
2999 | 
3000 | 16.4  <set session authorization identifier statement>
3001 | 
3002 | Function
3003 | 
3004 | Set the <authorization identifier> of the current SQL-session.
3005 | 
3006 | Format
3007 | 
3008 | <set session authorization identifier statement> ::=
3009 |      SET SESSION AUTHORIZATION <value specification>
3010 | 
3011 | 
3012 | 16.5  <set local time zone statement>
3013 | 
3014 | Function
3015 | 
3016 | Set the default local time zone displacement for the current SQL-
3017 | session.
3018 | 
3019 | Format
3020 | 
3021 | <set local time zone statement> ::=
3022 |      SET TIME ZONE <set time zone value>
3023 | 
3024 | <set time zone value> ::=
3025 |        <interval value expression>
3026 |      | LOCAL
3027 | 
3028 | 
3029 | 17.2  <allocate descriptor statement>
3030 | 
3031 | Function
3032 | 
3033 | Allocate an SQL descriptor area.
3034 | 
3035 | Format
3036 | 
3037 | <allocate descriptor statement> ::=
3038 |      ALLOCATE DESCRIPTOR <descriptor name> [ WITH MAX <occurrences> ]
3039 | 
3040 | 
3041 | <occurrences> ::= <simple value specification>
3042 | 
3043 | 
3044 | 17.3  <deallocate descriptor statement>
3045 | 
3046 | Function
3047 | 
3048 | Deallocate an SQL descriptor area.
3049 | 
3050 | Format
3051 | 
3052 | <deallocate descriptor statement> ::=
3053 |      DEALLOCATE DESCRIPTOR <descriptor name>
3054 | 
3055 | 
3056 | 17.4  <get descriptor statement>
3057 | 
3058 | Function
3059 | 
3060 | Get information from an SQL descriptor area.
3061 | 
3062 | Format
3063 | 
3064 | <get descriptor statement> ::=
3065 |      GET DESCRIPTOR <descriptor name> <get descriptor information>
3066 | 
3067 | 
3068 | <get descriptor information> ::=
3069 |        <get count>
3070 |      | VALUE <item number>
3071 |          <get item information> [ { <comma> <get item information> }... ]
3072 | 
3073 | 
3074 | <get count> ::=
3075 |      <simple target specification 1> <equals operator> COUNT
3076 | 
3077 | <get item information> ::=
3078 |      <simple target specification 2> <equals operator> <descriptor item name>>
3079 | 
3080 | 
3081 | <item number> ::= <simple value specification>
3082 | 
3083 | <simple target specification 1> ::= <simple target specification>
3084 | 
3085 | <simple target specification 2> ::= <simple target specification>
3086 | 
3087 | <descriptor item name> ::=
3088 |        TYPE
3089 |      | LENGTH
3090 |      | OCTET_LENGTH
3091 |      | RETURNED_LENGTH
3092 |      | RETURNED_OCTET_LENGTH
3093 |      | PRECISION
3094 |      | SCALE
3095 |      | DATETIME_INTERVAL_CODE
3096 |      | DATETIME_INTERVAL_PRECISION
3097 |      | NULLABLE
3098 |      | INDICATOR
3099 |      | DATA
3100 |      | NAME
3101 |      | UNNAMED
3102 |      | COLLATION_CATALOG
3103 |      | COLLATION_SCHEMA
3104 |      | COLLATION_NAME
3105 |      | CHARACTER_SET_CATALOG
3106 |      | CHARACTER_SET_SCHEMA
3107 |      | CHARACTER_SET_NAME
3108 | 
3109 | 
3110 | 17.5  <set descriptor statement>
3111 | 
3112 | Function
3113 | 
3114 | Set information in an SQL descriptor area.
3115 | 
3116 | Format
3117 | 
3118 | <set descriptor statement> ::=
3119 |      SET DESCRIPTOR <descriptor name> <set descriptor information>
3120 | 
3121 | 
3122 | <set descriptor information> ::=
3123 |        <set count>
3124 |      | VALUE <item number>
3125 |          <set item information> [ { <comma> <set item information> }... ]
3126 | 
3127 | 
3128 | <set count> ::=
3129 |      COUNT <equals operator> <simple value specification 1>
3130 | 
3131 | <set item information> ::=
3132 |      <descriptor item name> <equals operator> <simple value specification 2>
3133 | 
3134 | 
3135 | <simple value specification 1> ::= <simple value specification>
3136 | 
3137 | <simple value specification 2> ::= <simple value specification>
3138 | 
3139 | <item number> ::= <simple value specification>
3140 | 
3141 | 
3142 | 17.6  <prepare statement>
3143 | 
3144 | Function
3145 | 
3146 | Prepare a statement for execution.
3147 | 
3148 | Format
3149 | 
3150 | <prepare statement> ::=
3151 |      PREPARE <SQL statement name> FROM <SQL statement variable>
3152 | 
3153 | <SQL statement variable> ::= <simple value specification>
3154 | 
3155 | <preparable statement> ::=
3156 |        <preparable SQL data statement>
3157 |      | <preparable SQL schema statement>
3158 |      | <preparable SQL transaction statement>
3159 |      | <preparable SQL session statement>
3160 |      | <preparable implementation-defined statement>
3161 | 
3162 | <preparable SQL data statement> ::=
3163 |        <delete statement: searched>
3164 |      | <dynamic single row select statement>
3165 |      | <insert statement>
3166 |      | <dynamic select statement>
3167 |      | <update statement: searched>
3168 |      | <preparable dynamic delete statement: positioned>
3169 |      | <preparable dynamic update statement: positioned>
3170 | 
3171 | <preparable SQL schema statement> ::=
3172 |        <SQL schema statement>
3173 | 
3174 | <preparable SQL transaction statement> ::=
3175 |        <SQL transaction statement>
3176 | 
3177 | <preparable SQL session statement> ::=
3178 |        <SQL session statement>
3179 | 
3180 | <dynamic select statement> ::= <cursor specification>
3181 | 
3182 | <dynamic single row select statement> ::= <query specification>
3183 | 
3184 | <preparable implementation-defined statement> ::= !! See the Syntax
3185 | Rules.
3186 | 
3187 | 
3188 | 17.7  <deallocate prepared statement>
3189 | 
3190 | Function
3191 | 
3192 | Deallocate SQL-statements that have been prepared with a <prepare
3193 | statement>.
3194 | 
3195 | Format
3196 | 
3197 | <deallocate prepared statement> ::=
3198 |      DEALLOCATE PREPARE <SQL statement name>
3199 | 
3200 | 
3201 | 17.8  <describe statement>
3202 | 
3203 | Function
3204 | 
3205 | Obtain information about the <select list> columns or <dynamic
3206 | parameter specification>s contained in a prepared statement.
3207 | 
3208 | Format
3209 | 
3210 | <describe statement> ::=
3211 |        <describe input statement>
3212 |      | <describe output statement>
3213 | 
3214 | <describe input statement> ::=
3215 |      DESCRIBE INPUT <SQL statement name> <using descriptor>
3216 | 
3217 | <describe output statement> ::=
3218 |      DESCRIBE [ OUTPUT ] <SQL statement name> <using descriptor>
3219 | 
3220 | 
3221 | 17.9  <using clause>
3222 | 
3223 | Function
3224 | 
3225 | Describe the input/output variables for an <SQL dynamic statement>.
3226 | 
3227 | Format
3228 | 
3229 | 
3230 | <using clause> ::=
3231 |        <using arguments>
3232 |      | <using descriptor>
3233 | 
3234 | <using arguments> ::=
3235 |      { USING | INTO } <argument> [ { <comma> <argument> }... ]
3236 | 
3237 | <argument> ::= <target specification>
3238 | 
3239 | <using descriptor> ::=
3240 |      { USING | INTO } SQL DESCRIPTOR <descriptor name>
3241 | 
3242 | 
3243 | 17.10  <execute statement>
3244 | 
3245 | Function
3246 | 
3247 | Associate input parameters and output targets with a prepared
3248 | statement and execute the statement.
3249 | 
3250 | Format
3251 | 
3252 | <execute statement> ::=
3253 |      EXECUTE <SQL statement name>
3254 |        [ <result using clause> ]
3255 |        [ <parameter using clause> ]
3256 | 
3257 | <result using clause> ::= <using clause>
3258 | 
3259 | <parameter using clause> ::= <using clause>
3260 | 
3261 | 
3262 | 17.11  <execute immediate statement>
3263 | 
3264 | Function
3265 | 
3266 | Dynamically prepare and execute a preparable statement.
3267 | 
3268 | Format
3269 | 
3270 | <execute immediate statement> ::=
3271 |      EXECUTE IMMEDIATE <SQL statement variable>
3272 | 
3273 | 
3274 | 17.12  <dynamic declare cursor>
3275 | 
3276 | Function
3277 | 
3278 | Declare a cursor to be associated with a <statement name>, which
3279 | may in turn be associated with a <cursor specification>.
3280 | 
3281 | Format
3282 | 
3283 | <dynamic declare cursor> ::=
3284 |      DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR
3285 |      FOR <statement name>
3286 | 
3287 | 
3288 | 17.13  <allocate cursor statement>
3289 | 
3290 | Function
3291 | 
3292 | Define a cursor based on a <prepare statement> for a <cursor speci-
3293 | fication>.
3294 | 
3295 | Format
3296 | 
3297 | <allocate cursor statement> ::=
3298 |      ALLOCATE <extended cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR
3299 |        FOR <extended statement name>
3300 | 
3301 | 
3302 | 17.14  <dynamic open statement>
3303 | 
3304 | Function
3305 | 
3306 | Associate input parameters with a <cursor specification> and open
3307 | the cursor.
3308 | 
3309 | Format
3310 | 
3311 | <dynamic open statement> ::=
3312 |      OPEN <dynamic cursor name> [ <using clause> ]
3313 | 
3314 | 17.15  <dynamic fetch statement>
3315 | 
3316 | Function
3317 | 
3318 | Fetch a row for a cursor declared with a <dynamic declare cursor>.
3319 | 
3320 | Format
3321 | 
3322 | <dynamic fetch statement> ::=
3323 |      FETCH [ [ <fetch orientation> ] FROM ] <dynamic cursor name>
3324 |      <using clause>
3325 | 
3326 | 17.16  <dynamic close statement>
3327 | 
3328 | Function
3329 | 
3330 | Close a cursor.
3331 | 
3332 | Format
3333 | 
3334 | <dynamic close statement> ::=
3335 |      CLOSE <dynamic cursor name>
3336 | 
3337 | 
3338 | 17.17  <dynamic delete statement: positioned>
3339 | 
3340 | Function
3341 | 
3342 | Delete a row of a table.
3343 | 
3344 | Format
3345 | 
3346 | <dynamic delete statement: positioned> ::=
3347 |      DELETE FROM <table name>
3348 |        WHERE CURRENT OF <dynamic cursor name>
3349 | 
3350 | 
3351 | 17.18  <dynamic update statement: positioned>
3352 | 
3353 | Function
3354 | 
3355 | Update a row of a table.
3356 | 
3357 | Format
3358 | 
3359 | <dynamic update statement: positioned> ::=
3360 |      UPDATE <table name>
3361 |        SET <set clause> [ { <comma> <set clause> }... ]
3362 |          WHERE CURRENT OF <dynamic cursor name>
3363 | 
3364 | 
3365 | 17.19  <preparable dynamic delete statement: positioned>
3366 | 
3367 | Function
3368 | 
3369 | Delete a row of a table through a dynamic cursor.
3370 | 
3371 | Format
3372 | 
3373 | <preparable dynamic delete statement: positioned> ::=
3374 |      DELETE [ FROM <table name> ]
3375 |        WHERE CURRENT OF <cursor name>
3376 | 
3377 | 
3378 | 17.20  <preparable dynamic update statement: positioned>
3379 | 
3380 | Function
3381 | 
3382 | Update a row of a table through a dynamic cursor.
3383 | 
3384 | Format
3385 | 
3386 | <preparable dynamic update statement: positioned> ::=
3387 |      UPDATE [ <table name> ]
3388 |        SET <set clause list>
3389 |        WHERE CURRENT OF <cursor name>
3390 | 
3391 | 
3392 | 18  Diagnostics management
3393 | 
3394 | 
3395 | 
3396 | 18.1  <get diagnostics statement>
3397 | 
3398 | Function
3399 | 
3400 | Get exception or completion condition information from the diagnos-
3401 | tics area.
3402 | 
3403 | Format
3404 | 
3405 | <get diagnostics statement> ::=
3406 |      GET DIAGNOSTICS <sql diagnostics information>
3407 | 
3408 | <sql diagnostics information> ::=
3409 |        <statement information>
3410 |      | <condition information>
3411 | 
3412 | <statement information> ::=
3413 |      <statement information item> [ { <comma> <statement information item> }... ]
3414 | 
3415 | 
3416 | <statement information item> ::=
3417 |      <simple target specification> <equals operator> <statement information item name>
3418 | 
3419 | 
3420 | <statement information item name> ::=
3421 |        NUMBER
3422 |      | MORE
3423 |      | COMMAND_FUNCTION
3424 |      | DYNAMIC_FUNCTION
3425 |      | ROW_COUNT
3426 | 
3427 | <condition information> ::=
3428 |      EXCEPTION <condition number>
3429 |        <condition information item> [ { <comma> <condition information item> }... ]
3430 | 
3431 | 
3432 | <condition information item> ::=
3433 |      <simple target specification> <equals operator> <condition information item name>
3434 | 
3435 | 
3436 | <condition information item name> ::=
3437 |        CONDITION_NUMBER
3438 |      | RETURNED_SQLSTATE
3439 |      | CLASS_ORIGIN
3440 |      | SUBCLASS_ORIGIN
3441 |      | SERVER_NAME
3442 |      | CONNECTION_NAME
3443 |      | CONSTRAINT_CATALOG
3444 |      | CONSTRAINT_SCHEMA
3445 |      | CONSTRAINT_NAME
3446 |      | CATALOG_NAME
3447 |      | SCHEMA_NAME
3448 |      | TABLE_NAME
3449 |      | COLUMN_NAME
3450 |      | CURSOR_NAME
3451 |      | MESSAGE_TEXT
3452 |      | MESSAGE_LENGTH
3453 |      | MESSAGE_OCTET_LENGTH
3454 | 
3455 | <condition number> ::= <simple value specification>
3456 | 
3457 | 
3458 | 19  Embedded SQL
3459 | 
3460 | 
3461 | 
3462 | 19.1  <embedded SQL host program>
3463 | 
3464 | Function
3465 | 
3466 | Specify an <embedded SQL host program>.
3467 | 
3468 | Format
3469 | 
3470 | <embedded SQL host program> ::=
3471 |        <embedded SQL Ada program>
3472 |      | <embedded SQL C program>
3473 |      | <embedded SQL COBOL program>
3474 |      | <embedded SQL Fortran program>
3475 |      | <embedded SQL MUMPS program>
3476 |      | <embedded SQL Pascal program>
3477 |      | <embedded SQL PL/I program>
3478 | 
3479 | <embedded SQL statement> ::=
3480 |      <SQL prefix>
3481 |        <statement or declaration>
3482 |      [ <SQL terminator> ]
3483 | 
3484 | <statement or declaration> ::=
3485 |        <declare cursor>
3486 |      | <dynamic declare cursor>
3487 |      | <temporary table declaration>
3488 |      | <embedded exception declaration>
3489 |      | <SQL procedure statement>
3490 | 
3491 | <SQL prefix> ::=
3492 |        EXEC SQL
3493 |      | <ampersand>SQL<left paren>
3494 | 
3495 | <SQL terminator> ::=
3496 |        END-EXEC
3497 |      | <semicolon>
3498 |      | <right paren>
3499 | 
3500 | <embedded SQL declare section> ::=
3501 |        <embedded SQL begin declare>
3502 |          [ <embedded character set declaration> ]
3503 |          [ <host variable definition>... ]
3504 |        <embedded SQL end declare>
3505 |      | <embedded SQL MUMPS declare>
3506 | 
3507 | <embedded character set declaration> ::=
3508 |      SQL NAMES ARE <character set specification>
3509 | 
3510 | <embedded SQL begin declare> ::=
3511 |      <SQL prefix> BEGIN DECLARE SECTION [ <SQL terminator> ]
3512 | 
3513 | <embedded SQL end declare> ::=
3514 |      <SQL prefix> END DECLARE SECTION [ <SQL terminator> ]
3515 | 
3516 | <embedded SQL MUMPS declare> ::=
3517 |      <SQL prefix>
3518 |        BEGIN DECLARE SECTION
3519 |          [ <embedded character set declaration> ]
3520 |          [ <host variable definition>... ]
3521 |        END DECLARE SECTION
3522 |      <SQL terminator>
3523 | 
3524 | <host variable definition> ::=
3525 |        <Ada variable definition>
3526 |      | <C variable definition>
3527 |      | <COBOL variable definition>
3528 |      | <Fortran variable definition>
3529 |      | <MUMPS variable definition>
3530 |      | <Pascal variable definition>
3531 |      | <PL/I variable definition>
3532 | 
3533 | <embedded variable name> ::=
3534 |      <colon><host identifier>
3535 | 
3536 | <host identifier> ::=
3537 |        <Ada host identifier>
3538 |      | <C host identifier>
3539 |      | <COBOL host identifier>
3540 |      | <Fortran host identifier>
3541 |      | <MUMPS host identifier>
3542 |      | <Pascal host identifier>
3543 |      | <PL/I host identifier>
3544 | 
3545 | 
3546 | 19.2  <embedded exception declaration>
3547 | 
3548 | Function
3549 | 
3550 | Specify the action to be taken when an SQL-statement causes a spe-
3551 | cific class of condition to be raised.
3552 | 
3553 | Format
3554 | 
3555 | <embedded exception declaration> ::=
3556 |      WHENEVER <condition> <condition action>
3557 | 
3558 | <condition> ::=
3559 |      SQLERROR | NOT FOUND
3560 | 
3561 | <condition action> ::=
3562 |      CONTINUE | <go to>
3563 | 
3564 | <go to> ::=
3565 |      { GOTO | GO TO } <goto target>
3566 | 
3567 | <goto target> ::=
3568 |        <host label identifier>
3569 |      | <unsigned integer>
3570 |      | <host PL/I label variable>
3571 | 
3572 | <host label identifier> ::= !!See the Syntax Rules.
3573 | 
3574 | <host PL/I label variable> ::= !!See the Syntax Rules.
3575 | 
3576 | 19.3  <embedded SQL Ada program>
3577 | 
3578 | Function
3579 | 
3580 | Specify an <embedded SQL Ada program>.
3581 | 
3582 | Format
3583 | 
3584 | <embedded SQL Ada program> ::= !! See the Syntax Rules.
3585 | 
3586 | <Ada variable definition> ::=
3587 |      <Ada host identifier> [ { <comma> <Ada host identifier> }... ] :
3588 | 
3589 |      <Ada type specification> [ <Ada initial value> ]
3590 | 
3591 | <Ada initial value> ::=
3592 |      <Ada assignment operator> <character representation>...
3593 | 
3594 | <Ada assignment operator> ::= <colon><equals operator>
3595 | 
3596 | <Ada host identifier> ::= !! See the Syntax Rules.
3597 | 
3598 | <Ada type specification> ::=
3599 |        <Ada qualified type specification>
3600 |      | <Ada unqualified type specification>
3601 | 
3602 | <Ada qualified type specification> ::=
3603 |        SQL_STANDARD.CHAR [ CHARACTER SET [ IS ] <character set specification> ]
3604 | 
3605 |            <left paren> 1 <double period> <length> <right paren>
3606 |      | SQL_STANDARD.BIT <left paren> 1 <double period> <length> <right paren>
3607 | 
3608 |      | SQL_STANDARD.SMALLINT
3609 |      | SQL_STANDARD.INT
3610 |      | SQL_STANDARD.REAL
3611 |      | SQL_STANDARD.DOUBLE_PRECISION
3612 |      | SQL_STANDARD.SQLCODE_TYPE
3613 |      | SQL_STANDARD.SQLSTATE_TYPE
3614 |      | SQL_STANDARD.INDICATOR_TYPE
3615 | 
3616 | <Ada unqualified type specification> ::=
3617 |        CHAR <left paren> 1 <double period> <length> <right paren>
3618 |      | BIT <left paren> 1 <double period> <length> <right paren>
3619 |      | SMALLINT
3620 |      | INT
3621 |      | REAL
3622 |      | DOUBLE_PRECISION
3623 |      | SQLCODE_TYPE
3624 |      | SQLSTATE_TYPE
3625 |      | INDICATOR_TYPE
3626 | 
3627 | 19.4  <embedded SQL C program>
3628 | 
3629 | Function
3630 | 
3631 | Specify an <embedded SQL C program>.
3632 | 
3633 | Format
3634 | 
3635 | <embedded SQL C program> ::= !! See the Syntax Rules.
3636 | 
3637 | <C variable definition> ::=
3638 |        [ <C storage class> ]
3639 |        [ <C class modifier> ]
3640 |        <C variable specification>
3641 |      <semicolon>
3642 | 
3643 | <C variable specification> ::=
3644 |        <C numeric variable>
3645 |      | <C character variable>
3646 |      | <C derived variable>
3647 | 
3648 | <C storage class> ::=
3649 |        auto
3650 |      | extern
3651 |      | static
3652 | 
3653 | <C class modifier> ::= const | volatile
3654 | 
3655 | <C numeric variable> ::=
3656 |      { long | short | float | double }
3657 |        <C host identifier> [ <C initial value> ]
3658 |              [ { <comma> <C host identifier> [ <C initial value> ] }... ]
3659 | 
3660 | 
3661 | <C character variable> ::=
3662 |      char [ CHARACTER SET [ IS ] <character set specification> ]
3663 |        <C host identifier> <C array specification> [ <C initial value> ]
3664 | 
3665 |          [ { <comma> <C host identifier> <C array specification>
3666 |                   [ <C initial value> ] }... ]
3667 | 
3668 | <C array specification> ::=
3669 |      <left bracket> <length> <right bracket>
3670 | 
3671 | <C host identifier> ::= !! See the Syntax Rules.
3672 | 
3673 | <C derived variable> ::=
3674 |        <C VARCHAR variable>
3675 |      | <C bit variable>
3676 | 
3677 | <C VARCHAR variable> ::=
3678 |      VARCHAR [ CHARACTER SET [ IS ] <character set specification> ]
3679 |          <C host identifier> <C array specification> [ <C initial value> ]
3680 | 
3681 |            [ { <comma> <C host identifier> <C array specification>
3682 | 
3683 |                        [ <C initial value> ] }... ]
3684 | 
3685 | <C bit variable> ::=
3686 |      BIT <C host identifier> <C array specification> [ <C initial value> ]
3687 | 
3688 |        [ { <comma> <C host identifier> <C array specification>
3689 |                     [ <C initial value> ] }... ]
3690 | 
3691 | <C initial value> ::=
3692 |      <equals operator> <character representation>...
3693 | 
3694 | 19.5  <embedded SQL COBOL program>
3695 | 
3696 | Function
3697 | 
3698 | Specify an <embedded SQL COBOL program>.
3699 | 
3700 | Format
3701 | 
3702 | <embedded SQL COBOL program> ::= !! See the Syntax Rules.
3703 | 
3704 | <COBOL variable definition> ::=
3705 |      {01|77} <COBOL host identifier> <COBOL type specification>
3706 |        [ <character representation>... ] <period>
3707 | 
3708 | <COBOL host identifier> ::= !! See the Syntax Rules.
3709 | 
3710 | <COBOL type specification> ::=
3711 |        <COBOL character type>
3712 |      | <COBOL bit type>
3713 |      | <COBOL numeric type>
3714 |      | <COBOL integer type>
3715 | 
3716 | <COBOL character type> ::=
3717 |      [ CHARACTER SET [ IS ] <character set specification> ]
3718 |      { PIC | PICTURE } [ IS ] { X [ <left paren> <length> <right paren> ] }...
3719 | 
3720 | 
3721 | <COBOL bit type> ::=
3722 |      { PIC | PICTURE } [ IS ] { B [ <left paren> <length> <right paren> ] }...
3723 | 
3724 | 
3725 | <COBOL numeric type> ::=
3726 |      { PIC | PICTURE } [ IS ]
3727 |        S <COBOL nines specification>
3728 |      [ USAGE [ IS ] ] DISPLAY SIGN LEADING SEPARATE
3729 | 
3730 | <COBOL nines specification> ::=
3731 |        <COBOL nines> [ V [ <COBOL nines> ] ]
3732 |      | V <COBOL nines>
3733 | 
3734 | <COBOL integer type> ::=
3735 |        <COBOL computational integer>
3736 |      | <COBOL binary integer>
3737 | 
3738 | <COBOL computational integer> ::=
3739 |      { PIC | PICTURE } [ IS ] S<COBOL nines>
3740 |        [ USAGE [ IS ] ] { COMP | COMPUTATIONAL }
3741 | 
3742 | <COBOL binary integer> ::=
3743 |      { PIC | PICTURE } [ IS ] S<COBOL nines>
3744 |        [ USAGE [ IS ] ] BINARY
3745 | 
3746 | <COBOL nines> ::= { 9 [ <left paren> <length> <right paren> ] }...
3747 | 
3748 | 19.6  <embedded SQL Fortran program>
3749 | 
3750 | Function
3751 | 
3752 | Specify an <embedded SQL Fortran program>.
3753 | 
3754 | Format
3755 | 
3756 | <embedded SQL Fortran program> ::= !! See the Syntax Rules.
3757 | 
3758 | <Fortran variable definition> ::=
3759 |      <Fortran type specification>
3760 |      <Fortran host identifier> [ { <comma> <Fortran host identifier> }... ]
3761 | 
3762 | 
3763 | <Fortran host identifier> ::= !! See the Syntax Rules.
3764 | 
3765 | <Fortran type specification> ::=
3766 |        CHARACTER [ <asterisk> <length> ]
3767 |            [ CHARACTER SET [ IS ] <character set specification> ]
3768 |      | BIT [ <asterisk> <length> ]
3769 |      | INTEGER
3770 |      | REAL
3771 |      | DOUBLE PRECISION
3772 | 
3773 | 19.7  <embedded SQL MUMPS program>
3774 | 
3775 | Function
3776 | 
3777 | Specify an <embedded SQL MUMPS program>.
3778 | 
3779 | Format
3780 | 
3781 | <embedded SQL MUMPS program> ::= !! See the Syntax Rules.
3782 | 
3783 | <MUMPS variable definition> ::=
3784 |      { <MUMPS numeric variable> | <MUMPS character variable> }
3785 |      <semicolon>
3786 | 
3787 | <MUMPS character variable> ::=
3788 |      VARCHAR <MUMPS host identifier> <MUMPS length specification>
3789 |        [ { <comma> <MUMPS host identifier> <MUMPS length specification> }... ]
3790 | 
3791 | 
3792 | <MUMPS host identifier> ::= !! See the Syntax Rules.
3793 | 
3794 | <MUMPS length specification> ::=
3795 |      <left paren> <length> <right paren>
3796 | 
3797 | <MUMPS numeric variable> ::=
3798 |      <MUMPS type specification>
3799 |        <MUMPS host identifier> [ { <comma> <MUMPS host identifier> }... ]
3800 | 
3801 | 
3802 | <MUMPS type specification> ::=
3803 |        INT
3804 |      | DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
3805 | 
3806 |      | REAL
3807 | 
3808 | 19.8  <embedded SQL Pascal program>
3809 | 
3810 | Function
3811 | 
3812 | Specify an <embedded SQL Pascal program>.
3813 | 
3814 | Format
3815 | 
3816 | <embedded SQL Pascal program> ::= !! See the Syntax Rules.
3817 | 
3818 | <Pascal variable definition> ::=
3819 |      <Pascal host identifier> [ { <comma> <Pascal host identifier> }... ] <colon>
3820 | 
3821 |        <Pascal type specification> <semicolon>
3822 | 
3823 | <Pascal host identifier> ::= !! See the Syntax Rules.
3824 | 
3825 | <Pascal type specification> ::=
3826 |        PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket>
3827 | 
3828 |          OF CHAR
3829 |            [ CHARACTER SET [ IS ] <character set specification> ]
3830 |      | PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket>
3831 | 
3832 |          OF BIT
3833 |      | INTEGER
3834 |      | REAL
3835 |      | CHAR [ CHARACTER SET [ IS ] <character set specification> ]
3836 | 
3837 |      | BIT
3838 | 
3839 | 19.9  <embedded SQL PL/I program>
3840 | 
3841 | Function
3842 | 
3843 | Specify an <embedded SQL PL/I program>.
3844 | 
3845 | Format
3846 | 
3847 | <embedded SQL PL/I program> ::= !! See the Syntax Rules.
3848 | 
3849 | <PL/I variable definition> ::=
3850 |      {DCL | DECLARE}
3851 |         {   <PL/I host identifier>
3852 |           | <left paren> <PL/I host identifier>
3853 |                  [ { <comma> <PL/I host identifier> }... ] <right paren> }
3854 | 
3855 |      <PL/I type specification>
3856 |      [ <character representation>... ] <semicolon>
3857 | 
3858 | <PL/I host identifier> ::= !! See the Syntax Rules.
3859 | 
3860 | <PL/I type specification> ::=
3861 |        { CHAR | CHARACTER } [ VARYING ] <left paren><length><right paren>
3862 | 
3863 |            [ CHARACTER SET [ IS ] <character set specification> ]
3864 |      | BIT [ VARYING ] <left paren><length><right paren>
3865 |      | <PL/I type fixed decimal> <left paren> <precision>
3866 |            [ <comma> <scale> ] <right paren>
3867 |      | <PL/I type fixed binary> [ <left paren> <precision> <right paren> ]
3868 | 
3869 |      | <PL/I type float binary> <left paren> <precision> <right paren>
3870 | 
3871 | 
3872 | <PL/I type fixed decimal> ::=
3873 |        { DEC | DECIMAL } FIXED
3874 |      | FIXED { DEC | DECIMAL }
3875 | 
3876 | <PL/I type fixed binary> ::=
3877 |        { BIN | BINARY } FIXED
3878 |      | FIXED { BIN | BINARY }
3879 | 
3880 | <PL/I type float binary> ::=
3881 |        { BIN | BINARY } FLOAT
3882 |      | FLOAT { BIN | BINARY }
3883 | 
3884 | 
3885 | 20  Direct invocation of SQL
3886 | 
3887 | 
3888 | 
3889 | 20.1  <direct SQL statement>
3890 | 
3891 | Function
3892 | 
3893 | Specify direct execution of SQL.
3894 | 
3895 | Format
3896 | 
3897 | <direct SQL statement> ::=
3898 |      <directly executable statement> <semicolon>
3899 | 
3900 | <directly executable statement> ::=
3901 |        <direct SQL data statement>
3902 |      | <SQL schema statement>
3903 |      | <SQL transaction statement>
3904 |      | <SQL connection statement>
3905 |      | <SQL session statement>
3906 |      | <direct implementation-defined statement>
3907 | 
3908 | <direct SQL data statement> ::=
3909 |        <delete statement: searched>
3910 |      | <direct select statement: multiple rows>
3911 |      | <insert statement>
3912 |      | <update statement: searched>
3913 |      | <temporary table declaration>
3914 | 
3915 | <direct implementation-defined statement> ::= !!See the Syntax
3916 | Rules
3917 | 
3918 | 20.2  <direct select statement: multiple rows>
3919 | 
3920 | Function
3921 | 
3922 | Specify a statement to retrieve multiple rows from a specified
3923 | table.
3924 | 
3925 | Format
3926 | 
3927 | <direct select statement: multiple rows> ::=
3928 |      <query expression> [ <order by clause> ]
3929 | 


--------------------------------------------------------------------------------
/sql-overview.cabal:
--------------------------------------------------------------------------------
 1 | cabal-version:       >=1.10
 2 | 
 3 | name:                sql-overview
 4 | version:             0.1.0.0
 5 | build-type:          Simple
 6 | 
 7 | executable AddLinks
 8 |   main-is:             AddLinks.lhs
 9 |   build-depends:       base >=4 && <5
10 |   default-language:    Haskell2010
11 | 
12 | 
13 | executable GrammarToAsciidoc
14 |   main-is:             GrammarToAsciidoc.lhs
15 |   build-depends:       base >=4 && <5,
16 |                        regex-compat
17 |   default-language:    Haskell2010
18 | 


--------------------------------------------------------------------------------