package SQL2Secondo; import java_cup10.runtime.*; import SecExceptions.*; import Ext_Tools.*; import java.sql.SQLWarning; import Utilities.WarningContainer; //import Verbindungstest.TestReporter; //needs to be chucked out parser code {: public void report_error(String message, Object info) { } public void unrecovered_syntax_error(Symbol cur_token) throws Exception { done_parsing(); throw new SyntaxException((String) cur_token.value); } :} action code {: boolean inSquareBrackets = false; // in case no class from Ext_Tool is used it is set if sqare bracket are needed for Secondo SQL boolean FromError = false; // in case syntax is correct but cannot be used in a from-clause boolean SelectListError = false; // in case syntax is correct but cannot be used in a select-clause boolean useAsExpr = false; // is true in case an alias is needed boolean SecondoSubQuery = false; // turns true if a subquery is used which is supported in secondo boolean SubqueryInUse = false; // turns true and stays true if a subquery is in use. SecondoSubQuery // is turned into false again once it is recognized as a true SecondoSubquery boolean QualifierInUse = false; // used to detect whether a qualifier has been used boolean RVCListInUse = false; // Secondo only allows RowValueConstructor-Lists inside insert-clauses boolean insertError = false; // is set to true, in case an insert-construct is not allowed in Secondo SQLWarning warning; // to transport SQL-Warnings to the driverset String PreResult; QueryClause PreQuery; // variable is used to pepare the Query before it is assigned to the NON-Terminal public void raise_Error(String message) throws Exception { // Error if syntax correct but not supported in Secondo throw new NotSuppException(message); } public void raise_GeneralError(String message) throws Exception { // Error if incorrect syntax is not recognized by parser throw new SecServerException(message); } private void setNextWarning(String message) { if (this.warning == null) this.warning = WarningContainer.getInstance(); this.warning.setNextWarning(new SQLWarning(message)); } String getUniqueName() { //provides a unique name for an alias return "myatt"+ErrorCodes.UNumber++; } :} /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!! Terminal definition !!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** TERMINALS *** terminal CREATE, TABLE, INDEX, INSERT_INTO, DELETE_FROM,SELECT, DISTINCT, AS, INDEXTYPE; terminal DROP_TABLE, UPDATE, SET, CASCADE, RESTRICT, BTREE, RTREE, HASH; terminal FROM, TO, WHERE, GROUP_BY, HAVING, ORDER_BY, COLLATE; terminal COUNT, MIN, MAX, SUM, AVG, ALL, SOME, ANY; terminal CONCAT_OP; terminal CASE, WHEN, THEN, ELSE, NULLIF, COALESCE, CAST; terminal VALUES; terminal POSITION, CHAR_LENGTH, CHARACTER_LENGTH, BIT_LENGTH, OCTET_LENGTH, EXTRACT; terminal SUBSTRING, UPPER, LOWER, FOR, CONVERT, TRANSLATE, TRIM, LEADING, TRAILING, BOTH; terminal EQUAL, NOT_EQUAL, LESS, LESS_EQUAL, GREATER, GREATER_EQUAL; terminal OR, AND, IS, NOT, BETWEEN, IN, LIKE, ESCAPE, EXISTS, TRUE, FALSE, UNKNOWN; terminal EXCEPT, CORRESPONDING, BY, INTERSECT; terminal MATCH, OVERLAPS, UNIQUE, PARTIAL; terminal CROSS, JOIN, FULL, UNION,/*INNER, LEFT, RIGHT, OUTER, NATURAL,*/ ON, USING; terminal INT, REAL, BOOL, STRING, CHAR, CHARACTER, DATE, ASC, DESC; terminal LPARENT, RPARENT, COMMA, DOT, QUESTIONMARK, ASTERISK, PLUS, MINUS, SOLIDUS; terminal CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP, AT, TIME_ZONE, LOCAL; terminal YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, TIMEZONE_HOUR, TIMEZONE_MINUTE; terminal USER, CURRENT_USER, SESSION_USER, SYSTEM_USER, VALUE, INDICATOR; //Not supported terminal FIRST; terminal String ID, ENL, ANL, PAR_VAR_NAME, TYPE_NAME, UNSIGNED_INT, JOIN_TYPE, A_STRING; // TYPE_NAME is "CHARACTER STRING TYPE", "NATIONAL CHARACTER STRING TYPE", "BIT STRING TYPE", // "NUMERIC TYPE", "DATETIME TYPE" or "INTERVAL TYPE". // *** NON TERMINALS *** non terminal SOLUTION, SYSTEM_INFO; //for repetitions like X [{comma X}...] non terminal VALUE_EXPR_LIST; non terminal String CHECK_CONSTR_DEF, UNIQUE_SPEC, REF_SPEC, REF_TAB_COL, COL_CONSTR_DEF; non terminal String CONSTR_NAME_DEF, COL_CONSTR, UNI_CONSTR_DEF, REF_CONSTR_DEF, TAB_CONSTR; non terminal String TAB_CONSTR_DEF, DROP_TAB_CONSTR_DEF, ADD_TAB_CONSTR_DEF, DROP_COL_DEF; non terminal String DEFAULT_OPTION, DEFAULT_CLAUSE, COL_CONSTR_EXPR_2, ALTER_COL_ACTION; non terminal String ALTER_COL_DEF, ADD_COL_DEF, ALTER_TABLE, ALTER_TAB_ACTION; non terminal String CREATE_QUERY, INSERT_CLAUSE, DELETE_CLAUSE, DROP_CLAUSE, UPDATE_CLAUSE; non terminal String QUALNAME, DATATYPE, COLUMN_DEF, DOMAINNAME, COLUMN_NAME_LIST; non terminal String SET_CLAUSE, UPDATE_SOURCE, DISTINCT_CLAUSE, UNSIGNED_LITERAL, GEN_VALUE_SPEC; non terminal String BOOLEAN_VALUE_EXPR; non terminal String PARAM_SPEC, UNSIGNED_NUM_LITERAL, GENERAL_LITERAL, SIGNED_NUM_LITERAL, LITERAL; non terminal String COLUMN_REF, TABLE_ELEM, TABLE_ELEM_LIST; non terminal String SORT_KEY, ORDER_SPEC; non terminal String INS_COL_AND_SOU, INS_COL_LIST; non terminal String UNSIGNED_VALUE_SPEC, SET_FUN_SPEC, SET_FUN_TYPE; non terminal String JOINED_TABLE, JOIN_SPEC; non terminal String DERIVED_COLUMN_LIST, CORR_SPEC; non terminal String TRUTH_VALUE; non terminal String IN_VALUE_LIST; non terminal String COMP_OP, QUANTIFIER, SIGN; non terminal String CORRESPONDING_SPEC; non terminal String TABLE_CON_LIST; non terminal String TABLE_EXPR, AS_CLAUSE, HAVING_CLAUSE; non terminal String DATETIME_VALUE_EXPR, DATETIME_PRIM, DATETIME_FACTOR, TIMEZONE, TIMEZONE_SPEC; non terminal String DATETIME_TERM, DATETIME_VALUE_FUN, TIME_PRECISION; non terminal String INTERVAL_VALUE_EXPR, INTERVAL_TERM, INTERVAL_FACTOR, INTERVAL_PRIM, INTERVAL_QUAL; non terminal String SINGLE_DT_FIELD, NON_SECOND_DT_FIELD, END_FIELD; //for Options [] non terminal String ESC_EXPR, UNIQUE_EXPR, PAR_FULL_EXPR, UNION_EXCEPT_EXPR, ALL_EXPR; non terminal String CORR_BY_EXPR, CORR_SPEC_EXPR, FOR_EXPR, COLLATE_CLAUSE, UP_LOW_EXPR; non terminal String TIME_PRECISION_EXPR, INTERVAL_QUAL_EXPR, CHAR_L_EXPR, NOT_EXPR, COLUMN_EXPR; non terminal String CIOPTIONS, COL_EXPR, CITYPE_EXPR; non terminal GeneralList COL_CONSTR_EXPR, TAB_CONSTR_EXPR; non terminal GeneralList SET_CLAUSE_LIST; non terminal SimpleValue VALUE_EXPR_PRIMARY, NUMERIC_PRIMARY, FACTOR; non terminal ValueList TERM; non terminal ValueExpr VALUE_EXPR, NUMERIC_VALUE_EXPR, ROW_VALUE_CON_ELEM; non terminal ValueExprList ROW_VALUE_CON_LIST, ROW_VALUE_CON ; non terminal SelectElement SELECT_SUBLIST; non terminal SelectList SELECT_SLIST_EXPR; non terminal SelectClause SELECT_LIST; non terminal TableElement TABLE_REF; non terminal TableClause FROM_CLAUSE, TABLE_REF_EXPR; non terminal WhereElement PREDICATE, BOOL_PRIM, BOOL_FACTOR, BOOL_TEST; non terminal WhereList BOOL_TERM; non terminal WhereClause SEARCH_COND, WHERE_CLAUSE; non terminal QueryClause QUERY_SPEC, SUBQUERY, IN_PRED_VALUE; //QUERY_SPEC stands for select_query non terminal GroupElement GROUP_COL_REF; non terminal GroupClause GROUP_BY_CLAUSE, GROUP_COL_REF_LIST; non terminal OrderElement SORT_SPEC; non terminal OrderClause ORDER_BY_CLAUSE, SORT_SPEC_LIST; non terminal InsertElement SIMPLE_TABLE, QUERY_EXPR, NON_JOIN_QT, QUERY_TERM, QUERY_PRIM, NON_JOIN_QE, NON_JOIN_QP; // *** NOT SUPPORTED TERMINALS *** terminal WHERE_CURRENT_OF, DEFAULT, NULL, REFERENCES, CHECK, PRIM_KEY, CONSTRAINT; terminal FOREIGN_KEY, DROP, ADD, ALTER, COLUMN, FULLTEXT, SPATIAL; terminal String DATE_VALUE; // *** NOT SUPPORTET NON TERMINALS *** non terminal CASE_EXPR, CASE_ABBR, CASE_SPEC; non terminal SIM_WHEN_CLAUSE, ELSE_CLAUSE, RESULT_EXPR; // RESULT IS RESERVED non terminal CAST_SPEC, CAST_OP, CAST_TARGET; non terminal NUMERIC_VALUE_FUN, POS_EXPR, EXTRACT_EXPR, EXTRACT_FIELD, EXTRACT_SOURCE; non terminal DATETIME_FIELD, TIMEZONE_FIELD, LENGTH_EXPR; non terminal STRING_VALUE_EXPR, CHAR_VALUE_EXPR, BIT_VALUE_EXPR, STRING_VALUE_FUN, CHAR_VALUE_FUN; non terminal BIT_VALUE_FUN, CHAR_PRIM, CHAR_FACTOR, CONCAT, BIT_CONCAT, BIT_FACTOR, BIT_PRIM; non terminal CHAR_SUBSTR_FUN, FOLD, F_O_U_CONV, CHAR_TRANSL, TRIM_FUN, TRIM_OP, TRIM_SPEC, TRIM_CHAR; non terminal DROP_BEHAVIOUR; /* PRECEDENCE */ precedence left JOIN_TYPE; precedence left ON, USING; precedence left CROSS, JOIN, UNION/*NATURAL, INNER, LEFT, OUTER, RIGHT, FULL*/; //precedence left EQUAL, NOT_EQUAL, LESS, LESS_EQUAL, GREATER, GREATER_EQUAL, NOT, BETWEEN, IN, MATCH, OVERLAPS; precedence left LPARENT, RPARENT; precedence left NOT, COMMA; precedence left PLUS, MINUS; precedence right WHERE; /*** GRAMMAR ***/ SOLUTION ::= CREATE_QUERY:cq {: Translator.TrOutput = new completeAnswer(cq, false); :} | QUERY_SPEC:qc {: PreResult = qc.getQueryExpression(); if (PreResult.equals("-1")) raise_Error("There is an error with the qualifiers. This usage of a Select-Clause "); Translator.TrOutput = new completeAnswer(qc.getShadowList(),PreResult,SubqueryInUse); :} | INSERT_CLAUSE:ic {: Translator.TrOutput = new completeAnswer(ic, SubqueryInUse); :} | DELETE_CLAUSE:dc {: Translator.TrOutput = new completeAnswer(dc, false); :} | DROP_CLAUSE:drc {: Translator.TrOutput = new completeAnswer(drc, false); :} | UPDATE_CLAUSE:uc {: Translator.TrOutput = new completeAnswer(uc, false); :} | ALTER_TABLE:at {: Translator.TrOutput = new completeAnswer(at, false); :} //{: raise_Error("Alter-Table-statements "); :} ; /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!! DDL DEFINITION !!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** Definition of CREATE_QUERY *** //To create a query or an index CREATE_QUERY ::= CREATE TABLE QUALNAME:TabName LPARENT TABLE_ELEM_LIST:CoLi RPARENT {: String PreResult = CoLi; if (inSquareBrackets) {inSquareBrackets = false; PreResult = "[" + PreResult + "]";} RESULT = "create table "+TabName+" columns " + PreResult; :} | CREATE CIOPTIONS INDEX ID:indexname CITYPE_EXPR:indextype ON ID:tablename LPARENT COL_EXPR:col RPARENT {: setNextWarning("The name of the index is automatically changed into 'tablename_columnname_indextype'!"); RESULT = "create index on " + tablename + " columns " + col + indextype; :}; TABLE_ELEM_LIST ::= TABLE_ELEM:te {: RESULT = te; :} | TABLE_ELEM:te COMMA TABLE_ELEM_LIST:tel {: inSquareBrackets = true; RESULT = te + ", " + tel; :}; TABLE_ELEM ::= COLUMN_DEF:co {: RESULT = co; :} | TAB_CONSTR_DEF:tcd {: raise_Error("Constraints in a table definition "); :}; // column constraints would have to be added here COLUMN_DEF ::= ID:SpName DATATYPE:DaName DEFAULT_CLAUSE:dc COL_CONSTR_EXPR_2:cce {: if (dc != "") raise_Error("A default_clause in a column definition "); if (cce != "") raise_Error("Constraints in a column definition "); RESULT = SpName + ":" + DaName + cce; :} | ID:SpName DOMAINNAME:DName {: raise_Error("The column definition: " + SpName + " " + DName); :} ; COLUMN_NAME_LIST ::= ID:co {: RESULT = co; :} | ID:co COMMA COLUMN_NAME_LIST:cnl {: RESULT = co + ", " + cnl; :}; // new datatypes need to be added here DATATYPE ::= INT {: RESULT = "int"; :} | REAL {: RESULT = "real"; :} | BOOL {: RESULT = "bool"; :} | STRING {: RESULT = "string"; :} | DATE {: raise_Error("The datatype date "); :}; DOMAINNAME ::= ID:id {: RESULT = id; :} |ID:id1 DOT ID:id2 {: RESULT = id1+"."+id2; :}; CIOPTIONS ::= UNIQUE {: raise_GeneralError("create index is not supported by SQL92. Secondo partly adapts the version of mySQL but unique is not supported!"); :} | FULLTEXT {: raise_GeneralError("create index is not supported by SQL92. Secondo partly adapts the version of mySQL but fulltext is not supported!"); :} | SPATIAL {: raise_GeneralError("create index is not supported by SQL92. Secondo partly adapts the version of mySQL but spatial is not supported!"); :} |; // index type for CREATE INDEX CITYPE_EXPR ::= USING BTREE {: RESULT = " indextype btree "; :} | USING RTREE {: RESULT = " indextype rtree "; :} | USING HASH {: RESULT = " indextype hash "; :} | {: RESULT = ""; :}; COL_EXPR ::= ID:columnname {: RESULT = columnname; :} | ID COMMA COL_EXPR {: raise_GeneralError("create index is not supported by SQL92. Secondo partly adapts the version of mySQL but creating an index on more than one column is not supported!"); :}; // *** Definition of CREATE_QUERY ends here *** // *** DEFINITION OF ALTER TABLE *** ALTER_TABLE ::= ALTER TABLE QUALNAME:qn ALTER_TAB_ACTION:atb {: RESULT = "altertable;" + qn + atb; :}; //{: RESULT = "alter table " + qn + " " + atb; :}; ALTER_TAB_ACTION ::= ADD_COL_DEF:acd {: RESULT = acd; :} | ALTER_COL_DEF:alcd {: RESULT = alcd; :} | DROP_COL_DEF:dcd {: RESULT = dcd; :} | ADD_TAB_CONSTR_DEF:atcd {: RESULT = atcd; :} | DROP_TAB_CONSTR_DEF:dtcd {: RESULT = dtcd; :}; ADD_COL_DEF ::= ADD COLUMN_EXPR:ce COLUMN_DEF:co {: int PosColon = co.indexOf(":"); String CoName = co.substring(0,PosColon); String CoDatatype = co.substring(PosColon+1); RESULT = ";add;"+CoName+";"+CoDatatype; :}; ALTER_COL_DEF ::= ALTER COLUMN_EXPR:ce ID:id ALTER_COL_ACTION:aca {: raise_Error("alter table alter column "); :}; ALTER_COL_ACTION ::= SET DEFAULT_CLAUSE:dc {: RESULT = "set " + dc; :} | DROP DEFAULT {: RESULT = "drop default "; :}; DROP_COL_DEF ::= DROP COLUMN_EXPR:ce ID:id DROP_BEHAVIOUR:db {: if (db != "") raise_Error("this drop behaviour "); RESULT = ";drop;" + id; :}; ADD_TAB_CONSTR_DEF ::= ADD TAB_CONSTR_DEF:tcd {: raise_Error("alter table add contraint "); :}; DROP_TAB_CONSTR_DEF ::= DROP CONSTR_NAME_DEF:cnd DROP_BEHAVIOUR:db {: raise_Error("alter table drop constraint "); :}; // *** DEFINITION OF ALTER TABLE ENDS HERE *** /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!! DQL DEFINITION !!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** Definition of QUERY_SPEC *** QUERY_SPEC ::= SELECT DISTINCT_CLAUSE: DiCl SELECT_LIST:sl FROM_CLAUSE:fc WHERE_CLAUSE:wc GROUP_BY_CLAUSE:gbc ORDER_BY_CLAUSE:oc HAVING_CLAUSE {: sl.setDistinctClause(DiCl); PreQuery = new QueryClause(); PreQuery.addSClause(sl); PreQuery.addTClause(fc); PreQuery.addWClause(wc); PreQuery.addGClause(gbc); PreQuery.addOClause(oc); RESULT = PreQuery; :}; SELECT_LIST ::= ASTERISK {: RESULT = new SelectClause("*"); :} | SELECT_SLIST_EXPR:sse {: RESULT = new SelectClause(sse); :}; SELECT_SUBLIST ::= VALUE_EXPR:ve AS_CLAUSE:ac {: if (SelectListError) {SelectListError = false; raise_Error("The usage of strings as select-element ");} else if (ve.containsSub()) raise_Error("The usage of Subqueries in select-elements "); else RESULT = new SelectElement(ve.getStrValueExpr(), ac, ve.containsSetFunc()); :} | ID DOT ASTERISK {: raise_Error("The usage of qualified_name.* "); :} | ID DOT ID DOT ASTERISK // schema and Name {: raise_Error("The usage of qualified_name.* "); :} | ID DOT ID DOT ID DOT ASTERISK // catalog and schema and Name {: raise_Error("The usage of qualified_name.* "); :}; TABLE_EXPR ::= FROM_CLAUSE WHERE_CLAUSE GROUP_BY_CLAUSE HAVING_CLAUSE; FROM_CLAUSE ::= FROM TABLE_REF_EXPR:tre {: if (FromError) raise_Error("The FROM-clause in secondo just supports a"+ " relationname as Table-Reference. This usage of a FROM-clause "); else RESULT = tre; :}; WHERE_CLAUSE ::= WHERE SEARCH_COND:sc {: RESULT = sc;:} | {: RESULT = new WhereClause("");:}; GROUP_BY_CLAUSE ::= GROUP_BY GROUP_COL_REF_LIST:gcrl {: RESULT = gcrl; :} |{: RESULT = new GroupClause("");:}; HAVING_CLAUSE ::= HAVING SEARCH_COND {: raise_Error("having ..."); :} |; GROUP_COL_REF ::= COLUMN_REF:cr COLLATE_CLAUSE:cc {: if (cc != "") raise_Error("The usage of collate "); RESULT = new GroupElement(cr); :}; ORDER_BY_CLAUSE ::= ORDER_BY SORT_SPEC_LIST:ssl {: RESULT = ssl; :} |{: RESULT = new OrderClause("");:}; SORT_SPEC ::= SORT_KEY:sk COLLATE_CLAUSE:cc ORDER_SPEC:os {: if (cc != "") raise_Error("The usage of collate "); RESULT = new OrderElement(sk+os); :}; SORT_KEY ::= ID:id {: RESULT = id; :} | ENL:enl {: if (enl.indexOf(".") != -1) raise_GeneralError("Just integers are allowed at that position!"); raise_Error("The usage of numbers as sort_key within an order-by statement"); :}; ORDER_SPEC ::= ASC {: RESULT = " asc"; :} | DESC {: RESULT = " desc"; :} |{: RESULT = ""; :}; // *** Definition of QUERY_SPEC ends here *** /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!! DML DEFINITION !!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** Definition of INSERT starts here *** INSERT_CLAUSE ::= INSERT_INTO QUALNAME:qn INS_COL_AND_SOU:icas {: RESULT = "insert into " + qn + " " + icas; :}; INS_COL_AND_SOU ::= INS_COL_LIST QUERY_EXPR:qe {: RESULT = qe.getInsertElement(); :}; INS_COL_LIST ::= LPARENT COLUMN_NAME_LIST RPARENT {: raise_Error("An Insert_Column_List "); :} | {: RESULT = ""; :}; // *** Definition of INSERT ends here *** // *** Definition of DELETE starts here *** DELETE_CLAUSE ::= DELETE_FROM QUALNAME:qn WHERE_CLAUSE:wc {: if (wc.containsSubs()) raise_Error("The usage of subqueries in delete-statements "); RESULT = "delete from "+ qn + wc.getWhereClause(); :} | DELETE_FROM QUALNAME WHERE_CURRENT_OF ID {: raise_Error("The usage of positioned delete statement "); :} ; // *** Definition of DELETE ends here *** // *** Definition of DROP starts here *** DROP_CLAUSE ::= DROP_TABLE QUALNAME:qn DROP_BEHAVIOUR:db {: if (db != "") raise_Error("this drop behaviour "); RESULT = "drop table " + qn; :} | DROP INDEX ID:indexname ON ID:tablename {: RESULT = "drop index " + indexname; :} | DROP INDEX ON ID:tablename ID:colname {: RESULT = "drop index " + tablename + "_" + colname + "_btree"; :} /*| DROP INDEX ON ID:tablename ID:colname INDEXTYPE ID:intype {: RESULT = "drop index " + tablename + "_" + colname + "_" + intype; :}*/ ; DROP_BEHAVIOUR ::= CASCADE {: RESULT = "cascade"; :} | RESTRICT {: RESULT = "restrict"; :} | {: RESULT = ""; :} ; // *** Definition of DROP ends here *** // *** Definition of Update starts here *** UPDATE_CLAUSE ::= UPDATE QUALNAME:qn SET SET_CLAUSE_LIST:scl WHERE_CLAUSE:wc {: if (wc.containsSubs()) raise_Error("subqueries whithin an update_clause "); RESULT = "update " + qn + " set " + scl.getGList() + wc.getWhereClause(); :}; SET_CLAUSE_LIST ::= SET_CLAUSE:sc {: RESULT = new GeneralList(sc); :} | SET_CLAUSE:sc COMMA SET_CLAUSE_LIST:scl {: RESULT = scl.addElement(sc); :}; SET_CLAUSE ::= ID:co EQUAL UPDATE_SOURCE:us {: RESULT = co + "=" + us; :}; UPDATE_SOURCE ::= VALUE_EXPR:ve {: if (ve.containsSub()) raise_Error("Subqueries within a Set_Clause "); RESULT = ve.getStrValueExpr(); :} | DEFAULT {: raise_Error("default within a Set_Clause "); :} | NULL {: raise_Error("NULL within a Set_Clause "); :}; // *** Definition of Update ends here *** /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!! DEFINITION OF EXTENSIVE !!!!!!!!!!!!!! !!!!!!!!!!!!!!!!! NON-TERMINALS !!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** Definition of VALUE_EXPRESSION *** VALUE_EXPR ::= NUMERIC_VALUE_EXPR:nve {: RESULT = nve; :} | STRING_VALUE_EXPR {: raise_Error("This string_value_expression "); :} // general value will be supported by NUMERIC VALUE EXPR other constructions will // raise an error because the are not supported by Secondo | DATETIME_VALUE_EXPR:dve //{: RESULT = new ValueExpr(new ValueList(new SimpleValue(dve))); :} This could be activated if datetime_values are supported by secondo {: raise_Error("This datetime_value_expression "); :} | INTERVAL_VALUE_EXPR {: raise_Error("This interval_value_expression "); :} | BOOLEAN_VALUE_EXPR:bve {: RESULT = new ValueExpr(new ValueList(new SimpleValue(bve))); :}; NUMERIC_VALUE_EXPR ::= TERM:te //addition and substraction {: RESULT = new ValueExpr(te); :} | NUMERIC_VALUE_EXPR:nve PLUS TERM:te {: useAsExpr = true; if (nve.containsSub()|| nve.containsSetFunc()) raise_GeneralError("Syntax Error: subquery/Set_Function + operator!"); RESULT = nve.addElement(te, "+"); :} | NUMERIC_VALUE_EXPR:nve MINUS TERM:te {: useAsExpr = true; if (nve.containsSub() || nve.containsSetFunc()) raise_GeneralError("Syntax Error: subquery/Set_Function + operator!"); RESULT = nve.addElement(te, "-"); :}; TERM ::= FACTOR:fa //multiplication and division {: RESULT = new ValueList(fa); :} | TERM:te ASTERISK FACTOR:fa {: useAsExpr = true; if (te.containsSub() || te.containsSetFunc()) raise_GeneralError("Syntax Error: subquery/Set_Function + operator!"); RESULT = te.addElement(fa, "*"); :} | TERM:te SOLIDUS FACTOR:fa {: useAsExpr = true; if (te.containsSub() || te.containsSetFunc()) raise_GeneralError("Syntax Error: subquery/Set_Function + operator!"); RESULT = te.addElement(fa, "/"); :}; FACTOR ::= SIGN:si NUMERIC_PRIMARY:np // minus sign {: useAsExpr = true; if (np.containsSub() || np.containsSetFunc()) raise_GeneralError("Syntax Error: sign + subquery/Set_Function!"); RESULT = np.setSign(si); :} | NUMERIC_PRIMARY: np {: RESULT = np; :}; NUMERIC_PRIMARY ::= VALUE_EXPR_PRIMARY:vep {: RESULT = vep; :} | NUMERIC_VALUE_FUN {: raise_Error("The usage of numeric value functions like position (String...), extrac (String...) or char_length (String ...) "); :}; VALUE_EXPR_PRIMARY ::= UNSIGNED_VALUE_SPEC:uvs // number or string {: useAsExpr = true; RESULT = new SimpleValue(uvs); :} | COLUMN_REF:cr // identifier of columns {: RESULT = new SimpleValue(cr); :} | SUBQUERY:su // scalar subquery {: RESULT = new SimpleValue(su); :} // since subqueries in Values are needed Value_Expr had to become its own type | SET_FUN_SPEC:sfs // aggregate function {: SimpleValue PreResult = new SimpleValue(sfs); PreResult.setSetFunc(); RESULT = PreResult; :} /*| CASE_EXPR {: raise_Error("The usage of case-expressions "); :}*/ | CAST_SPEC {: raise_Error("The usage of cast-specifications "); :}; UNSIGNED_VALUE_SPEC ::= UNSIGNED_LITERAL:ul {: RESULT = ul; :} | GEN_VALUE_SPEC; //not supported by Secondo (returns SYSTEM_INFO and PARAMETERS outputs like CURRENT_USER) UNSIGNED_LITERAL ::= UNSIGNED_NUM_LITERAL:unl // numbers {: RESULT = unl; :} | GENERAL_LITERAL:gl // strings {: RESULT = gl; :}; UNSIGNED_NUM_LITERAL ::= ENL:enl //e.g. 1.2012 {: RESULT = enl;:} | ANL:anl //e.g 1.2012E-15 {: RESULT = anl;:}; GENERAL_LITERAL ::= A_STRING:a_st {: SelectListError = true; RESULT = "\""+a_st+"\""; :}; GEN_VALUE_SPEC ::= PARAM_SPEC:param {: raise_Error("The usage of parameters or variables: " +param); :} | QUESTIONMARK {: raise_Error("The usage of dynamic parameters "); :} | SYSTEM_INFO {: raise_Error("The usage of System-information like USER or VALUE "); :}; PARAM_SPEC ::= PAR_VAR_NAME:pvn {: RESULT = pvn; :} /*| PAR_VAR_NAME:pvn1 PAR_VAR_NAME:pvn2 {: RESULT = pvn1+" "+pvn2; :}*/ | PAR_VAR_NAME:pvn1 INDICATOR PAR_VAR_NAME:pvn2 {: RESULT = pvn1+" indicator "+pvn2; :}; SYSTEM_INFO ::= USER | CURRENT_USER | SESSION_USER | SYSTEM_USER | VALUE; COLUMN_REF ::= ID:ColumnName // identifier of a column {: RESULT = ColumnName; :} |ID:TableName DOT ID:CoName {: QualifierInUse = true; RESULT = TableName + ":" + CoName; :} |ID:schema DOT ID:TableName DOT ID:CoName {: raise_Error("The usage of Tablenames to specify columnnames like "+schema+"."+TableName+"."+CoName); :} |ID:catalog DOT ID:schema DOT ID:TableName DOT ID:CoName {: raise_Error("The usage of Tablenames to specify columnnames like "+catalog+"."+schema+"."+TableName+"."+CoName); :}; SET_FUN_SPEC ::= COUNT LPARENT ASTERISK RPARENT // aggregate functions {: RESULT = "count(*)"; :} | COUNT LPARENT DISTINCT_CLAUSE:dist VALUE_EXPR:ve RPARENT {: if (ve.containsSub()) raise_Error("A subquery as part of a set_function_type "); RESULT = "count(" + dist + ve.getStrValueExpr() + ")"; :} | SET_FUN_TYPE:fun LPARENT DISTINCT_CLAUSE:dist VALUE_EXPR:ve RPARENT {: if (ve.containsSub()) raise_Error("A subquery as part of a set_function_type "); RESULT = fun + "(" + dist + ve.getStrValueExpr() + ")"; :}; SET_FUN_TYPE ::= MIN {: RESULT = "min"; :} | MAX {: RESULT = "max"; :} | AVG {: RESULT = "avg"; :} | SUM {: RESULT = "sum"; :}; CASE_EXPR ::= CASE_ABBR | CASE_SPEC; CASE_ABBR ::= NULLIF LPARENT VALUE_EXPR COMMA VALUE_EXPR RPARENT | COALESCE LPARENT VALUE_EXPR_LIST RPARENT; CASE_SPEC ::= CASE VALUE_EXPR SIM_WHEN_CLAUSE | WHEN SEARCH_COND THEN RESULT_EXPR; SIM_WHEN_CLAUSE ::= WHEN VALUE_EXPR THEN RESULT_EXPR |WHEN VALUE_EXPR THEN RESULT_EXPR SIM_WHEN_CLAUSE; ELSE_CLAUSE ::= ELSE RESULT_EXPR |; RESULT_EXPR ::= VALUE_EXPR | NULL; CAST_SPEC ::= CAST LPARENT CAST_OP AS CAST_TARGET RPARENT; CAST_OP ::= VALUE_EXPR | NULL; CAST_TARGET ::= DOMAINNAME | TYPE_NAME; NUMERIC_VALUE_FUN ::= POS_EXPR | EXTRACT_EXPR | LENGTH_EXPR; POS_EXPR ::= POSITION LPARENT CHAR_VALUE_EXPR IN CHAR_VALUE_EXPR RPARENT; EXTRACT_EXPR ::= EXTRACT LPARENT EXTRACT_FIELD FROM EXTRACT_SOURCE RPARENT; EXTRACT_FIELD ::= DATETIME_FIELD |TIMEZONE_FIELD; EXTRACT_SOURCE ::= DATETIME_VALUE_EXPR INTERVAL_VALUE_EXPR; DATETIME_FIELD ::= NON_SECOND_DT_FIELD |SECOND; TIMEZONE_FIELD ::= TIMEZONE_HOUR | TIMEZONE_MINUTE; LENGTH_EXPR ::= CHAR_L_EXPR LPARENT STRING_VALUE_EXPR RPARENT | OCTET_LENGTH LPARENT STRING_VALUE_EXPR RPARENT | BIT_LENGTH LPARENT STRING_VALUE_EXPR RPARENT; STRING_VALUE_EXPR ::= CHAR_VALUE_EXPR | BIT_VALUE_EXPR; CHAR_VALUE_EXPR ::= CONCAT | CHAR_FACTOR; CONCAT ::= CHAR_VALUE_EXPR CONCAT_OP CHAR_FACTOR | CHAR_VALUE_EXPR CONCAT_OP VALUE_EXPR_PRIMARY | VALUE_EXPR_PRIMARY CONCAT_OP VALUE_EXPR_PRIMARY | VALUE_EXPR_PRIMARY CONCAT_OP CHAR_FACTOR; CHAR_FACTOR ::= CHAR_PRIM COLLATE_CLAUSE | VALUE_EXPR_PRIMARY COLLATE QUALNAME; CHAR_PRIM ::= STRING_VALUE_FUN; // | VALUE_EXPR_PRIMARY has not been implemented here because it leads to error messages // VALUE_EXPR_PRIMARY therefore had to be implemented in CHAR_FACTOR, CONCAT and // LIKE_PREDICATE. The implementation in CHAR_FACTOR is not complete, since it should // be VALUE_EXPR_PRIMARY COLLATE_CLAUSE, which also leads to an error. Therefore // VALUE_EXPR_PRIMARY needs to be added as alternatives in cases where // CHAR_VALUE_EXPR is used. STRING_VALUE_FUN ::= CHAR_VALUE_FUN | BIT_VALUE_FUN; CHAR_VALUE_FUN ::= CHAR_SUBSTR_FUN | FOLD | F_O_U_CONV | CHAR_TRANSL | TRIM_FUN; CHAR_SUBSTR_FUN ::= SUBSTRING LPARENT CHAR_VALUE_EXPR FROM NUMERIC_VALUE_EXPR FOR_EXPR RPARENT; FOLD ::= UP_LOW_EXPR LPARENT CHAR_VALUE_EXPR RPARENT; F_O_U_CONV ::= CONVERT LPARENT CHAR_VALUE_EXPR USING QUALNAME RPARENT; CHAR_TRANSL ::= TRANSLATE LPARENT CHAR_VALUE_EXPR USING QUALNAME RPARENT; TRIM_FUN ::= TRIM LPARENT TRIM_OP RPARENT; TRIM_OP ::= TRIM_SPEC TRIM_CHAR FROM CHAR_VALUE_EXPR | TRIM_CHAR FROM CHAR_VALUE_EXPR | CHAR_VALUE_EXPR; TRIM_SPEC ::= LEADING | TRAILING | BOTH; TRIM_CHAR ::= CHAR_VALUE_EXPR |; BIT_VALUE_EXPR ::=BIT_CONCAT BIT_FACTOR; BIT_CONCAT ::= BIT_VALUE_EXPR CONCAT_OP BIT_FACTOR; BIT_FACTOR ::= BIT_PRIM; BIT_PRIM ::= VALUE_EXPR_PRIMARY | STRING_VALUE_FUN; BIT_VALUE_FUN ::= SUBSTRING LPARENT BIT_VALUE_EXPR FROM NUMERIC_VALUE_EXPR FOR_EXPR RPARENT; DATETIME_VALUE_EXPR ::= DATETIME_TERM:dt {: RESULT = dt; :} | INTERVAL_VALUE_EXPR PLUS DATETIME_TERM | DATETIME_VALUE_EXPR PLUS INTERVAL_TERM | DATETIME_VALUE_EXPR MINUS INTERVAL_TERM; DATETIME_TERM ::= DATETIME_FACTOR:df {: RESULT = df; :}; DATETIME_FACTOR ::= DATETIME_PRIM:dp TIMEZONE {: RESULT = dp; :}; DATETIME_PRIM ::= /*VALUE_EXPR_PRIMARY |*/ DATE_VALUE:dv //DATE_VALUE is selfcreated and recognizes YYYY--MM-DD {: RESULT = dv; :} | DATETIME_VALUE_FUN; DATETIME_VALUE_FUN ::= CURRENT_DATE |CURRENT_TIME TIME_PRECISION |CURRENT_TIMESTAMP TIME_PRECISION; TIME_PRECISION ::= LPARENT UNSIGNED_INT RPARENT |; TIMEZONE ::= AT TIMEZONE_SPEC |; TIMEZONE_SPEC ::= LOCAL | TIME_ZONE INTERVAL_VALUE_EXPR; INTERVAL_VALUE_EXPR ::= INTERVAL_TERM | INTERVAL_VALUE_EXPR PLUS INTERVAL_TERM | INTERVAL_VALUE_EXPR MINUS INTERVAL_TERM | LPARENT DATETIME_VALUE_EXPR MINUS DATETIME_TERM RPARENT INTERVAL_QUAL; INTERVAL_TERM ::= INTERVAL_FACTOR | INTERVAL_TERM ASTERISK FACTOR | INTERVAL_TERM SOLIDUS FACTOR | TERM ASTERISK INTERVAL_FACTOR; INTERVAL_FACTOR ::= SIGN INTERVAL_PRIM | INTERVAL_PRIM; INTERVAL_PRIM ::= VALUE_EXPR_PRIMARY INTERVAL_QUAL_EXPR; INTERVAL_QUAL ::= NON_SECOND_DT_FIELD TIME_PRECISION TO END_FIELD | SINGLE_DT_FIELD; END_FIELD ::= NON_SECOND_DT_FIELD | SECOND TIME_PRECISION; SINGLE_DT_FIELD ::= NON_SECOND_DT_FIELD TIME_PRECISION | SECOND TIME_PRECISION_EXPR; NON_SECOND_DT_FIELD ::= YEAR | MONTH | DAY | HOUR | MINUTE; BOOLEAN_VALUE_EXPR ::= TRUTH_VALUE:tv {: RESULT = tv; :}; // *** Definition of VALUE_EXPRESSION ends here *** // *** Definition of SEARCH_COND *** SEARCH_COND ::= BOOL_TERM:bt // logic OR {: RESULT = new WhereClause(bt); :} |SEARCH_COND:sc OR BOOL_TERM:bt {: RESULT = sc.addElement(bt); :}; BOOL_TERM ::= BOOL_FACTOR:bf // logic AND {: RESULT = new WhereList(bf); :} | BOOL_TERM:bt AND BOOL_FACTOR:bf {: RESULT = bt.addElement(bf); :}; BOOL_FACTOR ::= NOT BOOL_TEST:bt // logic NOT {: bt.SetNotExpr(); RESULT = bt; :} | BOOL_TEST: bt {: RESULT = bt; :}; BOOL_TEST ::= BOOL_PRIM:bp {: RESULT = bp; :} | BOOL_PRIM IS NOT_EXPR TRUTH_VALUE {: raise_Error("expressions like is true or is false within a search condition "); :}; TRUTH_VALUE ::= TRUE {: RESULT = "true"; :} | FALSE {: RESULT = "false"; :} | UNKNOWN {: RESULT = ""; :}; BOOL_PRIM ::= PREDICATE:pr {: RESULT = pr; :} | LPARENT SEARCH_COND:sc RPARENT {: if (sc.containsSubs()) raise_Error("(search conditions containing Subqueries) within a search condition "); else RESULT = new WhereElement(sc); :}; // New operations can be included in predicate PREDICATE ::= ROW_VALUE_CON:rvc1 COMP_OP:co ROW_VALUE_CON:rvc2 {: if (rvc1.containsSub() || rvc2.containsSub()) raise_Error("Using Subqueries in row value constructors "); else if(rvc1.moreThanOne() || rvc2.moreThanOne()) raise_Error("Row value constructors building a row by a list of values outside insert clauses "); else RESULT = new WhereElement(rvc1.getValueExpr().getStrValueExpr(), rvc2.getValueExpr().getStrValueExpr(), co); :} | ROW_VALUE_CON:rvc NOT_EXPR:ne IN IN_PRED_VALUE:ipv {: if (rvc.containsSub()) raise_Error("Using Subqueries in row value constructors "); else if(rvc.moreThanOne()) raise_Error("Row value constructors building a row by a list of values outside insert clauses "); else RESULT = new WhereElement(rvc.getValueExpr().getStrValueExpr(), ne, "in", ipv); :} | ROW_VALUE_CON:rvc COMP_OP:co QUANTIFIER:qu SUBQUERY:su {: if (rvc.containsSub()) raise_Error("Using Subqueries in row value constructors "); else if(rvc.moreThanOne()) raise_Error("Row value constructors building a row by a list of values outside insert clauses "); else RESULT = new WhereElement(rvc.getValueExpr().getStrValueExpr(), co, qu, su); :} | EXISTS SUBQUERY: su {: RESULT = new WhereElement("", "exists", "", su); :} | ROW_VALUE_CON NOT_EXPR BETWEEN ROW_VALUE_CON AND ROW_VALUE_CON {: raise_Error("The expression between "); :} | CHAR_VALUE_EXPR NOT_EXPR LIKE CHAR_VALUE_EXPR ESC_EXPR {: raise_Error("the expression like "); :} | VALUE_EXPR_PRIMARY NOT_EXPR LIKE VALUE_EXPR_PRIMARY {: raise_Error("the expression like "); :} | CHAR_VALUE_EXPR NOT_EXPR LIKE VALUE_EXPR_PRIMARY {: raise_Error("the expression like "); :} | VALUE_EXPR_PRIMARY NOT_EXPR LIKE CHAR_VALUE_EXPR {: raise_Error("the expression like "); :} | ROW_VALUE_CON IS NOT_EXPR NULL {: raise_Error("checking whether an expression is null "); :} | ROW_VALUE_CON MATCH UNIQUE_EXPR PAR_FULL_EXPR SUBQUERY {: raise_Error("the expression match "); :} | ROW_VALUE_CON OVERLAPS ROW_VALUE_CON {: raise_Error("the expression overlaps "); :}; IN_PRED_VALUE ::= SUBQUERY:su {: RESULT = su; :} | LPARENT IN_VALUE_LIST RPARENT {: raise_Error("value lists within in-predicates "); :}; IN_VALUE_LIST ::= VALUE_EXPR | VALUE_EXPR COMMA IN_VALUE_LIST; ROW_VALUE_CON ::= ROW_VALUE_CON_ELEM:rvce {: RESULT = new ValueExprList(rvce); :} | LPARENT ROW_VALUE_CON_LIST:rvcl RPARENT {: RESULT = rvcl; :} /*| SUBQUERY The BNF grammar describes here a table row built by a subquery. BNF does not differentiate between a row and a value built by a subquery. Cup would raise a reduce/reduce error. Since a subquery entry is already interpreted by value_expr. It does not need to and it must not be included here.*/ ; ROW_VALUE_CON_ELEM ::= VALUE_EXPR:ve {: useAsExpr = false; RESULT = ve; :} | NULL {: raise_Error("Null"); :} | DEFAULT {: raise_Error("default"); :} ; ROW_VALUE_CON_LIST ::= ROW_VALUE_CON_ELEM:rvce {: RESULT = new ValueExprList(rvce); :} | ROW_VALUE_CON_LIST:rvcl COMMA ROW_VALUE_CON_ELEM:rvce {: RESULT = rvcl.addElement(rvce); :}; TABLE_CON_LIST ::= ROW_VALUE_CON:rvc {: RESULT = rvc.getValueExprList(); :} | ROW_VALUE_CON COMMA TABLE_CON_LIST {: raise_Error("Table constructor lists build by more than one Row value constructor lists ");:}; QUANTIFIER ::= ALL {: RESULT = " all "; :} | SOME {: RESULT = " some "; :} | ANY {: RESULT = " any "; :}; COMP_OP ::= EQUAL {: RESULT = " = "; :} | NOT_EQUAL {: RESULT = " # "; :} | LESS {: RESULT = " < "; :} | LESS_EQUAL {: RESULT = " <= "; :} | GREATER {: RESULT = " > "; :} | GREATER_EQUAL {: RESULT = " >= "; :}; // *** Definition of SEARCH_COND ends here *** // *** Definition of QUERY_EXPRESSION *** QUERY_EXPR ::= NON_JOIN_QE:njq {: RESULT = njq; :} | JOINED_TABLE {: insertError = true; :}; // ** Definition of NON_JOIN_QUERY_EXPRESSION ** NON_JOIN_QE ::= NON_JOIN_QT:njq // UNION and EXCEPT {: RESULT = njq; :} | QUERY_EXPR UNION_EXCEPT_EXPR ALL_EXPR CORRESPONDING_SPEC NON_JOIN_QT {: SecondoSubQuery = false; insertError = true; :} | QUERY_EXPR UNION_EXCEPT_EXPR ALL_EXPR CORRESPONDING_SPEC JOINED_TABLE {: SecondoSubQuery = false; insertError = true; :}; QUERY_TERM ::= NON_JOIN_QT:njq {: RESULT = njq; :} | JOINED_TABLE {: insertError = true; :}; NON_JOIN_QT ::= NON_JOIN_QP:njq // INTERSECT {: RESULT = njq; :} | NON_JOIN_QT INTERSECT ALL_EXPR CORRESPONDING_SPEC QUERY_PRIM {: SecondoSubQuery = false; insertError = true; :} | JOINED_TABLE INTERSECT ALL_EXPR CORRESPONDING_SPEC QUERY_PRIM {: SecondoSubQuery = false; insertError = true; :}; QUERY_PRIM ::= NON_JOIN_QP:njq {: RESULT = njq; :} | JOINED_TABLE {: insertError = true; :}; NON_JOIN_QP ::= SIMPLE_TABLE:st {: RESULT = st; :} | LPARENT NON_JOIN_QE RPARENT {: insertError = true; :}; SIMPLE_TABLE ::= TABLE QUALNAME {: insertError = true; :} | VALUES TABLE_CON_LIST:tcl {: RESULT = new InsertElement(tcl); :} | QUERY_SPEC:qs {: SecondoSubQuery = true; RESULT = new InsertElement(qs); :}; CORRESPONDING_SPEC ::= CORRESPONDING CORR_BY_EXPR |; // ** Definition of NON_JOIN_QUERY_EXPRESSION ends here ** // ** Definition of JOINED TABLE ** JOINED_TABLE ::= TABLE_REF CROSS JOIN TABLE_REF |TABLE_REF JOIN_TYPE TABLE_REF JOIN_SPEC; JOIN_SPEC ::= | ON SEARCH_COND | USING LPARENT COLUMN_NAME_LIST RPARENT; TABLE_REF ::= QUALNAME:rel CORR_SPEC_EXPR:cse {: RESULT = new TableElement(rel, cse); :} |SUBQUERY:su CORR_SPEC {: FromError = true; /*RESULT = su;*/ :} |JOINED_TABLE:jt {: FromError = true; /*RESULT = jt;*/ :}; CORR_SPEC ::= AS ID:id DERIVED_COLUMN_LIST:dcl {: if (dcl!="") {FromError = true; dcl = " "+dcl;} RESULT = id + dcl; :} /* a derived column list is not allowed in a from clause. In other occasions it might be ok */ | ID:id DERIVED_COLUMN_LIST:dcl {: if (dcl!="") {FromError = true; dcl = " "+dcl;} RESULT = id + dcl; :}; DERIVED_COLUMN_LIST ::= LPARENT COLUMN_NAME_LIST:cnl RPARENT {: RESULT = "(" + cnl + ")"; :} | {: RESULT = ""; :}; // ** Definition of JOINED_TABLE ends here ** // *** Definition of QUERY_EXPRESSION ends here *** /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!! MISCELLANEOUS NON-TERMINALS !!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ QUALNAME ::= ID:id {: RESULT = id; :} |ID:schema DOT ID:id {: raise_Error("Secondo does not work with schemas. The qualified name "+schema+"."+id); :} |ID:catalog DOT ID:schema DOT ID:id {: raise_Error("Secondo does not work with catalogs. The qualified name "+catalog+"."+schema+"."+id); :}; // !!! MODULE. has not been taken into account yet !!! SUBQUERY ::= LPARENT QUERY_EXPR:qe RPARENT {: if (!SecondoSubQuery) raise_Error("This kind of subquery "); else {SecondoSubQuery = false; SubqueryInUse = true; RESULT = qe.getQuery();} :}; SIGN ::= PLUS {: RESULT = "+"; :} | MINUS {: RESULT = "-"; :}; // *** Options like [] *** ESC_EXPR ::= ESCAPE CHAR_VALUE_EXPR |; UNIQUE_EXPR ::= UNIQUE |; PAR_FULL_EXPR ::= PARTIAL {: RESULT = " partial "; :} | FULL {: RESULT = " full "; :} | {: RESULT = ""; :}; UNION_EXCEPT_EXPR ::= UNION | EXCEPT; NOT_EXPR ::= NOT {: RESULT = "not "; :} | {: RESULT = ""; :}; ALL_EXPR ::= ALL |; CORR_BY_EXPR ::= BY LPARENT COLUMN_NAME_LIST RPARENT|; AS_CLAUSE ::= {: if (useAsExpr) PreResult = getUniqueName(); else PreResult =""; useAsExpr = false; RESULT = PreResult; :} | AS ID:id {: RESULT = id; :} | ID:id {: RESULT = id; :}; CORR_SPEC_EXPR ::= CORR_SPEC:cs {: RESULT = " "+cs; :} | {: RESULT = ""; :}; FOR_EXPR ::= FOR NUMERIC_VALUE_EXPR |; UP_LOW_EXPR ::= UPPER | LOWER; INTERVAL_QUAL_EXPR ::= INTERVAL_QUAL /*|*/; CHAR_L_EXPR ::= CHAR_LENGTH | CHARACTER_LENGTH; TIME_PRECISION_EXPR ::= LPARENT UNSIGNED_INT RPARENT | LPARENT UNSIGNED_INT COMMA LPARENT UNSIGNED_INT RPARENT RPARENT |; COLLATE_CLAUSE ::= COLLATE QUALNAME:qn {: RESULT = "collate " + qn; :} |{: RESULT = ""; :}; DISTINCT_CLAUSE ::= ALL {: RESULT = "all ";:} | DISTINCT {: RESULT = "distinct ";:} | {: RESULT = "";:}; COLUMN_EXPR ::= COLUMN {: RESULT = "column ";:} | {: RESULT = "";:}; // *** Options end here *** //*** Repetitions like X [{comma X}...] *** TABLE_REF_EXPR ::= TABLE_REF:tr {: RESULT = new TableClause(tr);:} | TABLE_REF:tr COMMA TABLE_REF_EXPR:tre {: RESULT = tre.addElement(tr); :}; SELECT_SLIST_EXPR ::= SELECT_SUBLIST:ss {: RESULT = new SelectList(ss);:} | SELECT_SUBLIST:ss COMMA SELECT_SLIST_EXPR:sse {: RESULT = sse.addElement(ss);:}; GROUP_COL_REF_LIST ::= GROUP_COL_REF:gcr {: RESULT = new GroupClause(gcr);:} | GROUP_COL_REF:gcr COMMA GROUP_COL_REF_LIST:gcrl {: RESULT = gcrl.addElement(gcr); :}; SORT_SPEC_LIST ::= SORT_SPEC:ssp {: RESULT = new OrderClause(ssp);:} | SORT_SPEC_LIST:ssl COMMA SORT_SPEC:ssp {: RESULT = ssl.addElement(ssp); :}; VALUE_EXPR_LIST ::= VALUE_EXPR | VALUE_EXPR COMMA VALUE_EXPR_LIST; // *** Repetitions end here *** /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!! PARTS WHICH ARE NOT YET SUPPORTED !!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ // *** DEFINITION DEFAULT_CLAUSE *** DEFAULT_CLAUSE ::= DEFAULT DEFAULT_OPTION:deo {: RESULT = "default " + deo;:} | {: RESULT = "";:}; DEFAULT_OPTION ::= LITERAL:li {: RESULT = li;:} | DATETIME_VALUE_FUN {: RESULT = "not supported";:} | USER {: RESULT = "user";:} | CURRENT_USER {: RESULT = "current_user";:} | SESSION_USER {: RESULT = "session_user";:} | SYSTEM_USER {: RESULT = "system_user";:} | NULL {: RESULT = "null";:}; LITERAL ::= SIGNED_NUM_LITERAL:snl {: RESULT = snl;:} |GENERAL_LITERAL:gl {: RESULT = gl;:}; SIGNED_NUM_LITERAL ::= SIGN:si UNSIGNED_NUM_LITERAL:unl {: RESULT = si+unl;:} | UNSIGNED_NUM_LITERAL:unl {: RESULT = unl;:}; // *** DEFINITION DEFAULT_CLAUSE ENDS HERE *** // *** DEFINITION OF CONSTRAINTS *** TAB_CONSTR_DEF ::= CONSTR_NAME_DEF:cnd TAB_CONSTR:tc {: RESULT = cnd + " " + tc; :} | TAB_CONSTR:tc {: RESULT = tc; :}; TAB_CONSTR ::= UNI_CONSTR_DEF:ucd {: RESULT = ucd; :} | REF_CONSTR_DEF:rcd {: RESULT = rcd; :} | CHECK_CONSTR_DEF:ccd {: RESULT = ccd; :}; CONSTR_NAME_DEF ::= CONSTRAINT QUALNAME:qn {: RESULT = " constraint " + qn; :}; UNI_CONSTR_DEF ::= UNIQUE_SPEC:us LPARENT COLUMN_NAME_LIST:cl RPARENT {: RESULT = us + "(" + cl + ")"; :}; REF_CONSTR_DEF ::= FOREIGN_KEY LPARENT COLUMN_NAME_LIST:cl RPARENT REF_SPEC:rs {: RESULT = "foreign key (" + cl + ")" + rs; :}; CHECK_CONSTR_DEF ::= CHECK LPARENT SEARCH_COND:sd RPARENT {: RESULT = "check (" + sd.getWhereClause() + ")"; :}; COL_CONSTR_EXPR_2 ::= COL_CONSTR_EXPR:cce {: RESULT = cce.getGListWithoutComma(); :} | {: RESULT = ""; :}; COL_CONSTR_EXPR ::= COL_CONSTR_DEF:ccd {: RESULT = new GeneralList(ccd); :} | COL_CONSTR_DEF:ccd COL_CONSTR_EXPR: cce {: RESULT = cce.addElement(ccd); :}; COL_CONSTR_DEF ::= CONSTR_NAME_DEF:cnd COL_CONSTR:cc {: RESULT = cnd + " " + cc; :} | COL_CONSTR:cc {: RESULT = cc; :}; COL_CONSTR ::= NOT NULL {: RESULT = "not null"; :} | UNIQUE_SPEC:us {: RESULT = us; :} | REF_SPEC:rs {: RESULT = rs; :} | CHECK_CONSTR_DEF:ccd {: RESULT = ccd; :}; UNIQUE_SPEC ::= UNIQUE {: RESULT = " unique "; :} | PRIM_KEY {: RESULT = " primary key "; :}; REF_SPEC ::= REFERENCES REF_TAB_COL:rtc PAR_FULL_EXPR:pfe {: RESULT = " references " + rtc + pfe; :}; REF_TAB_COL ::= QUALNAME:qn LPARENT COLUMN_NAME_LIST:cl RPARENT {: RESULT = qn + "(" + cl + ")"; :} | QUALNAME:qn {: RESULT = qn; :}; // *** DEFINITION OF CONSTRAINTS ENDS HERE ***