匿名使用者
匿名使用者 發問時間: 電腦與網際網路其他:電腦 · 2 0 年前

vb高手們...救救我吧急急急急急急急急

http://tw.knowledge.yahoo.com/question/?qid=110506...

http://tw.knowledge.yahoo.com/question/?qid=110506...

http://tw.knowledge.yahoo.com/question/?qid=110506...

麻煩各位了....這有點像是重複發表......但情非得已

救救我吧 在過一個小時 就要宣布我的判期了......

真ㄉ很急 再一次ㄉ麻煩各位了.....一個上課不認真ㄉ白痴~~~嗚嗚~~~~

能解掉以上三題ㄉ...不但擁有上面每題各10分

還有這20分也是屬於你ㄉ了...各位高手們...救救我吧

已更新項目:

嗚嗚....救救我吧.....我等到快腿軟了.....看著時間一分一秒ㄉ消失.....各位vb高手們 救救我吧 不要不理我ㄚ~~~~

2 個已更新項目:

這位大大....我真ㄉ很感謝你...但這似乎不是答案= =

因為這是考試題目 所以應該沒有這麼長或原始

能不能麻煩你...到上面三個網址中幫我看...對不起啦

麻煩你了...

順便一提 有解答以上三個問題ㄉ....就來這解答一下 我會看是誰回答ㄉ較好 這20分就會給他了 謝謝各位大大ㄉ幫忙

小弟感激不盡

1 個解答

評分
  • 天淚
    Lv 4
    2 0 年前
    最佳解答

    <SQL terminal character> ::=

    <SQL language character>

    | <SQL embedded language character>

    <SQL language character> ::=

    <simple Latin letter>

    | <digit>

    | <SQL special character>

    <simple Latin letter> ::=

    <simple Latin upper case letter>

    | <simple Latin lower case letter>

    <simple Latin upper case letter> ::=

    A | B | C | D | E | F | G | H | I | J | K | L | M | N | O

    | P | Q | R | S | T | U | V | W | X | Y | Z

    <simple Latin lower case letter> ::=

    a | b | c | d | e | f | g | h | i | j | k | l | m | n | o

    | p | q | r | s | t | u | v | w | x | y | z

    <digit> ::=

    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

    <SQL special character> ::=

    <space>

    | <double quote>

    | <percent>

    | <ampersand>

    | <quote>

    | <left paren>

    | <right paren>

    | <asterisk>

    | <plus sign>

    | <comma>

    | <minus sign>

    | <period>

    | <solidus>

    | <colon>

    | <semicolon>

    | <less than operator>

    | <equals operator>

    | <greater than operator>

    | <question mark>

    | <underscore>

    | <vertical bar>

    <space> ::= !! <EMPHASIS>(使用中的字集所用的空白字元)

    <double quote> ::= "

    <percent> ::= %

    <ampersand> ::= &

    <quote> ::= '

    <left paren> ::= (

    <right paren> ::= )

    <asterisk> ::= *

    <plus sign> ::= +

    <comma> ::= ,

    <minus sign> ::= -

    <period> ::= .

    <solidus> ::= /

    <colon> ::= :

    <semicolon> ::= ;

    <less than operator> ::= <

    <equals operator> ::= =

    <greater than operator> ::= >

    <question mark> ::= ?

    <underscore> ::= _

    <vertical bar> ::= |

    <SQL embedded language character> ::=

    <left bracket>

    | <right bracket>

    <left bracket> ::= [

    <right bracket> ::= ]

    <token> ::=

    <nondelimiter token>

    | <delimiter token>

    <nondelimiter token> ::=

    <regular identifier>

    | <key word>

    | <unsigned numeric literal>

    | <national character string literal>

    | <bit string literal>

    | <hex string literal>

    <regular identifier> ::= <identifier body>

    <identifier body> ::=

    <identifier start> [ ( <underscore> | <identifier part> )... ]

    <identifier start> ::= <EMPHASIS>(!! 參看文法規則)

    <identifier part> ::=

    <identifier start>

    | <digit>

    <key word> ::=

    <reserved word>

    | <non-reserved word>

    <reserved word> ::=

    ABSOLUTE | ACTION | ADD | ALL

    | ALLOCATE | ALTER | AND

    | ANY | ARE

    | AS | ASC

    | ASSERTION | AT

    | AUTHORIZATION | AVG

    | BEGIN | BETWEEN | BIT | BIT_LENGTH

    | BOTH | BY

    | CASCADE | CASCADED | CASE | CAST

    | CATALOG

    | CHAR | CHARACTER | CHAR_LENGTH

    | CHARACTER_LENGTH | CHECK | CLOSE | COALESCE

    | COLLATE | COLLATION

    | COLUMN | COMMIT

    | CONNECT

    | CONNECTION | CONSTRAINT

    | CONSTRAINTS | CONTINUE

    | CONVERT | CORRESPONDING | COUNT | CREATE | CROSS

    | CURRENT

    | CURRENT_DATE | CURRENT_TIME

    | CURRENT_TIMESTAMP | CURRENT_USER | CURSOR

    | DATE | DAY | DEALLOCATE | DEC

    | DECIMAL | DECLARE | DEFAULT | DEFERRABLE

    | DEFERRED | DELETE | DESC | DESCRIBE | DESCRIPTOR

    | DIAGNOSTICS

    | DISCONNECT | DISTINCT | DOMAIN | DOUBLE | DROP

    | ELSE | END | END-EXEC | ESCAPE

    | EXCEPT | EXCEPTION

    | EXEC | EXECUTE | EXISTS

    | EXTERNAL | EXTRACT

    | FALSE | FETCH | FIRST | FLOAT | FOR

    | FOREIGN | FOUND | FROM | FULL

    | GET | GLOBAL | GO | GOTO

    | GRANT | GROUP

    | HAVING | HOUR

    | IDENTITY | IMMEDIATE | IN | INDICATOR

    | INITIALLY | INNER | INPUT

    | INSENSITIVE | INSERT | INT | INTEGER | INTERSECT

    | INTERVAL | INTO | IS

    | ISOLATION

    | JOIN

    | KEY

    | LANGUAGE | LAST | LEADING | LEFT

    | LEVEL | LIKE | LOCAL | LOWER

    | MATCH | MAX | MIN | MINUTE | MODULE

    | MONTH

    | NAMES | NATIONAL | NATURAL | NCHAR | NEXT | NO

    | NOT | NULL

    | NULLIF | NUMERIC

    | OCTET_LENGTH | OF

    | ON | ONLY | OPEN | OPTION | OR

    | ORDER | OUTER

    | OUTPUT | OVERLAPS

    | PAD | PARTIAL | POSITION | PRECISION | PREPARE

    | PRESERVE | PRIMARY

    | PRIOR | PRIVILEGES | PROCEDURE | PUBLIC

    | READ | REAL | REFERENCES | RELATIVE | RESTRICT

    | REVOKE | RIGHT

    | ROLLBACK | ROWS

    | SCHEMA | SCROLL | SECOND | SECTION

    | SELECT

    | SESSION | SESSION_USER | SET

    | SIZE | SMALLINT | SOME | SPACE | SQL | SQLCODE

    | SQLERROR | SQLSTATE

    | SUBSTRING | SUM | SYSTEM_USER

    | TABLE | TEMPORARY

    | THEN | TIME | TIMESTAMP

    | TIMEZONE_HOUR | TIMEZONE_MINUTE

    | TO | TRAILING | TRANSACTION

    | TRANSLATE | TRANSLATION | TRIM | TRUE

    | UNION | UNIQUE | UNKNOWN | UPDATE | UPPER | USAGE

    | USER | USING

    | VALUE | VALUES | VARCHAR | VARYING | VIEW

    | WHEN | WHENEVER | WHERE | WITH | WORK | WRITE

    | YEAR

    | ZONE

    <non-reserved word> ::=

    ADA

    | C | CATALOG_NAME

    | CHARACTER_SET_CATALOG | CHARACTER_SET_NAME

    | CHARACTER_SET_SCHEMA | CLASS_ORIGIN | COBOL | COLLATION_CATALOG

    | COLLATION_NAME | COLLATION_SCHEMA | COLUMN_NAME | COMMAND_FUNCTION

    | COMMITTED

    | CONDITION_NUMBER | CONNECTION_NAME | CONSTRAINT_CATALOG | CONSTRAINT_NAME

    | CONSTRAINT_SCHEMA | CURSOR_NAME

    | DATA | DATETIME_INTERVAL_CODE

    | DATETIME_INTERVAL_PRECISION | DYNAMIC_FUNCTION

    | FORTRAN

    | LENGTH

    | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | MORE | MUMPS

    | NAME | NULLABLE | NUMBER

    | PASCAL | PLI

    | REPEATABLE | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE

    | ROW_COUNT

    | SCALE | SCHEMA_NAME | SERIALIZABLE | SERVER_NAME | SUBCLASS_ORIGIN

    | TABLE_NAME | TYPE

    | UNCOMMITTED | UNNAMED

    <unsigned numeric literal> ::=

    <exact numeric literal>

    | <approximate numeric literal>

    <exact numeric literal> ::=

    <unsigned integer> [ <period> [ <unsigned integer> ] ]

    | <period> <unsigned integer>

    <unsigned integer> ::= <digit>...

    <approximate numeric literal> ::= <mantissa> E <exponent>

    <mantissa> ::= <exact numeric literal>

    <exponent> ::= <signed integer>

    <signed integer> ::= [ <sign> ] <unsigned integer>

    <sign> ::= <plus sign> | <minus sign>

    <national character string literal> ::=

    N <quote> [ <character representation>... ] <quote>

    [ ( <separator>... <quote> [ <character representation>... ] <quote> )... ]

    <character representation> ::=

    <nonquote character>

    | <quote symbol>

    <nonquote character> ::= !! <EMPHASIS>(!! 參看文法規則)

    <quote symbol> ::= <quote><quote>

    <separator> ::= ( <comment> | <space> | <newline> )...

    <comment> ::=

    <comment introducer> [ <comment character>... ] <newline>

    <comment introducer> ::= <minus sign><minus sign>[<minus sign>...]

    <comment character> ::=

    <nonquote character>

    | <quote>

    <newline> ::= !! <EMPHASIS>(實踐方法定義的行末指示)

    <bit string literal> ::=

    B <quote> [ <bit>... ] <quote>

    [ ( <separator>... <quote> [ <bit>... ] <quote> )... ]

    <bit> ::= 0 | 1

    <hex string literal> ::=

    X <quote> [ <hexit>... ] <quote>

    [ ( <separator>... <quote> [ <hexit>... ] <quote> )... ]

    <hexit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f

    <delimiter token> ::=

    <character string literal>

    | <date string>

    | <time string>

    | <timestamp string>

    | <interval string>

    | <delimited identifier>

    | <SQL special character>

    | <not equals operator>

    | <greater than or equals operator>

    | <less than or equals operator>

    | <concatenation operator>

    | <double period>

    | <left bracket>

    | <right bracket>

    <character string literal> ::=

    [ <introducer><character set specification> ]

    <quote> [ <character representation>... ] <quote>

    [ ( <separator>... <quote> [ <character representation>... ] <quote> )... ]

    <introducer> ::= <underscore>

    <character set specification> ::=

    <standard character repertoire name>

    | <implementation-defined character repertoire name>

    | <user-defined character repertoire name>

    | <standard universal character form-of-use name>

    | <implementation-defined universal character form-of-use name>

    <standard character repertoire name> ::= <character set name>

    <character set name> ::= [ <schema name> <period> ]

    <SQL language identifier>

    <schema name> ::=

    [ <catalog name> <period> ] <unqualified schema name>

    <catalog name> ::= <identifier>

    <identifier> ::=

    [ <introducer><character set specification> ] <actual identifier>

    <actual identifier> ::=

    <regular identifier>

    | <delimited identifier>

    <delimited identifier> ::=

    <double quote> <delimited identifier body> <double quote>

    <delimited identifier body> ::= <delimited identifier part>...

    <delimited identifier part> ::=

    <nondoublequote character>

    | <doublequote symbol>

    <nondoublequote character> ::= <EMPHASIS>(!! 參看文法規則)

    <doublequote symbol> ::= <double quote><double quote>

    <unqualified schema name> ::= <identifier>

    <SQL language identifier> ::=

    <SQL language identifier start>

    [ ( <underscore> | <SQL language identifier part> )... ]

    <SQL language identifier start> ::= <simple Latin letter>

    <SQL language identifier part> ::=

    <simple Latin letter>

    | <digit>

    <implementation-defined character repertoire name> ::=

    <character set name>

    <user-defined character repertoire name> ::= <character set name>

    <standard universal character form-of-use name> ::=

    <character set name>

    <implementation-defined universal character form-of-use name> ::=

    <character set name>

    <date string> ::=

    <quote> <date value> <quote>

    <date value> ::=

    <years value> <minus sign> <months value>

    <minus sign> <days value>

    <years value> ::= <datetime value>

    <datetime value> ::= <unsigned integer>

    <months value> ::= <datetime value>

    <days value> ::= <datetime value>

    <time string> ::=

    <quote> <time value> [ <time zone interval> ] <quote>

    <time value> ::=

    <hours value> <colon> <minutes value> <colon> <seconds value>

    <hours value> ::= <datetime value>

    <minutes value> ::= <datetime value>

    <seconds value> ::=

    <seconds integer value> [ <period> [ <seconds fraction> ] ]

    <seconds integer value> ::= <unsigned integer>

    <seconds fraction> ::= <unsigned integer>

    <time zone interval> ::=

    <sign> <hours value> <colon> <minutes value>

    <timestamp string> ::=

    <quote> <date value> <space> <time value>

    [ <time zone interval> ] <quote>

    <interval string> ::=

    <quote> ( <year-month literal> | <day-time literal> ) <quote>

    <year-month literal> ::=

    <years value>

    | [ <years value> <minus sign> ] <months value>

    <day-time literal> ::=

    <day-time interval>

    | <time interval>

    <day-time interval> ::=

    <days value>

    [ <space> <hours value> [ <colon> <minutes value>

    [ <colon> <seconds value> ] ] ]

    <time interval> ::=

    <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]

    | <minutes value> [ <colon> <seconds value> ]

    | <seconds value>

    <not equals operator> ::= <>

    <greater than or equals operator> ::= >=

    <less than or equals operator> ::= <=

    <concatenation operator> ::= ||

    <double period> ::= ..

    <module> ::=

    <module name clause>

    <language clause>

    <module authorization clause>

    [ <temporary table declaration>... ]

    <module contents>...

    <module name clause> ::=

    MODULE [ <module name> ]

    [ <module character set specification> ]

    <module name> ::= <identifier>

    <module character set specification> ::=

    NAMES ARE <character set specification>

    <language clause> ::=

    LANGUAGE <language name>

    <language name> ::=

    ADA | C | COBOL | FORTRAN | MUMPS | PASCAL | PLI

    <module authorization clause> ::=

    SCHEMA <schema name>

    | AUTHORIZATION <module authorization identifier>

    | SCHEMA <schema name>

    AUTHORIZATION <module authorization identifier>

    <module authorization identifier> ::=

    <authorization identifier>

    <authorization identifier> ::= <identifier>

    <temporary table declaration> ::=

    DECLARE LOCAL TEMPORARY TABLE

    <qualified local table name>

    <table element list>

    [ ON COMMIT ( PRESERVE | DELETE ) ROWS ]

    <qualified local table name> ::=

    MODULE <period> <local table name>

    <local table name> ::= <qualified identifier>

    <qualified identifier> ::= <identifier>

    <table element list> ::=

    <left paren> <table element> [ ( <comma> <table element> )... ] <right paren>

    <table element> ::=

    <column definition>

    | <table constraint definition>

    <column definition> ::=

    <column name> ( <data type> | <domain name> )

    [ <default clause> ]

    [ <column constraint definition>... ]

    [ <collate clause> ]

    <column name> ::= <identifier>

    <data type> ::=

    <character string type>

    [ CHARACTER SET <character set specification> ]

    | <national character string type>

    | <bit string type>

    | <numeric type>

    | <datetime type>

    | <interval type>

    <character string type> ::=

    CHARACTER [ <left paren> <length> <right paren> ]

    | CHAR [ <left paren> <length> <right paren> ]

    | CHARACTER VARYING <left paren> <length> <right paren>

    | CHAR VARYING <left paren> <length> <right paren>

    | VARCHAR <left paren> <length> <right paren>

    <length> ::= <unsigned integer>

    <national character string type> ::=

    NATIONAL CHARACTER [ <left paren> <length> <right paren> ]

    | NATIONAL CHAR [ <left paren> <length> <right paren> ]

    | NCHAR [ <left paren> <length> <right paren> ]

    | NATIONAL CHARACTER VARYING <left paren> <length> <right paren>

    | NATIONAL CHAR VARYING <left paren> <length> <right paren>

    | NCHAR VARYING <left paren> <length> <right paren>

    <bit string type> ::=

    BIT [ <left paren> <length> <right paren> ]

    | BIT VARYING <left paren> <length> <right paren>

    <numeric type> ::=

    <exact numeric type>

    | <approximate numeric type>

    <exact numeric type> ::=

    NUMERIC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]

    | DECIMAL [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]

    | DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]

    | INTEGER

    | INT

    | SMALLINT

    <precision> ::= <unsigned integer>

    <scale> ::= <unsigned integer>

    <approximate numeric type> ::=

    FLOAT [ <left paren> <precision> <right paren> ]

    | REAL

    | DOUBLE PRECISION

    <datetime type> ::=

    DATE

    | TIME [ <left paren> <time precision> <right paren> ]

    [ WITH TIME ZONE ]

    | TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]

    [ WITH TIME ZONE ]

    <time precision> ::= <time fractional seconds precision>

    <time fractional seconds precision> ::= <unsigned integer>

    <timestamp precision> ::= <time fractional seconds precision>

    <interval type> ::= INTERVAL <interval qualifier>

    <interval qualifier> ::=

    <start field> TO <end field>

    | <single datetime field>

    <start field> ::=

    <non-second datetime field>

    [ <left paren> <interval leading field precision> <right paren> ]

    <non-second datetime field> ::= YEAR | MONTH | DAY | HOUR

    | MINUTE

    <interval leading field precision> ::= <unsigned integer>

    <end field> ::=

    <non-second datetime field>

    | SECOND [ <left paren> <interval fractional seconds precision> <right paren> ]

    <interval fractional seconds precision> ::= <unsigned integer>

    <single datetime field> ::=

    <non-second datetime field>

    [ <left paren> <interval leading field precision> <right paren> ]

    | SECOND [ <left paren> <interval leading field precision>

    [ <comma> <interval fractional seconds precision> ] <right paren> ]

    <domain name> ::= <qualified name>

    <qualified name> ::=

    [ <schema name> <period> ] <qualified identifier>

    <default clause> ::=

    DEFAULT <default option>

    <default option> ::=

    <literal>

    | <datetime value function>

    | USER

    | CURRENT_USER

    | SESSION_USER

    | SYSTEM_USER

    | NULL

    <literal> ::=

    <signed numeric literal>

    | <general literal>

    <signed numeric literal> ::=

    [ <sign> ] <unsigned numeric literal>

    <general literal> ::=

    <character string literal>

    | <national character string literal>

    | <bit string literal>

    | <hex string literal>

    | <datetime literal>

    | <interval literal>

    <datetime literal> ::=

    <date literal>

    | <time literal>

    | <timestamp literal>

    <date literal> ::=

    DATE <date string>

    <time literal> ::=

    TIME <time string>

    <timestamp literal> ::=

    TIMESTAMP <timestamp string>

    <interval literal> ::=

    INTERVAL [ <sign> ] <interval string> <interval qualifier>

    <datetime value function> ::=

    <current date value function>

    | <current time value function>

    | <current timestamp value function>

    <current date value function> ::= CURRENT_DATE

    <current time value function> ::=

    CURRENT_TIME [ <left paren> <time precision> <right paren> ]

    <current timestamp value function> ::=

    CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]

    <column constraint definition> ::=

    [ <constraint name definition> ]

    <column constraint>

    [ <constraint attributes> ]

    <constraint name definition> ::= CONSTRAINT <constraint name>

    <constraint name> ::= <qualified name>

    <column constraint> ::=

    NOT NULL

    | <unique specification>

    | <references specification>

    | <check constraint definition>

    <unique specification> ::=

    UNIQUE | PRIMARY KEY

    <references specification> ::=

    REFERENCES <referenced table and columns>

    [ MATCH <match type> ]

    [ <referential triggered action> ]

    <referenced table and columns> ::=

    <table name> [ <left paren> <reference column list> <right paren> ]

    <table name> ::=

    <qualified name>

    | <qualified local table name>

    <reference column list> ::= <column name list>

    <column name list> ::=

    <column name> [ ( <comma> <column name> )... ]

    <match type> ::=

    FULL

    | PARTIAL

    <referential triggered action> ::=

    <update rule> [ <delete rule> ]

    | <delete rule> [ <update rule> ]

    <update rule> ::= ON UPDATE <referential action>

    <referential action> ::=

    CASCADE

    | SET NULL

    | SET DEFAULT

    | NO ACTION

    <delete rule> ::= ON DELETE <referential action>

    <check constraint definition> ::=

    CHECK

    <left paren> <search condition> <right paren>

    <search condition> ::=

    <boolean term>

    | <search condition> OR <boolean term>

    <boolean term> ::=

    <boolean factor>

    | <boolean term> AND <boolean factor>

    <boolean factor> ::=

    [ NOT ] <boolean test>

    <boolean test> ::=

    <boolean primary> [ IS [ NOT ]

    <truth value> ]

    <boolean primary> ::=

    <predicate>

    | <left paren> <search condition> <right paren>

    <predicate> ::=

    <comparison predicate>

    | <between predicate>

    | <in predicate>

    | <like predicate>

    | <null predicate>

    | <quantified comparison predicate>

    | <exists predicate>

    | <unique predicate>

    | <match predicate>

    | <overlaps predicate>

    <comparison predicate> ::=

    <row value constructor> <comp op>

    <row value constructor>

    <row value constructor> ::=

    <row value constructor element>

    | <left paren> <row value constructor list> <right paren>

    | <row subquery>

    <row value constructor element> ::=

    <value expression>

    | <null specification>

    | <default specification>

    <value expression> ::=

    <numeric value expression>

    | <string value expression>

    | <datetime value expression>

    | <interval value expression>

    <numeric value expression> ::=

    <term>

    | <numeric value expression> <plus sign> <term>

    | <numeric value expression> <minus sign> <term>

    <term> ::=

    <factor>

    | <term> <asterisk> <factor>

    | <term> <solidus> <factor>

    <factor> ::=

    [ <sign> ] <numeric primary>

    <numeric primary> ::=

    <value expression primary>

    | <numeric value function>

    <value expression primary> ::=

    <unsigned value specification>

    | <column reference>

    | <set function specification>

    | <scalar subquery>

    | <case expression>

    | <left paren> <value expression> <right paren>

    | <cast specification>

    <unsigned value specification> ::=

    <unsigned literal>

    | <general value specification>

    <unsigned literal> ::=

    <unsigned numeric literal>

    | <general literal>

    <general value specification> ::=

    <parameter specification>

    | <dynamic parameter specification>

    | <variable specification>

    | USER

    | CURRENT_USER

    | SESSION_USER

    | SYSTEM_USER

    | VALUE

    <parameter specification> ::=

    <parameter name> [ <indicator parameter> ]

    <parameter name> ::= <colon> <identifier>

    <indicator parameter> ::=

    [ INDICATOR ] <parameter name>

    <dynamic parameter specification> ::= <question mark>

    <variable specification> ::=

    <embedded variable name> [ <indicator variable> ]

    <embedded variable name> ::=

    <colon><host identifier>

    <host identifier> ::=

    <Ada host identifier>

    | <C host identifier>

    | <COBOL host identifier>

    | <Fortran host identifier>

    | <MUMPS host identifier>

    | <Pascal host identifier>

    | <PL/I host identifier>

    <Ada host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <C host identifier> ::=

    !! <EMPHASIS>(參看文法規則)

    <COBOL host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <Fortran host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <MUMPS host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <Pascal host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <PL/I host identifier> ::= !! <EMPHASIS>(參看文法規則)

    <indicator variable> ::=

    [ INDICATOR ] <embedded variable name>

    <column reference> ::= [ <qualifier> <period> ] <column name>

    <qualifier> ::=

    <table name>

    | <correlation name>

    <correlation name> ::= <identifier>

    <set function specification> ::=

    COUNT <left paren> <asterisk> <right paren>

    | <general set function>

    <general set function> ::=

    <set function type>

    <left paren> [ <set quantifier> ] <value expression> <right paren>

    <set function type> ::=

    AVG | MAX | MIN | SUM | COUNT

    <set quantifier> ::= DISTINCT | ALL

    <scalar subquery> ::= <subquery>

    <subquery> ::= <left paren> <query expression> <right paren>

    <query expression> ::=

    <non-join query expression>

    | <joined table>

    <non-join query expression> ::=

    <non-join query term>

    | <query expression> UNION [ ALL ]

    [ <corresponding spec> ] <query term>

    | <query expression> EXCEPT [ ALL ]

    [ <corresponding spec> ] <query term>

    <non-join query term> ::=

    <non-join query primary>

    | <query term> INTERSECT [ ALL ]

    [ <corresponding spec> ] <query primary>

    <non-join query primary> ::=

    <simple table>

    | <left paren> <non-join query expression> <right paren>

    <simple table> ::=

    <query specification>

    | <table value constructor>

    | <explicit table>

    <query specification> ::=

    SELECT [ <set quantifier> ] <select list> <table expression>

    <select list> ::=

    <asterisk>

    | <select sublist> [ ( <comma> <select sublist> )... ]

    <select sublist> ::=

    <derived column>

    | <qualifier> <period> <asterisk>

    <derived column> ::= <value expression> [ <as clause> ]

    <as clause> ::= [ AS ] <column name>

    <table expression> ::=

    <from clause>

    [ <where clause> ]

    [ <group by clause> ]

    [ <having clause> ]

    <from clause> ::= FROM <table reference>

    [ ( <comma> <table reference> )... ]

    <table reference> ::=

    <table name> [ [ AS ] <correlation name>

    [ <left paren> <derived column list> <right paren> ] ]

    | <derived table> [ AS ] <correlation name>

    [ <left paren> <derived column list> <right paren> ]

    | <joined table>

    <derived column list> ::= <column name list>

    <derived table> ::= <table subquery>

    <table subquery> ::= <subquery>

    <joined table> ::=

    <cross join>

    | <qualified join>

    | <left paren> <joined table> <right paren>

    <cross join> ::=

    <table reference> CROSS JOIN <table reference>

    <qualified join> ::=

    <table reference> [ NATURAL ] [ <join type> ] JOIN

    <table reference> [ <join specification> ]

    <join type> ::=

    INNER

    | <outer join type> [ OUTER ]

    | UNION

    <outer join type> ::=

    LEFT

    | RIGHT

    | FULL

    <join specification> ::=

    <join condition>

    | <named columns join>

    <join condition> ::= ON <search condition>

    <named columns join> ::=

    USING <left paren> <join column list> <right paren>

    <join column list> ::= <column name list>

    <where clause> ::= WHERE <search condition>

    <group by clause> ::=

    GROUP BY <grouping column reference list>

    <grouping column reference list> ::=

    <grouping column reference>

    [ ( <comma> <grouping column reference> )... ]

    <grouping column reference> ::=

    <column reference> [ <collate clause> ]

    <collate clause> ::= COLLATE <collation name>

    <collation name> ::= <qualified name>

    <having clause> ::= HAVING <search condition>

    <table value constructor> ::=

    VALUES <table value constructor list>

    <table value constructor list> ::=

    <row value constructor> [ ( <comma> <row value constructor> )... ]

    <explicit table> ::= TABLE <table name>

    <query term> ::=

    <non-join query term>

    | <joined table>

    <corresponding spec> ::=

    CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]

    <corresponding column list> ::= <column name list>

    <query primary> ::=

    <non-join query primary>

    | <joined table>

    <case expression> ::=

    <case abbreviation>

    | <case specification>

    <case abbreviation> ::=

    NULLIF <left paren> <value expression> <comma>

    <value expression> <right paren>

    | COALESCE <left paren> <value expression>

    ( <comma> <value expression> )... <right paren>

    <case specification> ::=

    <simple case>

    | <searched case>

    <simple case> ::=

    CASE <case operand>

    <simple when clause>...

    [ <else clause> ]

    END

    <case operand> ::= <value expression>

    <simple when clause> ::= WHEN <when operand> THEN <result>

    <when operand> ::= <value expression>

    <result> ::= <result expression> | NULL

    <result expression> ::= <value expression>

    <else clause> ::= ELSE <result>

    <searched case> ::=

    CASE

    <searched when clause>...

    [ <else clause> ]

    END

    <searched when clause> ::= WHEN <search condition> THEN <result>

    <cast specification> ::=

    CAST <left paren> <cast operand> AS

    <cast target> <right paren>

    <cast operand> ::=

    <value expression>

    | NULL

    <cast target> ::=

    <domain name>

    | <data type>

    <numeric value function> ::=

    <position expression>

    | <extract expression>

    | <length expression>

    <position expression> ::=

    POSITION <left paren> <character value expression>

    IN <character value expression> <right paren>

    <character value expression> ::=

    <concatenation>

    | <character factor>

    <concatenation> ::=

    <character value expression> <concatenation operator>

    <character factor>

    <character factor> ::=

    <character primary> [ <collate clause> ]

    <character primary> ::=

    <value expression primary>

    | <string value function>

    <string value function> ::=

    <character value function>

    | <bit value function>

    <character value function> ::=

    <character substring function>

    | <fold>

    | <form-of-use conversion>

    | <character translation>

    | <trim function>

    <character substring function> ::=

    SUBSTRING <left paren> <character value expression> FROM <start position>

    [ FOR <string length> ] <right paren>

    <start position> ::= <numeric value expression>

    <string length> ::= <numeric value expression>

    <fold> ::= ( UPPER | LOWER )

    <left paren> <character value expression> <right paren>

    <form-of-use conversion> ::=

    CONVERT <left paren> <character value expression>

    USING <form-of-use conversion name> <right paren>

    <form-of-use conversion name> ::= <qualified name>

    <character translation> ::=

    TRANSLATE <left paren> <character value expression>

    USING <translation name> <right paren>

    <translation name> ::= <qualified name>

    <trim function> ::=

    TRIM <left paren> <trim operands> <right paren>

    <trim operands> ::=

    [ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>

    <trim specification> ::=

    LEADING

    | TRAILING

    | BOTH

    <trim character> ::= <character value expression>

    <trim source> ::= <character value expression>

    <bit value function> ::=

    <bit substring function>

    <bit substring function> ::=

    SUBSTRING <left paren> <bit value expression> FROM <start position>

    [ FOR <string length> ] <right paren>

    <bit value expression> ::=

    <bit concatenation>

    | <bit factor>

    <bit concatenation> ::=

    <bit value expression> <concatenation operator> <bit factor>

    <bit factor> ::= <bit primary>

    <bit primary> ::=

    <value expression primary>

    | <string value function>

    <extract expression> ::=

    EXTRACT <left paren> <extract field>

    FROM <extract source> <right paren>

    <extract field> ::=

    <datetime field>

    | <time zone field>

    <datetime field> ::=

    <non-second datetime field>

    | SECOND

    <time zone field> ::=

    TIMEZONE_HOUR

    | TIMEZONE_MINUTE

    <extract source> ::=

    <datetime value expression>

    | <interval value expression>

    <datetime value expression> ::=

    <datetime term>

    | <interval value expression> <plus sign> <datetime term>

    | <datetime value expression> <plus sign> <interval term>

    | <datetime value expression> <minus sign> <interval term>

    <interval term> ::=

    <interval factor>

    | <interval term 2> <asterisk> <factor>

    | <interval term 2> <solidus> <factor>

    | <term> <asterisk> <interval factor>

    <interval factor> ::=

    [ <sign> ] <interval primary>

    <interval primary> ::=

    <value expression primary> [ <interval qualifier> ]

    <interval term 2> ::= <interval term>

    <interval value expression> ::=

    <interval term>

    | <interval value expression 1> <plus sign> <interval term 1>

    | <interval value expression 1> <minus sign> <interval term 1>

    | <left paren> <datetime value expression> <minus sign>

    <datetime term> <right paren> <interval qualifier>

    <interval value expression 1> ::= <interval value expression>

    <interval term 1> ::= <interval term>

    <datetime term> ::=

    <datetime factor>

    <datetime factor> ::=

    <datetime primary> [ <time zone> ]

    <datetime primary> ::=

    <value expression primary>

    | <datetime value function>

    <time zone> ::=

    AT <time zone specifier>

    <time zone specifier> ::=

    LOCAL

    | TIME ZONE <interval value expression>

    <length expression> ::=

    <char length expression>

    | <octet length expression>

    | <bit length expression>

    <char length expression> ::=

    ( CHAR_LENGTH | CHARACTER_LENGTH )

    <left paren> <string value expression> <right paren>

    <string value expression> ::=

    <character value expression>

    | <bit value expression>

    <octet length expression> ::=

    OCTET_LENGTH <left paren> <string value expression> <right paren>

    <bit length expression> ::=

    BIT_LENGTH <left paren> <string value expression> <right paren>

    <null specification> ::=

    NULL

    <default specification> ::=

    DEFAULT

    <row value constructor list> ::=

    <row value constructor element>

    [ ( <comma> <row value constructor element> )... ]

    <row subquery> ::= <subquery>

    <comp op> ::=

    <equals operator>

    | <not equals operator>

    | <less than operator>

    | <greater than operator>

    | <less than or equals operator>

    | <greater than or equals operator>

    <between predicate> ::=

    <row value constructor> [ NOT ] BETWEEN

    <row value constructor> AND <row value constructor>

    <in predicate> ::=

    <row value constructor>

    [ NOT ] IN <in predicate value>

    <in predicate value> ::=

    <table subquery>

    | <left paren> <in value list> <right paren>

    <in value list> ::=

    <value expression> ( <comma> <value expression> )...

    <like predicate> ::=

    <match value> [ NOT ] LIKE <pattern>

    [ ESCAPE <escape character> ]

    <match value> ::= <character value expression>

    <pattern> ::= <character value expression>

    <escape character> ::= <character value expression>

    <null predicate> ::= <row value constructor>

    IS [ NOT ] NULL

    <quantified comparison predicate> ::=

    <row value constructor> <comp op> <quantifier> <table subquery>

    <quantifier> ::= <all> | <some>

    <all> ::= ALL

    <some> ::= SOME | ANY

    <exists predicate> ::= EXISTS <table subquery>

    <unique predicate> ::= UNIQUE <table subquery>

    <match predicate> ::=

    <row value constructor> MATCH [ UNIQUE ]

    [ PARTIAL | FULL ] <table subquery>

    <overlaps predicate> ::=

    <row value constructor 1> OVERLAPS <row value constructor 2>

    <row value constructor 1> ::= <row value constructor>

    <row value constructor 2> ::= <row value constructor>

    <truth value> ::=

    TRUE

    | FALSE

    | UNKNOWN

    <constraint attributes> ::=

    <constraint check time> [ [ NOT ] DEFERRABLE ]

    | [ NOT ] DEFERRABLE [ <constraint check time> ]

    <constraint check time> ::=

    INITIALLY DEFERRED

    | INITIALLY IMMEDIATE

    <table constraint definition> ::=

    [ <constraint name definition> ]

    <table constraint> [ <constraint attributes> ]

    <table constraint> ::=

    <unique constraint definition>

    | <referential constraint definition>

    | <check constraint definition>

    <unique constraint definition> ::=

    <unique specification> even in SQL3)

    <unique specification>

    <left paren> <unique column list> <right paren>

    <unique column list> ::= <column name list>

    <referential constraint definition> ::=

    FOREIGN KEY

    <left paren> <referencing columns> <right paren>

    <references specification>

    <referencing columns> ::=

    <reference column list>

    <module contents> ::=

    <declare cursor>

    | <dynamic declare cursor>

    | <procedure>

    <declare cursor> ::=

    DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR

    FOR <cursor specification>

    <cursor name> ::= <identifier>

    <cursor specification> ::=

    <query expression> [ <order by clause> ]

    [ <updatability clause> ]

    <order by clause> ::=

    ORDER BY <sort specification list>

    <sort specification list> ::=

    <sort specification> [ ( <comma> <sort specification> )... ]

    <sort specification> ::=

    <sort key> [ <collate clause> ] [ <ordering specification> ]

    <sort key> ::=

    <column name>

    | <unsigned integer>

    <ordering specification> ::= ASC | DESC

    <updatability clause> ::=

    FOR

    ( READ ONLY |

    UPDATE [ OF <column name list> ] )

    <dynamic declare cursor> ::=

    DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR

    FOR <statement name>

    <statement name> ::= <identifier>

    <procedure> ::=

    PROCEDURE <procedure name>

    <parameter declaration list> <semicolon>

    <SQL procedure statement> <semicolon>

    <procedure name> ::= <identifier>

    <parameter declaration list> ::=

    <left paren> <parameter declaration>

    [ ( <comma> <parameter declaration> )... ] <right paren>

    | <parameter declaration>...

    <parameter declaration> ::=

    <parameter name> <data type>

    | <status parameter>

    <status parameter> ::=

    SQLCODE | SQLSTATE

    <SQL procedure statement> ::=

    <SQL schema statement>

    | <SQL data statement>

    | <SQL transaction statement>

    | <SQL connection statement>

    | <SQL session statement>

    | <SQL dynamic statement>

    | <SQL diagnostics statement>

    <SQL schema statement> ::=

    <SQL schema definition statement>

    | <SQL schema manipulation statement>

    <SQL schema definition statement> ::=

    <schema definition>

    | <table definition>

    | <view definition>

    | <grant statement>

    | <domain definition>

    | <character set definition>

    | <collation definition>

    | <translation definition>

    | <assertion definition>

    <schema definition> ::=

    CREATE SCHEMA <schema name clause>

    [ <schema character set specification> ]

    [ <schema element>... ]

    <schema name clause> ::=

    <schema name>

    | AUTHORIZATION <schema authorization identifier>

    | <schema name> AUTHORIZATION

    <schema authorization identifier>

    <schema authorization identifier> ::=

    <authorization identifier>

    <schema character set specification> ::=

    DEFAULT CHARACTER

    SET <character set specification>

    <schema element> ::=

    <domain definition>

    | <table definition>

    | <view definition>

    | <grant statement>

    | <assertion definition>

    | <character set definition>

    | <collation definition>

    | <translation definition>

    <domain definition> ::=

    CREATE DOMAIN <domain name>

    [ AS ] <data type>

    [ <default clause> ]

    [ <domain constraint>... ]

    [ <collate clause> ]

    <domain constraint> ::=

    [ <constraint name definition> ]

    <check constraint definition> [ <constraint attributes> ]

    <table definition> ::=

    CREATE [ ( GLOBAL | LOCAL ) TEMPORARY ] TABLE

    <table name>

    <table element list>

    [ ON COMMIT ( DELETE | PRESERVE ) ROWS ]

    <view definition> ::=

    CREATE VIEW <table name> [ <left paren> <view column list>

    <right paren> ]

    AS <query expression>

    [ WITH [ <levels clause> ] CHECK OPTION ]

    <view column list> ::= <column name list>

    <levels clause> ::=

    CASCADED | LOCAL

    <grant statement> ::=

    GRANT <privileges> ON <object name>

    TO <grantee> [ ( <comma> <grantee> )... ]

    [ WITH GRANT OPTION ]

    <privileges> ::=

    ALL PRIVILEGES

    | <action list>

    <action list> ::= <action> [ ( <comma> <action> )... ]

    <action> ::=

    SELECT

    | DELETE

    | INSERT [ <left paren> <privilege column list> <right paren> ]

    | UPDATE [ <left paren> <privilege column list> <right paren> ]

    | REFERENCES [ <left paren> <privilege column list> <right paren> ]

    | USAGE

    <privilege column list> ::= <column name list>

    <object name> ::=

    [ TABLE ] <table name>

    | DOMAIN <domain name>

    | COLLATION <collation name>

    | CHARACTER SET <character set name>

    | TRANSLATION <translation name>

    <grantee> ::=

    PUBLIC

    | <authorization identifier>

    <assertion definition> ::=

    CREATE ASSERTION <constraint name> <assertion check>

    [ <constraint attributes> ]

    <assertion check> ::=

    CHECK

    <left paren> <search condition> <right paren>

    <character set definition> ::=

    CREATE CHARACTER SET <character set name>

    [ AS ]

    <character set source>

    [ <collate clause> | <limited collation definition> ]

    <character set source> ::=

    GET <existing character set name>

    <existing character set name> ::=

    <standard character repertoire name>

    | <implementation-defined character repertoire name>

    | <schema character set name>

    <schema character set name> ::= <character set name>

    <limited collation definition> ::=

    COLLATION FROM <collation source>

    <collation source> ::=

    <collating sequence definition>

    | <translation collation>

    <collating sequence definition> ::=

    <external collation>

    | <schema collation name>

    | DESC <left paren> <collation name> <right paren>

    | DEFAULT

    <external collation> ::=

    EXTERNAL <left paren> <quote> <external collation name> <quote> <right paren>

    <external collation name> ::=

    <standard collation name>

    | <implementation-defined collation name>

    <standard collation name> ::= <collation name>

    <implementation-defined collation name> ::= <collation name>

    <schema collation name> ::= <collation name>

    <translation collation> ::=

    TRANSLATION <translation name>

    [ THEN COLLATION <collation name> ]

    <collation definition> ::=

    CREATE COLLATION <collation name> FOR

    <character set specification>

    FROM <collation source>

    [ <pad attribute> ]

    <pad attribute> ::=

    NO PAD

    | PAD SPACE

    <translation definition> ::=

    CREATE TRANSLATION <translation name>

    FOR <source character set specification>

    TO <target character set specification>

    FROM <translation source>

    <source character set specification> ::= <character set specification>

    <target character set specification> ::= <character set specification>

    <translation source> ::=

    <translation specification>

    <translation specification> ::=

    <external translation>

    | IDENTITY

    | <schema translation name>

    <external translation> ::=

    EXTERNAL <left paren> <quote> <external translation name> <quote> <right paren>

    <external translation name> ::=

    <standard translation name>

    | <implementation-defined translation name>

    <standard translation name> ::= <translation name>

    <implementation-defined translation name> ::= <translation name>

    <schema translation name> ::= <translation name>

    <SQL schema manipulation statement> ::=

    <drop schema statement>

    | <alter table statement>

    | <drop table statement>

    | <drop view statement>

    | <revoke statement>

    | <alter domain statement>

    | <drop domain statement>

    | <drop character set statement>

    | <drop collation statement>

    | <drop translation statement>

    | <drop assertion statement>

    <drop schema statement> ::=

    DROP SCHEMA <schema name> <drop behavior>

    <drop behavior> ::= CASCADE | RESTRICT

    <alter table statement> ::=

    ALTER TABLE <table name> <alter table action>

    <alter table action> ::=

    <add column definition>

    | <alter column definition>

    | <drop column definition>

    | <add table constraint definition>

    | <drop table constraint definition>

    <add column definition> ::=

    ADD [ COLUMN ] <column definition>

    <alter column definition> ::=

    ALTER [ COLUMN ] <column name> <alter column action>

    <alter column action> ::=

    <set column default clause>

    | <drop column default clause>

    <set column default clause> ::=

    SET <default clause>

    <drop column default clause> ::=

    DROP DEFAULT

    <drop column definition> ::=

    DROP [ COLUMN ] <column name> <drop behavior>

    <add table constraint definition> ::=

    ADD <table constraint definition>

    <drop table constraint definition> ::=

    DROP CONSTRAINT <constraint name> <drop behavior>

    <drop table statement> ::=

    DROP TABLE <table name> <drop behavior>

    <drop view statement> ::=

    DROP VIEW <table name> <drop behavior>

    <revoke statement> ::=

    REVOKE [ GRANT OPTION FOR ]

    <privileges>

    ON <object name>

    FROM <grantee> [ ( <comma> <grantee> )... ] <drop behavior>

    <alter domain statement> ::=

    ALTER DOMAIN <domain name> <alter domain action>

    <alter domain action> ::=

    <set domain default clause>

    | <drop domain default clause>

    | <add domain constraint definition>

    | <drop domain constraint definition>

    <set domain default clause> ::= SET <default clause>

    <drop domain default clause> ::= DROP DEFAULT

    <add domain constraint definition> ::=

    ADD <domain constraint>

    <drop domain constraint definition> ::=

    DROP CONSTRAINT <constraint name>

    <drop domain statement> ::=

    DROP DOMAIN <domain name> <drop behavior>

    <drop character set statement> ::=

    DROP CHARACTER SET <character set name>

    <drop collation statement> ::=

    DROP COLLATION <collation name>

    <drop translation statement> ::=

    DROP TRANSLATION <translation name>

    <drop assertion statement> ::=

    DROP ASSERTION <constraint name>

    <SQL data statement> ::=

    <open statement>

    | <fetch statement>

    | <close statement>

    | <select statement: single row>

    | <SQL data change statement>

    <open statement> ::=

    OPEN <cursor name>

    <fetch statement> ::=

    FETCH [ [ <fetch orientation> ] FROM ]

    <cursor name> INTO <fetch target list>

    <fetch orientation> ::=

    NEXT

    | PRIOR

    | FIRST

    | LAST

    | ( ABSOLUTE | RELATIVE ) <simple value specification>

    <simple value specification> ::=

    <parameter name>

    | <embedded variable name>

    | <literal>

    <fetch target list> ::=

    <target specification> [ ( <comma> <target specification> )... ]

    <target specification> ::=

    <parameter specification>

    | <variable specification>

    <close statement> ::=

    CLOSE <cursor name>

    <select statement: single row> ::=

    SELECT [ <set quantifier> ] <select list>

    INTO <select target list>

    <table expression>

    <select target list> ::=

    <target specification> [ ( <comma> <target specification> )... ]

    <SQL data change statement> ::=

    <delete statement: positioned>

    | <delete statement: searched>

    | <insert statement>

    | <update statement: positioned>

    | <update statement: searched>

    <delete statement: positioned> ::=

    DELETE FROM <table name>

    WHERE CURRENT OF <cursor name>

    <delete statement: searched> ::=

    DELETE FROM <table name>

    [ WHERE <search condition> ]

    <insert statement> ::=

    INSERT INTO <table name>

    <insert columns and source>

    <insert columns and source> ::=

    [ <left paren> <insert column list> <right paren> ]

    <query expression>&l

還有問題?馬上發問,尋求解答。