1313 lines
43 KiB
Plaintext
1313 lines
43 KiB
Plaintext
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 ***
|
|
|
|
|
|
|
|
|