-/* ------------------------------------------------\r
-Copyright 2014 AT&T Intellectual Property\r
- Licensed under the Apache License, Version 2.0 (the "License");\r
- you may not use this file except in compliance with the License.\r
- You may obtain a copy of the License at\r
-\r
- http://www.apache.org/licenses/LICENSE-2.0\r
-\r
- Unless required by applicable law or agreed to in writing, software\r
- distributed under the License is distributed on an "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- See the License for the specific language governing permissions and\r
- limitations under the License.\r
- ------------------------------------------- */\r
-#ifndef _FTA_PARSE_H_INCLUDED__\r
-#define _FTA_PARSE_H_INCLUDED__\r
-\r
-#include<stdio.h>\r
-#include<ctype.h>\r
-\r
- int yyparse();\r
- void yyerror(char *s);\r
- int yylex();\r
-extern int flex_fta_lineno, flex_fta_ch;\r
-\r
-/* Interface to FTA Parser */\r
-void FtaParser_setfileinput(FILE *f);\r
-void FtaParser_setstringinput(char *s);\r
-\r
-\r
-/* Get type defines. */\r
-#include"type_objects.h"\r
-#include"literal_types.h"\r
-#include"type_indicators.h"\r
-\r
-#include <string>\r
-#include <vector>\r
-#include <map>\r
-#include <math.h>\r
-#include <string>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-\r
-\r
-// colref_t::is_equivalent needs to understand the schema\r
-#include"parse_schema.h"\r
-class colref_t;\r
-\r
-\r
-\r
-class var_pair_t{\r
-public:\r
- std::string name;\r
- std::string val;\r
-\r
- var_pair_t(char *n, char *v){\r
- name=n; val=v;\r
-//printf("NEW var_pair_t(%s, %s)\n",n,v);\r
- };\r
-\r
- var_pair_t(const std::string n, const std::string v){\r
- name=n; val=v;\r
- };\r
-};\r
-\r
-typedef std::map< std::string, std::string > ss_map;\r
-\r
-class var_defs_t{\r
-private:\r
- std::vector<var_pair_t *> namevec;\r
-\r
-public:\r
- var_defs_t(var_pair_t *vp){\r
- namevec.push_back(vp);\r
- };\r
-\r
- var_defs_t *add_var_pair(var_pair_t *vp){\r
- namevec.push_back(vp);\r
- return(this);\r
- };\r
-\r
- std::vector<var_pair_t *> get_nvec(){return namevec;};\r
-\r
- int size(){return namevec.size();};\r
-\r
- int find_name(std::string n){\r
- int i;\r
- for(i=0;i<namevec.size();i++){\r
- if(namevec[i]->name == n)\r
- return i;\r
- }\r
- return -1;\r
- }\r
- std::string get_name(int i){\r
- if(i>=0 && i<namevec.size()){\r
- return(namevec[i]->name);\r
- }else{\r
- return("");\r
- }\r
- }\r
-\r
- std::string get_def(int i){\r
- if(i>=0 && i<namevec.size()){\r
- return(namevec[i]->val);\r
- }else{\r
- return("");\r
- }\r
- }\r
-\r
- std::string dump(){\r
- int i;\r
- std::string ret;\r
- for(i=0;i<namevec.size();++i){\r
- ret += "\t"+namevec[i]->name+" = "+namevec[i]->val+"\n";\r
- }\r
- return ret;\r
- }\r
-\r
-};\r
-\r
-\r
-\r
-\r
-// literal type constants are defined in literal_types.h\r
-// (must share this info with type_objects.h)\r
-\r
-// Represents a literal, as expected\r
-// NOTE: this class contains some code generation methods.\r
-\r
-class literal_t{\r
-private:\r
-\r
-public:\r
- std::string lstring; /* literal value */\r
- short int ltype; /* literal type */\r
- int lineno, charno;\r
-\r
- int complex_literal_id; // if this literal has a complex constructor,\r
- // there is a function which constructs it)\r
- //set to the idx in the complex literal\r
- // table. (Must store this here (instead of in SE)\r
- // because of bare literals in the IN predicate).\r
-\r
-\r
- literal_t(std::string v){\r
- lstring = v;\r
- ltype = LITERAL_STRING;\r
- complex_literal_id = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- }\r
- static literal_t *make_define_literal(const char *s, var_defs_t *d){\r
- int i;\r
- i=d->find_name(s);\r
- if(i<0){\r
- fprintf(stderr,"ERROR at line %d, char %d; DEFINE'd literal %s referenced but not in DEFINE block.\n",flex_fta_lineno, flex_fta_ch, s);\r
- exit(1);\r
- }\r
- return new literal_t(d->get_def(i));\r
- }\r
-\r
- literal_t(const char *lit, int t){lstring = lit; ltype = t;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- complex_literal_id = -1;\r
-\r
-// For some datatypes we need to modify literal so make a copy of the string\r
- char v[100];\r
- strcpy(v, lit);\r
-\r
-// Remove UL, ULL suffix from INT constants.\r
- if(ltype == LITERAL_INT || ltype == LITERAL_LONGINT){\r
- int i;\r
- int len=strlen(v);\r
- for(i=0;i<len;++i){\r
- if(v[i] == 'U') v[i] = '\0';\r
- }\r
- lstring = v;\r
- }\r
-\r
-// HEX and LONGHEX must be converted to uint (long long uint)\r
- if(ltype == LITERAL_HEX){\r
- char *c,ltmpstr[100];\r
- unsigned long tmp_l;\r
- for(c=v; (*c)!='\0';++c){\r
- if(! ( ((*c) >= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){\r
- fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a HEX constant.\n",\r
- lineno, charno, v);\r
- exit(1);\r
- }\r
- }\r
- sscanf(v,"%lx",&tmp_l);\r
- sprintf(ltmpstr,"%lu",tmp_l);\r
- lstring = ltmpstr;\r
- ltype = LITERAL_INT;\r
- }\r
- if(ltype == LITERAL_LONGHEX){\r
- char *c,ltmpstr[100];\r
- unsigned long long tmp_ll;\r
- for(c=v; (*c)!='\0';++c){\r
- if(! ( ((*c) >= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){\r
- fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a LHEX constant.\n",\r
- lineno, charno, v);\r
- exit(1);\r
- }\r
- }\r
- sscanf(v,"%llx",&tmp_ll);\r
- sprintf(ltmpstr,"%llu",tmp_ll);\r
- lstring = ltmpstr;\r
- ltype = LITERAL_LONGINT;\r
- }\r
-// Convert IP to uint\r
- if(ltype == LITERAL_IP){\r
- char ltmpstr[100];\r
- unsigned int o1,o2,o3,o4,tmp_l;\r
- if(sscanf(v,"%u.%u.%u.%u",&o1,&o2,&o3,&o4) != 4){\r
- fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n",\r
- lineno, charno, v);\r
- exit(1);\r
- }\r
- if( (o1>255) || (o2>255) || (o3>255) || (o4>255) ){\r
- fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n",\r
- lineno, charno, v);\r
- exit(1);\r
- }\r
- tmp_l = (o1<<24)+(o2<<16)+(o3<<8)+o4;\r
- sprintf(ltmpstr,"%u",tmp_l);\r
- lstring = ltmpstr;\r
- ltype = LITERAL_IP;\r
- }\r
- };\r
-\r
-// used to create literals with a default or initial value.\r
- literal_t(int type_indicator){\r
- lineno=-1; charno=-1;\r
- complex_literal_id = -1;\r
-\r
- switch(type_indicator){\r
- case UINT_TYPE:\r
- case INT_TYPE:\r
- case USHORT_TYPE:\r
- ltype = LITERAL_INT;\r
- lstring = "0";\r
- break;\r
- case ULLONG_TYPE:\r
- case LLONG_TYPE:\r
- ltype = LITERAL_LONGINT;\r
- lstring = "0";\r
- break;\r
- case FLOAT_TYPE:\r
- ltype = LITERAL_FLOAT;\r
- lstring = "0.0";\r
- break;\r
- case BOOL_TYPE:\r
- ltype = LITERAL_BOOL;\r
- lstring = "FALSE";\r
- break;\r
- case VSTR_TYPE:\r
- ltype = LITERAL_STRING;\r
- lstring = ""; complex_literal_id = 0; // unregistred complex lit\r
- break;\r
- case TIMEVAL_TYPE:\r
- ltype = LITERAL_TIMEVAL;\r
- lstring = "0.0";\r
- break;\r
- case IPV6_TYPE:\r
- ltype = LITERAL_IPV6;\r
- lstring = "0000:0000:0000:0000:0000:0000:0000:0000";\r
- complex_literal_id = 0; // unregistered complex literal\r
- break;\r
- case IP_TYPE:\r
- ltype = LITERAL_IP;\r
- lstring = "0";\r
- break;\r
- default:\r
- ltype = LITERAL_UDEF;\r
- lstring=" INTERNAL ERROR, UNKNOWN TYPE INDICATOR IN literal_t::literal_t(int) ";\r
- }\r
- };\r
-\r
- std::string to_string(){return lstring;};\r
-\r
- int get_type(){return ltype; };\r
- int get_lineno(){return lineno; };\r
- int get_charno(){return charno; };\r
-\r
- bool is_equivalent(literal_t *l2){\r
- if(ltype != l2->ltype)\r
- return(false);\r
- if(lstring != l2->lstring)\r
- return(false);\r
-\r
- return(true);\r
- };\r
-\r
-// Internal function to unescape control characters.\r
- static std::string gsqlstr_to_cstr(std::string s){\r
- std::string retval;\r
- unsigned char c, prev_c='\0';\r
- int i;\r
-\r
- for(i=0;i<s.size();++i){\r
- c = s[i];\r
- if(c=='\''){ // || c=='\\'\r
- if(prev_c==c){\r
- retval += c;\r
- prev_c = '\0';\r
- }else{\r
- prev_c=c;\r
- }\r
- continue;\r
- }\r
-\r
- retval += c;\r
- prev_c = c;\r
- }\r
-\r
- return retval;\r
- }\r
-\r
-\r
-\r
- std::string to_hfta_C_code(std::string param){\r
- std::string retval;\r
- double tmp_f;\r
- int secs, millisecs;\r
- char tmpstr[100];\r
-\r
- switch(ltype){\r
- case LITERAL_STRING:\r
- retval.append(this->hfta_constructor_name() );\r
- retval.append("("+param+",\"");\r
- retval.append(gsqlstr_to_cstr(lstring));\r
- retval.append("\")");\r
- return(retval);\r
- case LITERAL_INT:\r
- case LITERAL_IP:\r
- return("((gs_uint32_t)"+lstring+")");\r
- case LITERAL_LONGINT:\r
- return("((gs_uint64_t)"+lstring+")");\r
- case LITERAL_FLOAT:\r
- return(lstring);\r
-// case LITERAL_HEX:\r
-// return("0x"+lstring);\r
- case LITERAL_BOOL:\r
- if(lstring == "TRUE"){\r
- return("1");\r
- }else{\r
- return("0");\r
- }\r
- case LITERAL_TIMEVAL:\r
- retval.append(this->hfta_constructor_name() );\r
- tmp_f = atof(lstring.c_str());\r
- secs = (int)floor(tmp_f);\r
- millisecs = (int) rint((tmp_f - secs)*1000);\r
- sprintf(tmpstr,"(%d, %d)",secs,millisecs);\r
- retval.append(tmpstr);\r
- return(retval);\r
- case LITERAL_IPV6:\r
- retval = this->hfta_constructor_name();\r
- retval += "("+param+",\""+lstring+"\")";\r
- return retval;\r
- }\r
-\r
- return("ERROR UNKNOWN LITERAL");\r
- };\r
-\r
-\r
-/// for LFTA code generation\r
- std::string to_C_code(std::string param){\r
- std::string retval;\r
- double tmp_f;\r
- int secs, millisecs;\r
- char tmpstr[100];\r
-\r
- switch(ltype){\r
- case LITERAL_STRING:\r
- retval = this->constructor_name()+"("+param+",\""+gsqlstr_to_cstr(lstring)+"\")";\r
- return(retval);\r
- case LITERAL_INT:\r
- case LITERAL_IP:\r
- return("((gs_uint32_t)"+lstring+")");\r
- case LITERAL_LONGINT:\r
- return("((gs_uint64_t)"+lstring+")");\r
- case LITERAL_FLOAT:\r
- return(lstring);\r
-// case LITERAL_HEX:\r
-// return("0x"+lstring);\r
- case LITERAL_BOOL:\r
- if(lstring == "TRUE"){\r
- return("1");\r
- }else{\r
- return("0");\r
- }\r
- case LITERAL_IPV6:\r
- retval = this->constructor_name()+"("+param+",\""+lstring+"\")";\r
- return(retval);\r
- case LITERAL_TIMEVAL:\r
- retval.append(this->constructor_name() );\r
- tmp_f = atof(lstring.c_str());\r
- secs = (int)floor(tmp_f);\r
- millisecs = (int) rint((tmp_f - secs)*1000);\r
- sprintf(tmpstr,"(%d, %d)",secs,millisecs);\r
- retval.append(tmpstr);\r
- return(retval);\r
- }\r
-\r
- return("ERROR UNKNOWN LITERAL");\r
- };\r
-\r
-\r
- std::string to_query_string(){\r
- std::string retval;\r
-\r
- switch(ltype){\r
- case LITERAL_IP:\r
- {\r
- unsigned int v;\r
- sscanf(lstring.c_str(),"%u",&v);\r
- int d1 = v & 0xff;\r
- int d2 = (v & 0xff00) >> 8;\r
- int d3 = (v & 0xff0000) >> 16;\r
- int d4 = (v & 0xff000000) >> 24;\r
- char ret[200];\r
- sprintf(ret,"IP_VAL'%u.%u.%u.%u'",d4,d3,d2,d1);\r
- return ret;\r
- }\r
- case LITERAL_STRING:\r
- retval = "'"+lstring+"'";\r
- return(retval);\r
- case LITERAL_INT:\r
- case LITERAL_FLOAT:\r
- case LITERAL_TIMEVAL:\r
- case LITERAL_IPV6:\r
- case LITERAL_BOOL:\r
- return(lstring);\r
- case LITERAL_LONGINT:\r
- return(lstring+"ULL");\r
- }\r
-\r
- return("ERROR UNKNOWN LITERAL in literal_t::to_query_string");\r
- };\r
-\r
-// TODO : Use definition files instead of hardwiring these.\r
-\r
-// constructor in LFTA code\r
- std::string constructor_name(){\r
-\r
- switch(ltype){\r
- case LITERAL_TIMEVAL:\r
- return("Timeval_Constructor");\r
- case LITERAL_IPV6:\r
- return("Ipv6_Constructor");\r
- case LITERAL_STRING:\r
- return("str_constructor");\r
- case LITERAL_INT:\r
- case LITERAL_IP:\r
- case LITERAL_LONGINT:\r
- case LITERAL_BOOL:\r
- case LITERAL_FLOAT:\r
- return("");\r
- }\r
- return("ERROR UNKNOWN LITERAL");\r
- };\r
-\r
- std::string hfta_constructor_name(){\r
-\r
- switch(ltype){\r
- case LITERAL_TIMEVAL:\r
- return("HFTA_Timeval_Constructor");\r
- case LITERAL_IPV6:\r
- return("HFTA_Ipv6_Constructor");\r
- case LITERAL_STRING:\r
- return("Vstring_Constructor");\r
- case LITERAL_INT:\r
- case LITERAL_IP:\r
- case LITERAL_LONGINT:\r
- case LITERAL_BOOL:\r
- case LITERAL_FLOAT:\r
- return("");\r
- }\r
- return("ERROR UNKNOWN LITERAL");\r
- };\r
-\r
- std::string hfta_empty_literal_name(){\r
-\r
- switch(ltype){\r
- case LITERAL_TIMEVAL:\r
- return("EmptyTimeval");\r
- case LITERAL_IPV6:\r
- return("EmptyIp6");\r
- case LITERAL_STRING:\r
- return("EmptyString");\r
- }\r
- return("ERROR_NOT_A_COMPLEX_LITERAL");\r
- };\r
-\r
-\r
- void set_cpx_lit_ref(int g){complex_literal_id = g; };\r
- int get_cpx_lit_ref(){return (complex_literal_id ); };\r
- bool is_cpx_lit(){return(complex_literal_id >= 0); };\r
-\r
-};\r
-\r
-\r
-/*\r
- A (null terminated) list of literals.\r
- Used for the IN clause\r
-*/\r
-\r
-class literal_list_t{\r
-private:\r
-\r
-public:\r
- std::vector<literal_t *> lit_list;\r
- int lineno, charno;\r
-\r
- literal_list_t(literal_t *l){\r
- lit_list.push_back(l);\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- literal_list_t(std::vector<literal_t *> lvec){\r
- lineno = charno = 0;\r
- lit_list = lvec;\r
- };\r
-\r
- literal_list_t *append_literal(literal_t *l){\r
- lit_list.push_back(l);\r
- return(this);\r
- };\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
- for(i=0;i<lit_list.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(lit_list[i]->to_query_string());\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<literal_t *> get_literal_vector(){return(lit_list);};\r
-\r
-};\r
-\r
-\r
-class string_t{\r
-public:\r
- std::string val;\r
- string_t(char *s){\r
- val = s;\r
- }\r
- string_t *append(char *s){\r
- val += s;\r
- return this;\r
- }\r
- string_t *append(char *sep, char *s){\r
- val += sep;\r
- val += s;\r
- return this;\r
- }\r
- const char *c_str(){\r
- return val.c_str();\r
- }\r
-};\r
-\r
-// A tablevar is a data source in a GSQL query.\r
-// Every column ref must be bound to a tablevar,\r
-// either explicitly or via imputation.\r
-\r
-\r
-class tablevar_t{\r
-public:\r
-// A tablevar is a variable which binds to a named data source.\r
-// the variable name might be explicit in the query, or it might be\r
-// implicit in which case the variable name is imputed. In either case\r
-// the variable name is set via the set_range_var method.\r
-//\r
-// The data source is the name of either a STREAM or a PROTOCOL.\r
-// All STREAMS are unique, but a PROTOCOL must be bound to an\r
-// interface. If the interface is not given, it is imputed to be\r
-// the default interface.\r
-\r
- std::string machine;\r
- std::string interface;\r
- std::string schema_name;\r
- std::string variable_name;\r
- std::string udop_alias; // record UDOP ID for of UDOP\r
- // for use by cluster manager\r
-\r
- int schema_ref; // index of the table in the schema (table_list)\r
- int opview_idx; // index in list of operator views (if any)\r
- bool iface_is_query; // true if iface resolves to query\r
- // instead of specific interface.\r
-\r
- int properties; // inner (0) or outer (1) join;\r
- // labeled using FROM clause,\r
- // determines join algorithm.\r
-\r
- int lineno, charno;\r
-\r
- tablevar_t(){ opview_idx = -1; schema_ref=-1; iface_is_query = false;\r
- lineno=-1; charno=-1;};\r
- tablevar_t(const char *t){schema_name=t; interface="";\r
- opview_idx = -1; schema_ref = -1;\r
- variable_name=""; properties = 0;\r
- iface_is_query = false;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- tablevar_t(const char *i, const char *s, int iq){interface=i; schema_name=s;\r
- opview_idx = -1; schema_ref = -1;\r
- variable_name=""; properties = 0;\r
- if(iq) iface_is_query = true; else iface_is_query = false;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- tablevar_t(const char *m, const char *i, const char *s){\r
- machine = m; interface=i; schema_name=s;\r
- opview_idx = -1; schema_ref = -1;\r
- variable_name=""; properties = 0;\r
- iface_is_query = false;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- tablevar_t *duplicate(){\r
- tablevar_t *ret = new tablevar_t();\r
- ret->lineno = lineno; ret->charno = charno;\r
- ret->schema_ref = schema_ref;\r
- ret->opview_idx = opview_idx;\r
- ret->machine = machine;\r
- ret->interface = interface;\r
- ret->schema_name = schema_name;\r
- ret->variable_name = variable_name;\r
- ret->properties = properties;\r
- ret->iface_is_query = iface_is_query;\r
- return(ret);\r
- };\r
-\r
- tablevar_t *set_range_var(const char *r){\r
- variable_name = r;\r
- return(this);\r
- };\r
- tablevar_t *set_range_var(std::string r){\r
- variable_name = r;\r
- return(this);\r
- };\r
-\r
- void set_schema(std::string s){schema_name = s;};\r
- void set_interface(std::string i){interface=i;};\r
- void set_machine(std::string m){machine = m;};\r
- void set_udop_alias(std::string u){udop_alias = u;};\r
-\r
- void set_schema_ref(int r){schema_ref = r;};\r
- int get_schema_ref(){return schema_ref;};\r
-\r
- void set_opview_idx(int i){opview_idx = i;};\r
- int get_opview_idx(){return opview_idx;};\r
-\r
- void set_property(int p){properties = p;};\r
- int get_property(){return properties;};\r
-\r
- bool get_ifq(){return iface_is_query;};\r
- void set_ifq(bool b){iface_is_query = b;};\r
-\r
- std::string to_string(){\r
- std::string retval;\r
-\r
- if(machine != "" && !iface_is_query)\r
- retval += "'"+machine+"'.";\r
- if(interface != ""){\r
- if(iface_is_query){\r
- retval += '['+interface+"].";\r
- }else{\r
- retval += interface+".";\r
- }\r
- }\r
- retval += schema_name;\r
- if(variable_name != "") retval+=" "+variable_name;\r
-\r
- return(retval);\r
- };\r
-\r
- std::string get_schema_name(){return schema_name;};\r
- void set_schema_name(std::string n){schema_name=n;};\r
- std::string get_var_name(){return variable_name;};\r
- std::string get_interface(){return interface;};\r
- std::string get_machine(){return machine;};\r
- std::string get_udop_alias(){return udop_alias;};\r
-\r
- int get_lineno(){return(lineno); };\r
- int get_charno(){return(charno); };\r
-\r
-};\r
-\r
-#define INNER_JOIN_PROPERTY 0\r
-#define LEFT_OUTER_JOIN_PROPERTY 1\r
-#define RIGHT_OUTER_JOIN_PROPERTY 2\r
-#define OUTER_JOIN_PROPERTY 3\r
-#define FILTER_JOIN_PROPERTY 4\r
-\r
-// tablevar_list_t is the list of tablevars in a FROM clause\r
-\r
-struct tablevar_list_t{\r
-public:\r
- std::vector<tablevar_t *> tlist;\r
- int properties;\r
- int lineno, charno;\r
-// For filter join\r
- colref_t *temporal_var;\r
- unsigned int temporal_range;\r
-\r
- tablevar_list_t(){properties = -1; temporal_var = NULL;}\r
- tablevar_list_t(tablevar_t *t){tlist.push_back(t); properties=-1; temporal_var = NULL;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
- tablevar_list_t(std::vector<tablevar_t *> t){tlist = t; properties=-1; temporal_var = NULL;\r
- lineno = 0; charno = 0;};\r
-\r
- tablevar_list_t *duplicate(){\r
- tablevar_list_t *ret = new tablevar_list_t();\r
- ret->lineno = lineno; ret->charno = charno;\r
- ret->properties = properties;\r
- ret->temporal_var = temporal_var;\r
- ret->temporal_range = temporal_range;\r
- int i;\r
- for(i=0;i<tlist.size();++i){\r
- ret->append_table(tlist[i]->duplicate());\r
- }\r
- return(ret);\r
- }\r
-\r
-\r
-\r
- tablevar_list_t *append_table(tablevar_t *t){\r
- tlist.push_back(t);\r
- return(this);\r
- };\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
-\r
- for(i=0;i<tlist.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(tlist[i]->to_string());\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<tablevar_t *> get_table_list(){return(tlist); };\r
-\r
- std::vector<std::string> get_table_names(){\r
- std::vector<std::string> ret;\r
- int t;\r
- for(t=0;t<tlist.size();++t){\r
- std::string tbl_name = tlist[t]->get_schema_name();\r
- ret.push_back(tbl_name);\r
- }\r
- return(ret);\r
- }\r
-\r
- std::vector<std::string> get_src_tbls(table_list *Schema){\r
- std::vector<std::string> ret;\r
- int t, sq;\r
- for(t=0;t<tlist.size();++t){\r
- std::string tbl_name = tlist[t]->get_schema_name();\r
- int sid = Schema->find_tbl(tbl_name);\r
- if(sid < 0){ ret.push_back(tbl_name);\r
- }else\r
- if(Schema->get_schema_type(sid) != OPERATOR_VIEW_SCHEMA){\r
- ret.push_back(tbl_name);\r
- }else{\r
- std::vector<subquery_spec *> sqspec = Schema->get_subqueryspecs(sid);\r
- for(sq=0;sq<sqspec.size();++sq){\r
- ret.push_back(sqspec[sq]->name);\r
- }\r
- }\r
- }\r
- return(ret);\r
- };\r
-\r
- int size(){\r
- return tlist.size();\r
- };\r
-\r
-// Some accessor functions.\r
-\r
- std::vector<std::string> get_schema_names(){\r
- int i;\r
- std::vector<std::string > retval;\r
- for(i=0;i<tlist.size();i++){\r
- retval.push_back(tlist[i]->get_schema_name());\r
- }\r
- return(retval);\r
- }\r
-\r
- std::vector<int> get_schema_refs(){\r
- int i;\r
- std::vector<int> retval;\r
- for(i=0;i<tlist.size();i++){\r
- retval.push_back(tlist[i]->get_schema_ref());\r
- }\r
- return(retval);\r
- }\r
-\r
-\r
- int get_schema_ref(int i){\r
- if(i<0 || i>=tlist.size()) return(-1);\r
- return tlist[i]->get_schema_ref();\r
- };\r
-\r
- std::string get_tablevar_name(int i){\r
- if(i<0 || i>=tlist.size()) return("");\r
- return tlist[i]->get_var_name();\r
- };\r
-\r
- void set_properties(int p){properties = p;};\r
- int get_properties(){return properties;};\r
-\r
- void set_colref(colref_t *c){temporal_var = c;};\r
- void set_temporal_range(unsigned int t){temporal_range = t;};\r
- void set_temporal_range(const char *t){temporal_range= atoi(t);};\r
- colref_t *get_colref(){return temporal_var;};\r
- unsigned int get_temporal_range(){return temporal_range;};\r
-\r
-};\r
-\r
-// A reference to an interface parameter.\r
-// (I need to be able to record the source\r
-// tablevar, else this would be a lot simpler).\r
-class ifpref_t{\r
-public:\r
- std::string tablevar;\r
- std::string pname;\r
- int tablevar_ref;\r
- int lineno, charno;\r
-\r
- ifpref_t(const char *p){\r
- tablevar="";\r
- pname = p;\r
- tablevar_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- ifpref_t(const char *t, const char *p){\r
- tablevar=t;\r
- pname = p;\r
- tablevar_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- void set_tablevar_ref(int i){tablevar_ref = i;};\r
- int get_tablevar_ref(){return tablevar_ref;};\r
- std::string get_tablevar(){return tablevar;}\r
- void set_tablevar(std::string t){tablevar = t;};\r
- std::string get_pname(){return pname;}\r
- std::string to_string(){\r
- std::string ret;\r
- if(tablevar != "")\r
- ret += tablevar + ".";\r
- ret += "@"+pname;\r
- return ret;\r
- };\r
- bool is_equivalent(ifpref_t *i){\r
- return (tablevar_ref == i->tablevar_ref) && (pname == i->pname);\r
- };\r
-};\r
-\r
-\r
-\r
-\r
-// A representation of a reference to a field of a\r
-// stream (or table). This reference must be bound\r
-// to a particular schema (schema_ref) and to a\r
-// particular table variable in the FROM clause (tablevar_ref)\r
-// If the column reference was generated by the parser,\r
-// it will contain some binding text wich might need\r
-// interpretation to do the actual binding.\r
-class colref_t{\r
-public:\r
- std::string interface; // specified interface, if any.\r
- std::string table_name; // specified table name or range var, if any.\r
- std::string field; // field name\r
- bool default_table; // true iff. no table or range var given.\r
- int schema_ref; // ID of the source schema.\r
- int tablevar_ref; // ID of the tablevar (in FROM clause).\r
- int lineno, charno;\r
-\r
- colref_t(const char *f){\r
- field = f; default_table = true;\r
- schema_ref = -1; tablevar_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- colref_t(const char *t, const char *f){\r
- table_name = t; field=f; default_table = false;\r
- schema_ref = -1; tablevar_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- colref_t(const char *i, const char *t, const char *f){\r
- interface=i;\r
- table_name = t; field=f; default_table = false;\r
- schema_ref = -1; tablevar_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- colref_t *duplicate(){\r
- colref_t *retval = new colref_t(interface.c_str(), table_name.c_str(), field.c_str());\r
- retval->schema_ref = schema_ref;\r
- retval->tablevar_ref = tablevar_ref;\r
- retval->lineno = lineno;\r
- retval->charno = charno;\r
- retval->default_table = default_table;\r
- return(retval);\r
- }\r
-\r
- std::string to_string(){\r
- if(default_table){\r
- return field;\r
- }else{\r
- if(interface != "") return(interface+"."+table_name+"."+field);\r
- return(table_name + "." + field);\r
- }\r
- };\r
-\r
- std::string to_query_string(){\r
- if(default_table){\r
- return field;\r
- }else{\r
- if(interface != "") return(interface+"."+table_name+"."+field);\r
- if(table_name != "") return(table_name + "." + field);\r
- return(field);\r
- }\r
- };\r
-\r
- int get_lineno(){return lineno; };\r
- int get_charno(){return charno; };\r
-\r
- bool uses_default_table(){return default_table; };\r
-\r
- std::string get_field(){return(field); };\r
- void set_field(std::string f){field=f;};\r
- std::string get_table_name(){return(table_name);};\r
- std::string get_interface(){return(interface);};\r
- void set_table_name(std::string t){table_name = t; default_table=false;};\r
- void set_interface(std::string i){interface=i;};\r
-\r
- int get_schema_ref(){return schema_ref;}\r
- void set_schema_ref(int s){schema_ref = s;};\r
- int get_tablevar_ref(){return tablevar_ref;}\r
- void set_tablevar_ref(int s){tablevar_ref = s;};\r
-\r
-// Should equivalence be based on tablevar_ref or schema_ref?\r
- bool is_equivalent(colref_t *c2){\r
- if(schema_ref == c2->schema_ref){\r
- return(field == c2->field);\r
- }\r
- return(false);\r
- };\r
-\r
- bool is_equivalent_base(colref_t *c2, table_list *Schema){\r
- if(Schema->get_basetbl_name(schema_ref,field) ==\r
- Schema->get_basetbl_name(c2->schema_ref,c2->field)){\r
- return(field == c2->field);\r
- }\r
- return(false);\r
- };\r
-};\r
-\r
-class colref_list_t{\r
-public:\r
- std::vector<colref_t *> clist;\r
-\r
-// colref_list_t(){};\r
-\r
- colref_list_t(colref_t *c){\r
- clist.push_back(c);\r
- }\r
-\r
- colref_list_t *append(colref_t *c){\r
- clist.push_back(c);\r
- return this;\r
- }\r
-\r
- std::vector<colref_t *> get_clist(){\r
- return clist;\r
- }\r
-};\r
-\r
-\r
-\r
-\r
-\r
-\r
-/*\r
- A tree containing a scalar expression.\r
- Used for\r
- atom : a parameter or a literal\r
- scalar_exp (see the scalar_exp: rule in emf.l for details)\r
- function_ref (a function that has a value, e.g. an aggregate\r
- function).\r
- operator_type defines the contents of the node. If its a non-terminal,\r
- then op has a meaning and defines the operation. See the list of\r
- #define'd constants following the structure definition.\r
-\r
-\r
-*/\r
-\r
-#define SE_LITERAL 1\r
-#define SE_PARAM 2\r
-#define SE_COLREF 3\r
-#define SE_UNARY_OP 4\r
-#define SE_BINARY_OP 5\r
-#define SE_AGGR_STAR 6\r
-#define SE_AGGR_SE 7\r
-#define SE_FUNC 8\r
-#define SE_IFACE_PARAM 9\r
-\r
-\r
-class scalarexp_t{\r
-public:\r
- int operator_type;\r
- std::string op;\r
- union{\r
- scalarexp_t *scalarp;\r
- literal_t *litp;\r
- colref_t *colref;\r
- ifpref_t *ifp;\r
- } lhs;\r
- union{\r
- scalarexp_t *scalarp;\r
- } rhs;\r
- std::vector<scalarexp_t *> param_list;\r
-\r
-// SE node decorations -- results of query analysis.\r
- data_type *dt;\r
- int gb_ref; // set to the gb attr tbl ref, else -1\r
- int aggr_id; // set to the aggr tbl ref, else -1\r
- int fcn_id; // external function table ref, else -1\r
- int partial_ref; // partial fcn table ref, else -1\r
- int fcn_cache_ref; // function cache ref, else -1\r
- int handle_ref; // Entry in pass-by-handle parameter table, else -1.\r
- // (might be a literal or a query param).\r
- bool is_superagg; // true if is aggregate and associated with supergroup.\r
- std::string storage_state; // storage state of stateful fcn,\r
- // empty o'wise.\r
-\r
- int lineno, charno;\r
-\r
- void default_init(){\r
- operator_type = 0;\r
- gb_ref = -1; aggr_id = -1; fcn_id = -1;\r
- partial_ref = -1; fcn_cache_ref=-1;\r
- handle_ref = -1;\r
- dt = NULL; lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- is_superagg = false;\r
- };\r
-\r
- scalarexp_t(){\r
- default_init();};\r
-\r
- scalarexp_t(colref_t *c){\r
- default_init();\r
- operator_type = SE_COLREF;\r
- lhs.colref = c;\r
- };\r
-\r
- scalarexp_t(literal_t *l){\r
- default_init();\r
- operator_type = SE_LITERAL;\r
- lhs.litp = l;\r
- };\r
-\r
- void convert_to_literal(literal_t *l){\r
-// default_init();\r
- if(operator_type != SE_IFACE_PARAM){\r
- fprintf(stderr,"INTERNAL ERROR in literal_t::convert_to_literal, operator type isn't SE_IFACE_PARAM.\n");\r
- exit(1);\r
- }\r
- operator_type = SE_LITERAL;\r
- lhs.litp = l;\r
- }\r
-\r
- scalarexp_t(const char *o, scalarexp_t *operand){\r
- default_init();\r
- operator_type = SE_UNARY_OP;\r
- op = o;\r
- lhs.scalarp = operand;\r
- };\r
-\r
- scalarexp_t(const char *o, scalarexp_t *l_op, scalarexp_t *r_op){\r
- default_init();\r
- operator_type = SE_BINARY_OP;\r
- op = o;\r
- lhs.scalarp = l_op;\r
- rhs.scalarp = r_op;\r
- };\r
-\r
- scalarexp_t(const char *o, std::vector<scalarexp_t *> op_list){\r
- default_init();\r
- operator_type = SE_FUNC;\r
- op = o;\r
- param_list = op_list;\r
- };\r
-\r
- static scalarexp_t *make_paramless_fcn(const char *o){\r
- scalarexp_t *ret = new scalarexp_t();\r
- ret->operator_type = SE_FUNC;\r
- ret->op = o;\r
- return(ret);\r
- };\r
-\r
- static scalarexp_t *make_star_aggr(const char *ag){\r
- scalarexp_t *ret = new scalarexp_t();\r
- ret->operator_type = SE_AGGR_STAR;\r
- ret->op = ag;\r
- return(ret);\r
- };\r
-\r
- static scalarexp_t *make_se_aggr(const char *ag, scalarexp_t *l_op){\r
- scalarexp_t *ret = new scalarexp_t();\r
- ret->operator_type = SE_AGGR_SE;\r
- ret->op = ag;\r
- ret->lhs.scalarp = l_op;\r
- return(ret);\r
- };\r
-\r
- static scalarexp_t *make_param_reference(const char *param){\r
- scalarexp_t *ret = new scalarexp_t();\r
- ret->operator_type = SE_PARAM;\r
- ret->op = param;\r
- return(ret);\r
- };\r
-\r
- static scalarexp_t *make_iface_param_reference(ifpref_t *i){\r
- scalarexp_t *ret = new scalarexp_t();\r
- ret->operator_type = SE_IFACE_PARAM;\r
- ret->lhs.ifp = i;\r
- return(ret);\r
- };\r
-\r
-\r
- std::string to_string(){\r
- if(operator_type == SE_COLREF){\r
- return lhs.colref->to_string();\r
- }\r
- if(operator_type == SE_LITERAL){\r
- return lhs.litp->to_string();\r
- }\r
- if(operator_type == SE_UNARY_OP){\r
- return op + " (" + lhs.scalarp->to_string() + ")";\r
- }\r
- if(operator_type == SE_BINARY_OP){\r
- return "(" + lhs.scalarp->to_string() + " " + op + " " + rhs.scalarp->to_string() + ")";\r
- }\r
- return("");\r
- };\r
-\r
- scalarexp_t *get_left_se(){return lhs.scalarp; };\r
- scalarexp_t *get_right_se(){return rhs.scalarp; };\r
- int get_operator_type(){return operator_type; };\r
- std::string & get_op(){return op; };\r
- std::string & get_param_name(){return op; };\r
-// std::string & get_iface_param_name(){return op; };\r
- colref_t *get_colref(){return lhs.colref; };\r
- ifpref_t *get_ifpref(){return lhs.ifp; };\r
- literal_t *get_literal(){return lhs.litp; };\r
-\r
- int get_lineno(){return lineno; };\r
- int get_charno(){return charno; };\r
-\r
- void set_data_type(data_type *d){dt=d; };\r
- data_type *get_data_type(){return dt; };\r
- void reset_temporal(){if(dt!=NULL) dt->reset_temporal();}\r
-\r
- void set_gb_ref(int g){gb_ref = g; };\r
- int get_gb_ref(){return (gb_ref); };\r
- bool is_gb(){return(gb_ref >= 0); };\r
-\r
- void set_aggr_id(int a){aggr_id = a;};\r
- int get_aggr_ref(){return(aggr_id); };\r
-\r
- void set_storage_state(std::string s){storage_state = s;};\r
- std::string get_storage_state(){return storage_state;};\r
-\r
- std::vector<scalarexp_t *> get_operands(){return param_list;};\r
- void set_fcn_id(int f){fcn_id = f; };\r
- int get_fcn_id(){return fcn_id; };\r
-\r
- void set_partial_ref(int p){partial_ref = p; };\r
- int get_partial_ref(){return partial_ref; };\r
- bool is_partial(){return partial_ref >= 0; };\r
-\r
- void set_fcncache_ref(int p){fcn_cache_ref = p; };\r
- int get_fcncache_ref(){return fcn_cache_ref; };\r
- bool is_fcncached(){return fcn_cache_ref >= 0; };\r
-\r
- void set_handle_ref(int tf){handle_ref = tf; };\r
- int get_handle_ref(){return handle_ref; };\r
- bool is_handle_ref(){return handle_ref>=0; };\r
-\r
- void set_superaggr(bool b){is_superagg=b;};\r
- bool is_superaggr(){return is_superagg;};\r
-\r
- void use_decorations_of(scalarexp_t *se){\r
- if(se->get_data_type() != NULL)\r
- dt = se->get_data_type()->duplicate();\r
- gb_ref = se->gb_ref;\r
- aggr_id = se->aggr_id;\r
- fcn_id = se->fcn_id;\r
- partial_ref = se->partial_ref;\r
- handle_ref = se->handle_ref;\r
- lineno = se->lineno;\r
- charno = se->charno;\r
- is_superagg = se->is_superagg;\r
- };\r
-};\r
-\r
-\r
-/*\r
- A (null terminated) list of scalar expressions.\r
- Used for\r
- selection, scalar_exp_commalist\r
-*/\r
-\r
-class se_list_t{\r
-public:\r
- std::vector<scalarexp_t *> se_list;\r
- int lineno, charno;\r
-\r
- se_list_t(scalarexp_t *s){se_list.push_back(s);\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- se_list_t *append(scalarexp_t *s){\r
- se_list.push_back(s);\r
- return(this);\r
- };\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
- for(i=0;i<se_list.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(se_list[i]->to_string());\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<scalarexp_t *> get_se_list(){return se_list; };\r
-\r
-\r
-};\r
-\r
-/*\r
- select_commalist : collect some additional info about\r
- the selected things -- mostly the name.\r
-*/\r
-\r
-struct select_element{\r
- scalarexp_t *se;\r
- std::string name;\r
-\r
- select_element(){se=NULL; name="";};\r
- select_element(scalarexp_t *s){se=s; name="";};\r
- select_element(scalarexp_t *s, std::string n){se=s; name=n;};\r
-};\r
-\r
-class select_list_t{\r
-public:\r
- std::vector<select_element *> select_list;\r
- int lineno, charno;\r
-\r
- select_list_t(){lineno = -1; charno = -1;};\r
- select_list_t(scalarexp_t *s){select_list.push_back(new select_element(s));\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
- select_list_t(scalarexp_t *s, std::string n){\r
- select_list.push_back(new select_element(s,n));\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
- select_list_t *append(scalarexp_t *s){\r
- select_list.push_back(new select_element(s));\r
- return(this);\r
- };\r
- select_list_t *append(scalarexp_t *s, std::string n){\r
- select_list.push_back(new select_element(s,n));\r
- return(this);\r
- };\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
- for(i=0;i<select_list.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(select_list[i]->se->to_string());\r
- if(select_list[i]->name != "")\r
- retval += " AS " + select_list[i]->name;\r
-\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<select_element *> get_select_list(){return select_list; };\r
- std::vector<scalarexp_t *> get_select_se_list(){\r
- std::vector<scalarexp_t *> ret;\r
- int i;\r
- for(i=0; i<select_list.size();++i) ret.push_back(select_list[i]->se);\r
- return ret;\r
- };\r
-};\r
-\r
-\r
-\r
-#define GB_COLREF 1\r
-#define GB_COMPUTED 2\r
-\r
-class gb_t{\r
-public:\r
- std::string name;\r
- std::string table;\r
- std::string interface;\r
- scalarexp_t *def;\r
- int type;\r
- int lineno, charno;\r
-\r
- gb_t(const char *field_name){\r
- interface="";\r
- name = field_name; table=""; def=NULL; type=GB_COLREF;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- gb_t(const char *table_name, const char *field_name){\r
- interface="";\r
- name = field_name; table=""; def=NULL; type=GB_COLREF;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- gb_t(const char *iface, const char *table_name, const char *field_name){\r
- interface=iface;\r
- name = field_name; table=""; def=NULL; type=GB_COLREF;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- gb_t( scalarexp_t *s, const char *gname){\r
- name = gname; table = ""; def = s; type = GB_COMPUTED;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- std::string to_string(){\r
- std::string retval;\r
- if(type == GB_COLREF){\r
- if(table != ""){\r
- retval = table;\r
- retval.append(".");\r
- }\r
- retval.append(name);\r
- }\r
- if(type == GB_COMPUTED){\r
- retval = "(scalarexp) AS ";\r
- retval.append(name);\r
- }\r
- return(retval);\r
- };\r
-\r
- gb_t *duplicate();\r
-\r
-};\r
-\r
-/*\r
- A (null terminated) list of group by attributes\r
-*/\r
-\r
-class gb_list_t{\r
-public:\r
- std::vector<gb_t *> gb_list;\r
- int lineno, charno;\r
-\r
- gb_list_t(gb_t *g){gb_list.push_back(g);\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- gb_list_t *append(gb_t *s){\r
- gb_list.push_back(s);\r
- return(this);\r
- };\r
- gb_list_t(int l, int c) : lineno(l), charno(c){ }\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
- for(i=0;i<gb_list.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(gb_list[i]->to_string());\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<gb_t *> get_gb_list(){return gb_list; };\r
-\r
- gb_list_t *duplicate(){\r
- gb_list_t *ret = new gb_list_t(lineno, charno);\r
- int i;\r
- for(i=0;i<gb_list.size();++i){\r
- ret->append(gb_list[i]->duplicate());\r
- }\r
-\r
- return ret;\r
- }\r
-\r
-\r
-};\r
-\r
-class list_of_gb_list_t{\r
-public:\r
- std::vector<gb_list_t *> gb_lists;\r
-\r
- list_of_gb_list_t(gb_list_t *gl){\r
- gb_lists.push_back(gl);\r
- }\r
-\r
- list_of_gb_list_t *append(gb_list_t *gl){\r
- gb_lists.push_back(gl);\r
- return this;\r
- }\r
-};\r
-\r
-\r
-enum extended_gb_type {no_egb_type, gb_egb_type, rollup_egb_type,\r
- cube_egb_type, gsets_egb_type};\r
-class extended_gb_t{\r
-public:\r
-\r
- extended_gb_type type;\r
- gb_t *gb;\r
- std::vector<gb_list_t *> gb_lists;\r
-\r
- extended_gb_t(){\r
- gb = NULL;\r
- type = no_egb_type;\r
- }\r
-\r
- ~extended_gb_t(){\r
- }\r
-\r
- static extended_gb_t *create_from_gb(gb_t *g){\r
- extended_gb_t *ret = new extended_gb_t();\r
- ret->type = gb_egb_type;\r
- ret->gb = g;\r
- return ret;\r
- }\r
-\r
- static extended_gb_t *extended_create_from_rollup(gb_list_t *gl){\r
- extended_gb_t *ret = new extended_gb_t();\r
- ret->type = rollup_egb_type;\r
- ret->gb_lists.push_back(gl);\r
- return ret;\r
- }\r
-\r
- static extended_gb_t *extended_create_from_cube(gb_list_t *gl){\r
- extended_gb_t *ret = new extended_gb_t();\r
- ret->type = cube_egb_type;\r
- ret->gb_lists.push_back(gl);\r
- return ret;\r
- }\r
-\r
- static extended_gb_t *extended_create_from_gsets(list_of_gb_list_t *lgl){\r
- extended_gb_t *ret = new extended_gb_t();\r
- ret->type = gsets_egb_type;\r
- ret->gb_lists = lgl->gb_lists;\r
- return ret;\r
- }\r
-\r
- extended_gb_t *duplicate(){\r
- extended_gb_t *ret = new extended_gb_t();\r
- ret->type = type;\r
- if(gb != NULL)\r
- ret->gb = gb->duplicate();\r
- int i;\r
- for(i=0;i<gb_lists.size();++i){\r
- ret->gb_lists.push_back(gb_lists[i]->duplicate());\r
- }\r
- return ret;\r
- }\r
-\r
-\r
- std::string to_string(){\r
- std::string ret;\r
- int i;\r
-\r
- switch(type){\r
- case no_egb_type:\r
- return "Error, undefined extended gb type.";\r
- case gb_egb_type:\r
- return gb->to_string();\r
- case rollup_egb_type:\r
- return "ROLLUP("+gb_lists[0]->to_string()+")";\r
- case cube_egb_type:\r
- return "CUBE("+gb_lists[0]->to_string()+")";\r
- case gsets_egb_type:\r
- ret = "GROUPING_SETS(";\r
- for(i=0;i<gb_lists.size();++i){\r
- if(i>0) ret+=", ";\r
- ret += "(" +gb_lists[i]->to_string()+")";\r
- }\r
- ret += ")";\r
- return ret;\r
- default:\r
- break;\r
- }\r
- return "Error, unknown extended gb type.";\r
- }\r
-\r
-};\r
-\r
-class extended_gb_list_t{\r
-public:\r
- std::vector<extended_gb_t *> gb_list;\r
- int lineno, charno;\r
-\r
- extended_gb_list_t(extended_gb_t *g){gb_list.push_back(g);\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;};\r
-\r
- extended_gb_list_t *append(extended_gb_t *s){\r
- gb_list.push_back(s);\r
- return(this);\r
- };\r
-\r
- std::string to_string(){\r
- int i;\r
- std::string retval;\r
- for(i=0;i<gb_list.size();i++){\r
- if(i>0) retval.append(", ");\r
- retval.append(gb_list[i]->to_string());\r
- }\r
- return(retval);\r
- };\r
-\r
- std::vector<extended_gb_t *> get_gb_list(){return gb_list; };\r
-};\r
-\r
-\r
-\r
-/*\r
- A predicate tree. Structure is similar to\r
- a scalar expression tree but the type is always boolean.\r
- Used by\r
- opt_where_clause, where_clause, opt_having_clause,\r
- search_condition, predicate, comparison_predicate, repl_predicate\r
-*/\r
-\r
-#define PRED_COMPARE 1\r
-#define PRED_UNARY_OP 2\r
-#define PRED_BINARY_OP 3\r
-#define PRED_FUNC 4\r
-#define PRED_IN 5\r
-\r
-class predicate_t{\r
-public:\r
- int operator_type;\r
- std::string op;\r
- union {\r
- predicate_t *predp;\r
- scalarexp_t *sexp;\r
- }lhs;\r
- union {\r
- predicate_t *predp;\r
- scalarexp_t *sexp;\r
- literal_list_t *ll;\r
- }rhs;\r
- std::vector<scalarexp_t *> param_list; /// pred fcn params\r
- int fcn_id; /// external pred fcn id\r
- int combinable_ref;\r
- bool is_sampling_fcn;\r
- int lineno, charno;\r
-\r
- predicate_t(scalarexp_t *s, literal_list_t *litl){\r
- operator_type = PRED_IN;\r
- op = "in";\r
- lhs.sexp = s;\r
- rhs.ll = litl;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- predicate_t(scalarexp_t *s, std::vector<literal_t *> litv){\r
- operator_type = PRED_IN;\r
- op = "in";\r
- lhs.sexp = s;\r
- rhs.ll = new literal_list_t(litv);\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
-\r
- predicate_t(scalarexp_t *l_op, const char *o, scalarexp_t *r_op){\r
- operator_type = PRED_COMPARE;\r
- op = o;\r
- lhs.sexp = l_op;\r
- rhs.sexp = r_op;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- predicate_t(const char *o, predicate_t *p){\r
- operator_type = PRED_UNARY_OP;\r
- op = o;\r
- lhs.predp = p;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- predicate_t(const char *o, predicate_t *l_p, predicate_t *r_p){\r
- operator_type = PRED_BINARY_OP;\r
- op = o;\r
- lhs.predp = l_p;\r
- rhs.predp = r_p;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- predicate_t(const char *o, std::vector<scalarexp_t *> op_list){\r
- operator_type = PRED_FUNC;\r
- op = o;\r
- param_list = op_list;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- predicate_t(const char *o){\r
- op = o;\r
- fcn_id = -1;\r
- combinable_ref = -1;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
-\r
- static predicate_t *make_paramless_fcn_predicate(const char *o){\r
- predicate_t *ret = new predicate_t(o);\r
- ret->operator_type = PRED_FUNC;\r
- ret->fcn_id = -1;\r
- ret->combinable_ref = -1;\r
- return(ret);\r
- };\r
-\r
- std::string to_string(){\r
- if(operator_type == PRED_IN){\r
- return( lhs.sexp->to_string() + " " + op + " [ " + rhs.ll->to_string() +" ]");\r
- }\r
- if(operator_type == PRED_COMPARE){\r
- return( lhs.sexp->to_string() + " " + op + " " + rhs.sexp->to_string() );\r
- }\r
- if(operator_type == PRED_UNARY_OP){\r
- return( op + " (" + lhs.predp->to_string() + ")" );\r
- }\r
- if(operator_type == PRED_BINARY_OP){\r
- return( "(" + lhs.predp->to_string() + " " + op + " " + rhs.predp->to_string() + ")" );\r
- }\r
- if(operator_type == PRED_FUNC){\r
- std::string ret = op + "[ ";\r
- int i;\r
- for(i=0;i<param_list.size();++i){\r
- if(i>0) ret += ", ";\r
- ret += param_list[i]->to_string();\r
- }\r
- ret += "] ";\r
- return(ret);\r
- }\r
- return("");\r
- };\r
-\r
- std::vector<scalarexp_t *> get_op_list(){return param_list; };\r
- int get_operator_type(){return operator_type; };\r
- std::string get_op(){return op; };\r
- int get_lineno(){return lineno; };\r
- int get_charno(){return charno; };\r
- int get_combinable_ref(){return combinable_ref;}\r
- void set_combinable_ref(int f){combinable_ref = f;};\r
- predicate_t *get_left_pr(){return(lhs.predp); };\r
- predicate_t *get_right_pr(){return(rhs.predp); };\r
- scalarexp_t *get_left_se(){return(lhs.sexp); };\r
- scalarexp_t *get_right_se(){return(rhs.sexp); };\r
- std::vector<literal_t *> get_lit_vec(){return(rhs.ll->get_literal_vector()); };\r
-\r
- void swap_scalar_operands(){\r
- if(operator_type != PRED_COMPARE){\r
- fprintf(stderr,"INTERNAL ERROR: swap_scalar_operands called on predicate of type %d\n",operator_type);\r
- exit(1);\r
- }\r
- scalarexp_t *tmp;\r
- tmp = lhs.sexp; lhs.sexp = rhs.sexp; rhs.sexp = tmp;\r
- if(op == ">"){op = "<"; return;}\r
- if(op == ">="){op = "<="; return;}\r
- if(op == "<"){op = ">"; return;}\r
- if(op == "<="){op = ">="; return;}\r
- };\r
- void set_fcn_id(int i){fcn_id = i;};\r
- int get_fcn_id(){return fcn_id;};\r
-\r
-\r
-};\r
-\r
-\r
-/*\r
- A structure that holds the components of a query.\r
- This is the root type.\r
- Used by manipulative_statement, select_statement, table_exp\r
-*/\r
-\r
-#define SELECT_QUERY 1\r
-#define MERGE_QUERY 2\r
-\r
-class table_exp_t{\r
-public:\r
- int query_type; // roughly, the type of the query.\r
- ss_map nmap; // DEFINE block\r
- std::vector<var_pair_t *> query_params; // PARAM block (uninterpreted)\r
- select_list_t *sl; // SELECT\r
- tablevar_list_t *fm; // FROM\r
- predicate_t *wh; // WHERE\r
- predicate_t *hv; // HAVING\r
- predicate_t *cleaning_when; // CLEANING WHEN\r
- predicate_t *cleaning_by; // CLEANING BY\r
- predicate_t *closing_when; // CLOSING WHEN\r
- std::vector<extended_gb_t *> gb; // GROUP BY\r
- std::vector<colref_t *> mergevars; // merge colrefs.\r
- std::vector<colref_t *> supergb; // supergroup.\r
- scalarexp_t *slack; // merge slack\r
- bool exernal_visible; // true iff. it can be subscribed to.\r
- int lineno, charno;\r
-\r
-\r
- table_exp_t(tablevar_list_t *f, predicate_t *p, extended_gb_list_t *g, colref_list_t *sg, predicate_t *h, predicate_t *cw, predicate_t *cb, predicate_t *closew)\r
- {fm = f; wh = p; hv = h;\r
- cleaning_when = cw; cleaning_by = cb;\r
- closing_when = closew;\r
- if(g != NULL)\r
- gb = g->gb_list;\r
- if(sg != NULL)\r
- supergb = sg->get_clist();\r
- slack = NULL;\r
- query_type = SELECT_QUERY;\r
- exernal_visible = true;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- table_exp_t(colref_list_t *mv, tablevar_list_t *f)\r
- {fm = f; mergevars=mv->get_clist();\r
- slack = NULL;\r
- query_type = MERGE_QUERY;\r
- exernal_visible = true;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
- table_exp_t(colref_list_t *mv, scalarexp_t *sl, tablevar_list_t *f)\r
- {fm = f; mergevars=mv->get_clist();\r
- slack = sl;\r
- query_type = MERGE_QUERY;\r
- exernal_visible = true;\r
- lineno = flex_fta_lineno; charno = flex_fta_ch;\r
- };\r
-\r
-// Figure out the temporal merge field at analyze_fta time.\r
- static table_exp_t *make_deferred_merge(std::vector<std::string> src_tbls){\r
- table_exp_t *ret = new table_exp_t();\r
- ret->query_type = MERGE_QUERY;\r
- ret->fm = new tablevar_list_t();\r
- int t;\r
- for(t=0;t<src_tbls.size();++t){\r
- ret->fm->append_table(new tablevar_t(src_tbls[t].c_str()));\r
- }\r
- ret->lineno = 0; ret->charno = 0;\r
- return ret;\r
- }\r
-\r
- table_exp_t(){\r
- fm = NULL; sl = NULL; wh=NULL; hv=NULL;\r
- slack = NULL;\r
- cleaning_when=NULL; cleaning_by = NULL;\r
- closing_when = NULL;\r
- exernal_visible = true;\r
- };\r
-\r
- table_exp_t *add_selection(select_list_t *s){\r
- sl = s;\r
- return(this);\r
- };\r
-\r
- void add_nmap(var_defs_t *vd){\r
- int n;\r
- if(vd != NULL){\r
- for(n=0;n<vd->size();++n){\r
- nmap[vd->get_name(n)] = vd->get_def(n);\r
-//printf("Adding (%s, %s) to name map.\n",vd->get_name(n).c_str(), vd->get_def(n).c_str());\r
- }\r
- }\r
- };\r
-\r
- void add_param_list(var_defs_t *vd){\r
- int n;\r
- if(vd != NULL){\r
- query_params = vd->get_nvec();\r
- }\r
- };\r
-\r
-\r
- std::string to_string(){\r
- std::string retval;\r
- if(sl != NULL){\r
- retval.append("Select " + sl->to_string() + "\n");\r
- }\r
- if(fm != NULL){\r
- retval.append("From " + fm->to_string() + "\n");\r
- }\r
- if(wh != NULL){\r
- retval.append("Where "+ wh->to_string() + "\n");\r
- }\r
- if(hv != NULL){\r
- retval.append("Having "+hv->to_string() + "\n");\r
- }\r
- return(retval);\r
- };\r
-\r
- tablevar_list_t *get_from(){return fm; };\r
- select_list_t *get_select(){return sl; };\r
- std::vector<select_element *> get_sl_vec(){return sl->get_select_list(); };\r
- predicate_t *get_where(){return wh; };\r
- predicate_t *get_having(){return hv; };\r
- predicate_t *get_cleaning_by(){return cleaning_by; };\r
- predicate_t *get_cleaning_when(){return cleaning_when; };\r
- predicate_t *get_closing_when(){return closing_when; };\r
- std::vector<extended_gb_t *> get_groupby(){return(gb); };\r
- std::vector<colref_t *> get_supergb(){return supergb;};\r
-\r
- ss_map get_name_map(){return nmap;};\r
-\r
- bool name_exists(std::string nm){\r
- return(nmap.count(nm) > 0);\r
- };\r
-\r
- std::string get_val_of_name(std::string nm){\r
- if(nmap.count(nm) == 0) return("");\r
- else return nmap[nm];\r
- };\r
-\r
- void set_val_of_name(const std::string n, const std::string v){\r
- nmap[n]=v;\r
- }\r
-\r
- void set_visible(bool v){exernal_visible=v;};\r
- bool get_visible(){return exernal_visible;};\r
-};\r
-\r
-struct query_list_t{\r
- std::vector<table_exp_t *> qlist;\r
-\r
- query_list_t(table_exp_t *t){\r
- qlist.push_back(t);\r
- };\r
- query_list_t *append(table_exp_t *t){\r
- qlist.push_back(t);\r
- return(this);\r
- };\r
-};\r
-\r
-\r
-#define TABLE_PARSE 1\r
-#define QUERY_PARSE 2\r
-#define STREAM_PARSE 3\r
-\r
-struct fta_parse_t{\r
- query_list_t *parse_tree_list;\r
- table_exp_t *fta_parse_tree;\r
- table_list *tables;\r
- int parse_type;\r
-};\r
-\r
-\r
-\r
-\r
-\r
- extern table_exp_t *fta_parse_tree;\r
-\r
-\r
-\r
-\r
-\r
-#endif\r
-\r
+/* ------------------------------------------------
+Copyright 2014 AT&T Intellectual Property
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ ------------------------------------------- */
+#ifndef _FTA_PARSE_H_INCLUDED__
+#define _FTA_PARSE_H_INCLUDED__
+
+#include<stdio.h>
+#include<ctype.h>
+
+ int yyparse();
+ void yyerror(char *s);
+ int yylex();
+extern int flex_fta_lineno, flex_fta_ch;
+
+/* Interface to FTA Parser */
+void FtaParser_setfileinput(FILE *f);
+void FtaParser_setstringinput(char *s);
+
+
+/* Get type defines. */
+#include"type_objects.h"
+#include"literal_types.h"
+#include"type_indicators.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <math.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// colref_t::is_equivalent needs to understand the schema
+#include"parse_schema.h"
+class colref_t;
+
+
+
+class var_pair_t{
+public:
+ std::string name;
+ std::string val;
+
+ var_pair_t(char *n, char *v){
+ name=n; val=v;
+//printf("NEW var_pair_t(%s, %s)\n",n,v);
+ };
+
+ var_pair_t(const std::string n, const std::string v){
+ name=n; val=v;
+ };
+};
+
+typedef std::map< std::string, std::string > ss_map;
+
+class var_defs_t{
+private:
+ std::vector<var_pair_t *> namevec;
+
+public:
+ var_defs_t(var_pair_t *vp){
+ namevec.push_back(vp);
+ };
+
+ var_defs_t *add_var_pair(var_pair_t *vp){
+ namevec.push_back(vp);
+ return(this);
+ };
+
+ std::vector<var_pair_t *> get_nvec(){return namevec;};
+
+ int size(){return namevec.size();};
+
+ int find_name(std::string n){
+ int i;
+ for(i=0;i<namevec.size();i++){
+ if(namevec[i]->name == n)
+ return i;
+ }
+ return -1;
+ }
+ std::string get_name(int i){
+ if(i>=0 && i<namevec.size()){
+ return(namevec[i]->name);
+ }else{
+ return("");
+ }
+ }
+
+ std::string get_def(int i){
+ if(i>=0 && i<namevec.size()){
+ return(namevec[i]->val);
+ }else{
+ return("");
+ }
+ }
+
+ std::string dump(){
+ int i;
+ std::string ret;
+ for(i=0;i<namevec.size();++i){
+ ret += "\t"+namevec[i]->name+" = "+namevec[i]->val+"\n";
+ }
+ return ret;
+ }
+
+};
+
+
+
+
+// literal type constants are defined in literal_types.h
+// (must share this info with type_objects.h)
+
+// Represents a literal, as expected
+// NOTE: this class contains some code generation methods.
+
+class literal_t{
+private:
+
+public:
+ std::string lstring; /* literal value */
+ short int ltype; /* literal type */
+ int lineno, charno;
+
+ int complex_literal_id; // if this literal has a complex constructor,
+ // there is a function which constructs it)
+ //set to the idx in the complex literal
+ // table. (Must store this here (instead of in SE)
+ // because of bare literals in the IN predicate).
+
+
+ literal_t(std::string v){
+ lstring = v;
+ ltype = LITERAL_STRING;
+ complex_literal_id = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ }
+ static literal_t *make_define_literal(const char *s, var_defs_t *d){
+ int i;
+ i=d->find_name(s);
+ if(i<0){
+ fprintf(stderr,"ERROR at line %d, char %d; DEFINE'd literal %s referenced but not in DEFINE block.\n",flex_fta_lineno, flex_fta_ch, s);
+ exit(1);
+ }
+ return new literal_t(d->get_def(i));
+ }
+
+ literal_t(const char *lit, int t){lstring = lit; ltype = t;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ complex_literal_id = -1;
+
+// For some datatypes we need to modify literal so make a copy of the string
+ char v[100];
+ strcpy(v, lit);
+
+// Remove UL, ULL suffix from INT constants.
+ if(ltype == LITERAL_INT || ltype == LITERAL_LONGINT){
+ int i;
+ int len=strlen(v);
+ for(i=0;i<len;++i){
+ if(v[i] == 'U') v[i] = '\0';
+ }
+ lstring = v;
+ }
+
+// HEX and LONGHEX must be converted to uint (long long uint)
+ if(ltype == LITERAL_HEX){
+ char *c,ltmpstr[100];
+ unsigned long tmp_l;
+ for(c=v; (*c)!='\0';++c){
+ if(! ( ((*c) >= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){
+ fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a HEX constant.\n",
+ lineno, charno, v);
+ exit(1);
+ }
+ }
+ sscanf(v,"%lx",&tmp_l);
+ sprintf(ltmpstr,"%lu",tmp_l);
+ lstring = ltmpstr;
+ ltype = LITERAL_INT;
+ }
+ if(ltype == LITERAL_LONGHEX){
+ char *c,ltmpstr[100];
+ unsigned long long tmp_ll;
+ for(c=v; (*c)!='\0';++c){
+ if(! ( ((*c) >= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){
+ fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a LHEX constant.\n",
+ lineno, charno, v);
+ exit(1);
+ }
+ }
+ sscanf(v,"%llx",&tmp_ll);
+ sprintf(ltmpstr,"%llu",tmp_ll);
+ lstring = ltmpstr;
+ ltype = LITERAL_LONGINT;
+ }
+// Convert IP to uint
+ if(ltype == LITERAL_IP){
+ char ltmpstr[100];
+ unsigned int o1,o2,o3,o4,tmp_l;
+ if(sscanf(v,"%u.%u.%u.%u",&o1,&o2,&o3,&o4) != 4){
+ fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n",
+ lineno, charno, v);
+ exit(1);
+ }
+ if( (o1>255) || (o2>255) || (o3>255) || (o4>255) ){
+ fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n",
+ lineno, charno, v);
+ exit(1);
+ }
+ tmp_l = (o1<<24)+(o2<<16)+(o3<<8)+o4;
+ sprintf(ltmpstr,"%u",tmp_l);
+ lstring = ltmpstr;
+ ltype = LITERAL_IP;
+ }
+ };
+
+// used to create literals with a default or initial value.
+ literal_t(int type_indicator){
+ lineno=-1; charno=-1;
+ complex_literal_id = -1;
+
+ switch(type_indicator){
+ case UINT_TYPE:
+ case INT_TYPE:
+ case USHORT_TYPE:
+ ltype = LITERAL_INT;
+ lstring = "0";
+ break;
+ case ULLONG_TYPE:
+ case LLONG_TYPE:
+ ltype = LITERAL_LONGINT;
+ lstring = "0";
+ break;
+ case FLOAT_TYPE:
+ ltype = LITERAL_FLOAT;
+ lstring = "0.0";
+ break;
+ case BOOL_TYPE:
+ ltype = LITERAL_BOOL;
+ lstring = "FALSE";
+ break;
+ case VSTR_TYPE:
+ ltype = LITERAL_STRING;
+ lstring = ""; complex_literal_id = 0; // unregistred complex lit
+ break;
+ case TIMEVAL_TYPE:
+ ltype = LITERAL_TIMEVAL;
+ lstring = "0.0";
+ break;
+ case IPV6_TYPE:
+ ltype = LITERAL_IPV6;
+ lstring = "0000:0000:0000:0000:0000:0000:0000:0000";
+ complex_literal_id = 0; // unregistered complex literal
+ break;
+ case IP_TYPE:
+ ltype = LITERAL_IP;
+ lstring = "0";
+ break;
+ default:
+ ltype = LITERAL_UDEF;
+ lstring=" INTERNAL ERROR, UNKNOWN TYPE INDICATOR IN literal_t::literal_t(int) ";
+ }
+ };
+
+ std::string to_string(){return lstring;};
+
+ int get_type(){return ltype; };
+ int get_lineno(){return lineno; };
+ int get_charno(){return charno; };
+
+ bool is_equivalent(literal_t *l2){
+ if(ltype != l2->ltype)
+ return(false);
+ if(lstring != l2->lstring)
+ return(false);
+
+ return(true);
+ };
+
+// Internal function to unescape control characters.
+ static std::string gsqlstr_to_cstr(std::string s){
+ std::string retval;
+ unsigned char c, prev_c='\0';
+ int i;
+
+ for(i=0;i<s.size();++i){
+ c = s[i];
+ if(c=='\''){ // || c=='\\'
+ if(prev_c==c){
+ retval += c;
+ prev_c = '\0';
+ }else{
+ prev_c=c;
+ }
+ continue;
+ }
+
+ retval += c;
+ prev_c = c;
+ }
+
+ return retval;
+ }
+
+
+
+ std::string to_hfta_C_code(std::string param){
+ std::string retval;
+ double tmp_f;
+ int secs, millisecs;
+ char tmpstr[100];
+
+ switch(ltype){
+ case LITERAL_STRING:
+ retval.append(this->hfta_constructor_name() );
+ retval.append("("+param+",\"");
+ retval.append(gsqlstr_to_cstr(lstring));
+ retval.append("\")");
+ return(retval);
+ case LITERAL_INT:
+ case LITERAL_IP:
+ return("((gs_uint32_t)"+lstring+")");
+ case LITERAL_LONGINT:
+ return("((gs_uint64_t)"+lstring+")");
+ case LITERAL_FLOAT:
+ return(lstring);
+// case LITERAL_HEX:
+// return("0x"+lstring);
+ case LITERAL_BOOL:
+ if(lstring == "TRUE"){
+ return("1");
+ }else{
+ return("0");
+ }
+ case LITERAL_TIMEVAL:
+ retval.append(this->hfta_constructor_name() );
+ tmp_f = atof(lstring.c_str());
+ secs = (int)floor(tmp_f);
+ millisecs = (int) rint((tmp_f - secs)*1000);
+ sprintf(tmpstr,"(%d, %d)",secs,millisecs);
+ retval.append(tmpstr);
+ return(retval);
+ case LITERAL_IPV6:
+ retval = this->hfta_constructor_name();
+ retval += "("+param+",\""+lstring+"\")";
+ return retval;
+ }
+
+ return("ERROR UNKNOWN LITERAL");
+ };
+
+
+/// for LFTA code generation
+ std::string to_C_code(std::string param){
+ std::string retval;
+ double tmp_f;
+ int secs, millisecs;
+ char tmpstr[100];
+
+ switch(ltype){
+ case LITERAL_STRING:
+ retval = this->constructor_name()+"("+param+",\""+gsqlstr_to_cstr(lstring)+"\")";
+ return(retval);
+ case LITERAL_INT:
+ case LITERAL_IP:
+ return("((gs_uint32_t)"+lstring+")");
+ case LITERAL_LONGINT:
+ return("((gs_uint64_t)"+lstring+")");
+ case LITERAL_FLOAT:
+ return(lstring);
+// case LITERAL_HEX:
+// return("0x"+lstring);
+ case LITERAL_BOOL:
+ if(lstring == "TRUE"){
+ return("1");
+ }else{
+ return("0");
+ }
+ case LITERAL_IPV6:
+ retval = this->constructor_name()+"("+param+",\""+lstring+"\")";
+ return(retval);
+ case LITERAL_TIMEVAL:
+ retval.append(this->constructor_name() );
+ tmp_f = atof(lstring.c_str());
+ secs = (int)floor(tmp_f);
+ millisecs = (int) rint((tmp_f - secs)*1000);
+ sprintf(tmpstr,"(%d, %d)",secs,millisecs);
+ retval.append(tmpstr);
+ return(retval);
+ }
+
+ return("ERROR UNKNOWN LITERAL");
+ };
+
+
+ std::string to_query_string(){
+ std::string retval;
+
+ switch(ltype){
+ case LITERAL_IP:
+ {
+ unsigned int v;
+ sscanf(lstring.c_str(),"%u",&v);
+ int d1 = v & 0xff;
+ int d2 = (v & 0xff00) >> 8;
+ int d3 = (v & 0xff0000) >> 16;
+ int d4 = (v & 0xff000000) >> 24;
+ char ret[200];
+ sprintf(ret,"IP_VAL'%u.%u.%u.%u'",d4,d3,d2,d1);
+ return ret;
+ }
+ case LITERAL_STRING:
+ retval = "'"+lstring+"'";
+ return(retval);
+ case LITERAL_INT:
+ case LITERAL_FLOAT:
+ case LITERAL_TIMEVAL:
+ case LITERAL_IPV6:
+ case LITERAL_BOOL:
+ return(lstring);
+ case LITERAL_LONGINT:
+ return(lstring+"ULL");
+ }
+
+ return("ERROR UNKNOWN LITERAL in literal_t::to_query_string");
+ };
+
+// TODO : Use definition files instead of hardwiring these.
+
+// constructor in LFTA code
+ std::string constructor_name(){
+
+ switch(ltype){
+ case LITERAL_TIMEVAL:
+ return("Timeval_Constructor");
+ case LITERAL_IPV6:
+ return("Ipv6_Constructor");
+ case LITERAL_STRING:
+ return("str_constructor");
+ case LITERAL_INT:
+ case LITERAL_IP:
+ case LITERAL_LONGINT:
+ case LITERAL_BOOL:
+ case LITERAL_FLOAT:
+ return("");
+ }
+ return("ERROR UNKNOWN LITERAL");
+ };
+
+ std::string hfta_constructor_name(){
+
+ switch(ltype){
+ case LITERAL_TIMEVAL:
+ return("HFTA_Timeval_Constructor");
+ case LITERAL_IPV6:
+ return("HFTA_Ipv6_Constructor");
+ case LITERAL_STRING:
+ return("Vstring_Constructor");
+ case LITERAL_INT:
+ case LITERAL_IP:
+ case LITERAL_LONGINT:
+ case LITERAL_BOOL:
+ case LITERAL_FLOAT:
+ return("");
+ }
+ return("ERROR UNKNOWN LITERAL");
+ };
+
+ std::string hfta_empty_literal_name(){
+
+ switch(ltype){
+ case LITERAL_TIMEVAL:
+ return("EmptyTimeval");
+ case LITERAL_IPV6:
+ return("EmptyIp6");
+ case LITERAL_STRING:
+ return("EmptyString");
+ }
+ return("ERROR_NOT_A_COMPLEX_LITERAL");
+ };
+
+
+ void set_cpx_lit_ref(int g){complex_literal_id = g; };
+ int get_cpx_lit_ref(){return (complex_literal_id ); };
+ bool is_cpx_lit(){return(complex_literal_id >= 0); };
+
+};
+
+
+/*
+ A (null terminated) list of literals.
+ Used for the IN clause
+*/
+
+class literal_list_t{
+private:
+
+public:
+ std::vector<literal_t *> lit_list;
+ int lineno, charno;
+
+ literal_list_t(literal_t *l){
+ lit_list.push_back(l);
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ literal_list_t(std::vector<literal_t *> lvec){
+ lineno = charno = 0;
+ lit_list = lvec;
+ };
+
+ literal_list_t *append_literal(literal_t *l){
+ lit_list.push_back(l);
+ return(this);
+ };
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+ for(i=0;i<lit_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(lit_list[i]->to_query_string());
+ }
+ return(retval);
+ };
+
+ std::vector<literal_t *> get_literal_vector(){return(lit_list);};
+
+};
+
+
+class string_t{
+public:
+ std::string val;
+ string_t(char *s){
+ val = s;
+ }
+ string_t *append(char *s){
+ val += s;
+ return this;
+ }
+ string_t *append(char *sep, char *s){
+ val += sep;
+ val += s;
+ return this;
+ }
+ const char *c_str(){
+ return val.c_str();
+ }
+};
+
+// A tablevar is a data source in a GSQL query.
+// Every column ref must be bound to a tablevar,
+// either explicitly or via imputation.
+
+
+class tablevar_t{
+public:
+// A tablevar is a variable which binds to a named data source.
+// the variable name might be explicit in the query, or it might be
+// implicit in which case the variable name is imputed. In either case
+// the variable name is set via the set_range_var method.
+//
+// The data source is the name of either a STREAM or a PROTOCOL.
+// All STREAMS are unique, but a PROTOCOL must be bound to an
+// interface. If the interface is not given, it is imputed to be
+// the default interface.
+
+ std::string machine;
+ std::string interface;
+ std::string schema_name;
+ std::string variable_name;
+ std::string udop_alias; // record UDOP ID for of UDOP
+ // for use by cluster manager
+
+ int schema_ref; // index of the table in the schema (table_list)
+ int opview_idx; // index in list of operator views (if any)
+ bool iface_is_query; // true if iface resolves to query
+ // instead of specific interface.
+
+ int properties; // inner (0) or outer (1) join;
+ // labeled using FROM clause,
+ // determines join algorithm.
+
+ int lineno, charno;
+
+ tablevar_t(){ opview_idx = -1; schema_ref=-1; iface_is_query = false;
+ lineno=-1; charno=-1;};
+ tablevar_t(const char *t){schema_name=t; interface="";
+ opview_idx = -1; schema_ref = -1;
+ variable_name=""; properties = 0;
+ iface_is_query = false;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ tablevar_t(const char *i, const char *s, int iq){interface=i; schema_name=s;
+ opview_idx = -1; schema_ref = -1;
+ variable_name=""; properties = 0;
+ if(iq) iface_is_query = true; else iface_is_query = false;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ tablevar_t(const char *m, const char *i, const char *s){
+ machine = m; interface=i; schema_name=s;
+ opview_idx = -1; schema_ref = -1;
+ variable_name=""; properties = 0;
+ iface_is_query = false;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ tablevar_t *duplicate(){
+ tablevar_t *ret = new tablevar_t();
+ ret->lineno = lineno; ret->charno = charno;
+ ret->schema_ref = schema_ref;
+ ret->opview_idx = opview_idx;
+ ret->machine = machine;
+ ret->interface = interface;
+ ret->schema_name = schema_name;
+ ret->variable_name = variable_name;
+ ret->properties = properties;
+ ret->iface_is_query = iface_is_query;
+ return(ret);
+ };
+
+ tablevar_t *set_range_var(const char *r){
+ variable_name = r;
+ return(this);
+ };
+ tablevar_t *set_range_var(std::string r){
+ variable_name = r;
+ return(this);
+ };
+
+ void set_schema(std::string s){schema_name = s;};
+ void set_interface(std::string i){interface=i;};
+ void set_machine(std::string m){machine = m;};
+ void set_udop_alias(std::string u){udop_alias = u;};
+
+ void set_schema_ref(int r){schema_ref = r;};
+ int get_schema_ref(){return schema_ref;};
+
+ void set_opview_idx(int i){opview_idx = i;};
+ int get_opview_idx(){return opview_idx;};
+
+ void set_property(int p){properties = p;};
+ int get_property(){return properties;};
+
+ bool get_ifq(){return iface_is_query;};
+ void set_ifq(bool b){iface_is_query = b;};
+
+ std::string to_string(){
+ std::string retval;
+
+ if(machine != "" && !iface_is_query)
+ retval += "'"+machine+"'.";
+ if(interface != ""){
+ if(iface_is_query){
+ retval += '['+interface+"].";
+ }else{
+ retval += interface+".";
+ }
+ }
+ retval += schema_name;
+ if(variable_name != "") retval+=" "+variable_name;
+
+ return(retval);
+ };
+
+ std::string get_schema_name(){return schema_name;};
+ void set_schema_name(std::string n){schema_name=n;};
+ std::string get_var_name(){return variable_name;};
+ std::string get_interface(){return interface;};
+ std::string get_machine(){return machine;};
+ std::string get_udop_alias(){return udop_alias;};
+
+ int get_lineno(){return(lineno); };
+ int get_charno(){return(charno); };
+
+};
+
+#define INNER_JOIN_PROPERTY 0
+#define LEFT_OUTER_JOIN_PROPERTY 1
+#define RIGHT_OUTER_JOIN_PROPERTY 2
+#define OUTER_JOIN_PROPERTY 3
+#define FILTER_JOIN_PROPERTY 4
+
+// tablevar_list_t is the list of tablevars in a FROM clause
+
+struct tablevar_list_t{
+public:
+ std::vector<tablevar_t *> tlist;
+ int properties;
+ int lineno, charno;
+// For filter join
+ colref_t *temporal_var;
+ unsigned int temporal_range;
+
+ tablevar_list_t(){properties = -1; temporal_var = NULL;}
+ tablevar_list_t(tablevar_t *t){tlist.push_back(t); properties=-1; temporal_var = NULL;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+ tablevar_list_t(std::vector<tablevar_t *> t){tlist = t; properties=-1; temporal_var = NULL;
+ lineno = 0; charno = 0;};
+
+ tablevar_list_t *duplicate(){
+ tablevar_list_t *ret = new tablevar_list_t();
+ ret->lineno = lineno; ret->charno = charno;
+ ret->properties = properties;
+ ret->temporal_var = temporal_var;
+ ret->temporal_range = temporal_range;
+ int i;
+ for(i=0;i<tlist.size();++i){
+ ret->append_table(tlist[i]->duplicate());
+ }
+ return(ret);
+ }
+
+
+
+ tablevar_list_t *append_table(tablevar_t *t){
+ tlist.push_back(t);
+ return(this);
+ };
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+
+ for(i=0;i<tlist.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(tlist[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<tablevar_t *> get_table_list(){return(tlist); };
+
+ std::vector<std::string> get_table_names(){
+ std::vector<std::string> ret;
+ int t;
+ for(t=0;t<tlist.size();++t){
+ std::string tbl_name = tlist[t]->get_schema_name();
+ ret.push_back(tbl_name);
+ }
+ return(ret);
+ }
+
+ std::vector<std::string> get_src_tbls(table_list *Schema){
+ std::vector<std::string> ret;
+ int t, sq;
+ for(t=0;t<tlist.size();++t){
+ std::string tbl_name = tlist[t]->get_schema_name();
+ int sid = Schema->find_tbl(tbl_name);
+ if(sid < 0){ ret.push_back(tbl_name);
+ }else
+ if(Schema->get_schema_type(sid) != OPERATOR_VIEW_SCHEMA){
+ ret.push_back(tbl_name);
+ }else{
+ std::vector<subquery_spec *> sqspec = Schema->get_subqueryspecs(sid);
+ for(sq=0;sq<sqspec.size();++sq){
+ ret.push_back(sqspec[sq]->name);
+ }
+ }
+ }
+ return(ret);
+ };
+
+ int size(){
+ return tlist.size();
+ };
+
+// Some accessor functions.
+
+ std::vector<std::string> get_schema_names(){
+ int i;
+ std::vector<std::string > retval;
+ for(i=0;i<tlist.size();i++){
+ retval.push_back(tlist[i]->get_schema_name());
+ }
+ return(retval);
+ }
+
+ std::vector<int> get_schema_refs(){
+ int i;
+ std::vector<int> retval;
+ for(i=0;i<tlist.size();i++){
+ retval.push_back(tlist[i]->get_schema_ref());
+ }
+ return(retval);
+ }
+
+
+ int get_schema_ref(int i){
+ if(i<0 || i>=tlist.size()) return(-1);
+ return tlist[i]->get_schema_ref();
+ };
+
+ std::string get_tablevar_name(int i){
+ if(i<0 || i>=tlist.size()) return("");
+ return tlist[i]->get_var_name();
+ };
+
+ void set_properties(int p){properties = p;};
+ int get_properties(){return properties;};
+
+ void set_colref(colref_t *c){temporal_var = c;};
+ void set_temporal_range(unsigned int t){temporal_range = t;};
+ void set_temporal_range(const char *t){temporal_range= atoi(t);};
+ colref_t *get_colref(){return temporal_var;};
+ unsigned int get_temporal_range(){return temporal_range;};
+
+};
+
+// A reference to an interface parameter.
+// (I need to be able to record the source
+// tablevar, else this would be a lot simpler).
+class ifpref_t{
+public:
+ std::string tablevar;
+ std::string pname;
+ int tablevar_ref;
+ int lineno, charno;
+
+ ifpref_t(const char *p){
+ tablevar="";
+ pname = p;
+ tablevar_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ ifpref_t(const char *t, const char *p){
+ tablevar=t;
+ pname = p;
+ tablevar_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ void set_tablevar_ref(int i){tablevar_ref = i;};
+ int get_tablevar_ref(){return tablevar_ref;};
+ std::string get_tablevar(){return tablevar;}
+ void set_tablevar(std::string t){tablevar = t;};
+ std::string get_pname(){return pname;}
+ std::string to_string(){
+ std::string ret;
+ if(tablevar != "")
+ ret += tablevar + ".";
+ ret += "@"+pname;
+ return ret;
+ };
+ bool is_equivalent(ifpref_t *i){
+ return (tablevar_ref == i->tablevar_ref) && (pname == i->pname);
+ };
+};
+
+
+
+
+// A representation of a reference to a field of a
+// stream (or table). This reference must be bound
+// to a particular schema (schema_ref) and to a
+// particular table variable in the FROM clause (tablevar_ref)
+// If the column reference was generated by the parser,
+// it will contain some binding text wich might need
+// interpretation to do the actual binding.
+class colref_t{
+public:
+ std::string interface; // specified interface, if any.
+ std::string table_name; // specified table name or range var, if any.
+ std::string field; // field name
+ bool default_table; // true iff. no table or range var given.
+ int schema_ref; // ID of the source schema.
+ int tablevar_ref; // ID of the tablevar (in FROM clause).
+ int lineno, charno;
+
+ colref_t(const char *f){
+ field = f; default_table = true;
+ schema_ref = -1; tablevar_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ colref_t(const char *t, const char *f){
+ table_name = t; field=f; default_table = false;
+ schema_ref = -1; tablevar_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ colref_t(const char *i, const char *t, const char *f){
+ interface=i;
+ table_name = t; field=f; default_table = false;
+ schema_ref = -1; tablevar_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ colref_t *duplicate(){
+ colref_t *retval = new colref_t(interface.c_str(), table_name.c_str(), field.c_str());
+ retval->schema_ref = schema_ref;
+ retval->tablevar_ref = tablevar_ref;
+ retval->lineno = lineno;
+ retval->charno = charno;
+ retval->default_table = default_table;
+ return(retval);
+ }
+
+ std::string to_string(){
+ if(default_table){
+ return field;
+ }else{
+ if(interface != "") return(interface+"."+table_name+"."+field);
+ return(table_name + "." + field);
+ }
+ };
+
+ std::string to_query_string(){
+ if(default_table){
+ return field;
+ }else{
+ if(interface != "") return(interface+"."+table_name+"."+field);
+ if(table_name != "") return(table_name + "." + field);
+ return(field);
+ }
+ };
+
+ int get_lineno(){return lineno; };
+ int get_charno(){return charno; };
+
+ bool uses_default_table(){return default_table; };
+
+ std::string get_field(){return(field); };
+ void set_field(std::string f){field=f;};
+ std::string get_table_name(){return(table_name);};
+ std::string get_interface(){return(interface);};
+ void set_table_name(std::string t){table_name = t; default_table=false;};
+ void set_interface(std::string i){interface=i;};
+
+ int get_schema_ref(){return schema_ref;}
+ void set_schema_ref(int s){schema_ref = s;};
+ int get_tablevar_ref(){return tablevar_ref;}
+ void set_tablevar_ref(int s){tablevar_ref = s;};
+
+// Should equivalence be based on tablevar_ref or schema_ref?
+ bool is_equivalent(colref_t *c2){
+ if(schema_ref == c2->schema_ref){
+ return(field == c2->field);
+ }
+ return(false);
+ };
+
+ bool is_equivalent_base(colref_t *c2, table_list *Schema){
+ if(Schema->get_basetbl_name(schema_ref,field) ==
+ Schema->get_basetbl_name(c2->schema_ref,c2->field)){
+ return(field == c2->field);
+ }
+ return(false);
+ };
+};
+
+class colref_list_t{
+public:
+ std::vector<colref_t *> clist;
+
+// colref_list_t(){};
+
+ colref_list_t(colref_t *c){
+ clist.push_back(c);
+ }
+
+ colref_list_t *append(colref_t *c){
+ clist.push_back(c);
+ return this;
+ }
+
+ std::vector<colref_t *> get_clist(){
+ return clist;
+ }
+};
+
+
+
+
+
+
+/*
+ A tree containing a scalar expression.
+ Used for
+ atom : a parameter or a literal
+ scalar_exp (see the scalar_exp: rule in emf.l for details)
+ function_ref (a function that has a value, e.g. an aggregate
+ function).
+ operator_type defines the contents of the node. If its a non-terminal,
+ then op has a meaning and defines the operation. See the list of
+ #define'd constants following the structure definition.
+
+
+*/
+
+#define SE_LITERAL 1
+#define SE_PARAM 2
+#define SE_COLREF 3
+#define SE_UNARY_OP 4
+#define SE_BINARY_OP 5
+#define SE_AGGR_STAR 6
+#define SE_AGGR_SE 7
+#define SE_FUNC 8
+#define SE_IFACE_PARAM 9
+
+
+class scalarexp_t{
+public:
+ int operator_type;
+ std::string op;
+ union{
+ scalarexp_t *scalarp;
+ literal_t *litp;
+ colref_t *colref;
+ ifpref_t *ifp;
+ } lhs;
+ union{
+ scalarexp_t *scalarp;
+ } rhs;
+ std::vector<scalarexp_t *> param_list;
+
+// SE node decorations -- results of query analysis.
+ data_type *dt;
+ int gb_ref; // set to the gb attr tbl ref, else -1
+ int aggr_id; // set to the aggr tbl ref, else -1
+ int fcn_id; // external function table ref, else -1
+ int partial_ref; // partial fcn table ref, else -1
+ int fcn_cache_ref; // function cache ref, else -1
+ int handle_ref; // Entry in pass-by-handle parameter table, else -1.
+ // (might be a literal or a query param).
+ bool is_superagg; // true if is aggregate and associated with supergroup.
+ std::string storage_state; // storage state of stateful fcn,
+ // empty o'wise.
+
+ int lineno, charno;
+
+ void default_init(){
+ operator_type = 0;
+ gb_ref = -1; aggr_id = -1; fcn_id = -1;
+ partial_ref = -1; fcn_cache_ref=-1;
+ handle_ref = -1;
+ dt = NULL; lineno = flex_fta_lineno; charno = flex_fta_ch;
+ is_superagg = false;
+ };
+
+ scalarexp_t(){
+ default_init();};
+
+ scalarexp_t(colref_t *c){
+ default_init();
+ operator_type = SE_COLREF;
+ lhs.colref = c;
+ };
+
+ scalarexp_t(literal_t *l){
+ default_init();
+ operator_type = SE_LITERAL;
+ lhs.litp = l;
+ };
+
+ void convert_to_literal(literal_t *l){
+// default_init();
+ if(operator_type != SE_IFACE_PARAM){
+ fprintf(stderr,"INTERNAL ERROR in literal_t::convert_to_literal, operator type isn't SE_IFACE_PARAM.\n");
+ exit(1);
+ }
+ operator_type = SE_LITERAL;
+ lhs.litp = l;
+ }
+
+ scalarexp_t(const char *o, scalarexp_t *operand){
+ default_init();
+ operator_type = SE_UNARY_OP;
+ op = o;
+ lhs.scalarp = operand;
+ };
+
+ scalarexp_t(const char *o, scalarexp_t *l_op, scalarexp_t *r_op){
+ default_init();
+ operator_type = SE_BINARY_OP;
+ op = o;
+ lhs.scalarp = l_op;
+ rhs.scalarp = r_op;
+ };
+
+ scalarexp_t(const char *o, std::vector<scalarexp_t *> op_list){
+ default_init();
+ operator_type = SE_FUNC;
+ op = o;
+ param_list = op_list;
+ };
+
+ static scalarexp_t *make_paramless_fcn(const char *o){
+ scalarexp_t *ret = new scalarexp_t();
+ ret->operator_type = SE_FUNC;
+ ret->op = o;
+ return(ret);
+ };
+
+ static scalarexp_t *make_star_aggr(const char *ag){
+ scalarexp_t *ret = new scalarexp_t();
+ ret->operator_type = SE_AGGR_STAR;
+ ret->op = ag;
+ return(ret);
+ };
+
+ static scalarexp_t *make_se_aggr(const char *ag, scalarexp_t *l_op){
+ scalarexp_t *ret = new scalarexp_t();
+ ret->operator_type = SE_AGGR_SE;
+ ret->op = ag;
+ ret->lhs.scalarp = l_op;
+ return(ret);
+ };
+
+ static scalarexp_t *make_param_reference(const char *param){
+ scalarexp_t *ret = new scalarexp_t();
+ ret->operator_type = SE_PARAM;
+ ret->op = param;
+ return(ret);
+ };
+
+ static scalarexp_t *make_iface_param_reference(ifpref_t *i){
+ scalarexp_t *ret = new scalarexp_t();
+ ret->operator_type = SE_IFACE_PARAM;
+ ret->lhs.ifp = i;
+ return(ret);
+ };
+
+
+ std::string to_string(){
+ if(operator_type == SE_COLREF){
+ return lhs.colref->to_string();
+ }
+ if(operator_type == SE_LITERAL){
+ return lhs.litp->to_string();
+ }
+ if(operator_type == SE_UNARY_OP){
+ return op + " (" + lhs.scalarp->to_string() + ")";
+ }
+ if(operator_type == SE_BINARY_OP){
+ return "(" + lhs.scalarp->to_string() + " " + op + " " + rhs.scalarp->to_string() + ")";
+ }
+ return("");
+ };
+
+ scalarexp_t *get_left_se(){return lhs.scalarp; };
+ scalarexp_t *get_right_se(){return rhs.scalarp; };
+ int get_operator_type(){return operator_type; };
+ std::string & get_op(){return op; };
+ std::string & get_param_name(){return op; };
+// std::string & get_iface_param_name(){return op; };
+ colref_t *get_colref(){return lhs.colref; };
+ ifpref_t *get_ifpref(){return lhs.ifp; };
+ literal_t *get_literal(){return lhs.litp; };
+
+ int get_lineno(){return lineno; };
+ int get_charno(){return charno; };
+
+ void set_data_type(data_type *d){dt=d; };
+ data_type *get_data_type(){return dt; };
+ void reset_temporal(){if(dt!=NULL) dt->reset_temporal();}
+
+ void set_gb_ref(int g){gb_ref = g; };
+ int get_gb_ref(){return (gb_ref); };
+ bool is_gb(){return(gb_ref >= 0); };
+
+ void set_aggr_id(int a){aggr_id = a;};
+ int get_aggr_ref(){return(aggr_id); };
+
+ void set_storage_state(std::string s){storage_state = s;};
+ std::string get_storage_state(){return storage_state;};
+
+ std::vector<scalarexp_t *> get_operands(){return param_list;};
+ void set_fcn_id(int f){fcn_id = f; };
+ int get_fcn_id(){return fcn_id; };
+
+ void set_partial_ref(int p){partial_ref = p; };
+ int get_partial_ref(){return partial_ref; };
+ bool is_partial(){return partial_ref >= 0; };
+
+ void set_fcncache_ref(int p){fcn_cache_ref = p; };
+ int get_fcncache_ref(){return fcn_cache_ref; };
+ bool is_fcncached(){return fcn_cache_ref >= 0; };
+
+ void set_handle_ref(int tf){handle_ref = tf; };
+ int get_handle_ref(){return handle_ref; };
+ bool is_handle_ref(){return handle_ref>=0; };
+
+ void set_superaggr(bool b){is_superagg=b;};
+ bool is_superaggr(){return is_superagg;};
+
+ void use_decorations_of(scalarexp_t *se){
+ if(se->get_data_type() != NULL)
+ dt = se->get_data_type()->duplicate();
+ gb_ref = se->gb_ref;
+ aggr_id = se->aggr_id;
+ fcn_id = se->fcn_id;
+ partial_ref = se->partial_ref;
+ handle_ref = se->handle_ref;
+ lineno = se->lineno;
+ charno = se->charno;
+ is_superagg = se->is_superagg;
+ };
+};
+
+
+/*
+ A (null terminated) list of scalar expressions.
+ Used for
+ selection, scalar_exp_commalist
+*/
+
+class se_list_t{
+public:
+ std::vector<scalarexp_t *> se_list;
+ int lineno, charno;
+
+ se_list_t(scalarexp_t *s){se_list.push_back(s);
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ se_list_t *append(scalarexp_t *s){
+ se_list.push_back(s);
+ return(this);
+ };
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+ for(i=0;i<se_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(se_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<scalarexp_t *> get_se_list(){return se_list; };
+
+
+};
+
+/*
+ select_commalist : collect some additional info about
+ the selected things -- mostly the name.
+*/
+
+struct select_element{
+ scalarexp_t *se;
+ std::string name;
+
+ select_element(){se=NULL; name="";};
+ select_element(scalarexp_t *s){se=s; name="";};
+ select_element(scalarexp_t *s, std::string n){se=s; name=n;};
+};
+
+class select_list_t{
+public:
+ std::vector<select_element *> select_list;
+ int lineno, charno;
+
+ select_list_t(){lineno = -1; charno = -1;};
+ select_list_t(scalarexp_t *s){select_list.push_back(new select_element(s));
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+ select_list_t(scalarexp_t *s, std::string n){
+ select_list.push_back(new select_element(s,n));
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+ select_list_t *append(scalarexp_t *s){
+ select_list.push_back(new select_element(s));
+ return(this);
+ };
+ select_list_t *append(scalarexp_t *s, std::string n){
+ select_list.push_back(new select_element(s,n));
+ return(this);
+ };
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+ for(i=0;i<select_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(select_list[i]->se->to_string());
+ if(select_list[i]->name != "")
+ retval += " AS " + select_list[i]->name;
+
+ }
+ return(retval);
+ };
+
+ std::vector<select_element *> get_select_list(){return select_list; };
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0; i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+};
+
+
+
+#define GB_COLREF 1
+#define GB_COMPUTED 2
+
+class gb_t{
+public:
+ std::string name;
+ std::string table;
+ std::string interface;
+ scalarexp_t *def;
+ int type;
+ int lineno, charno;
+
+ gb_t(const char *field_name){
+ interface="";
+ name = field_name; table=""; def=NULL; type=GB_COLREF;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ gb_t(const char *table_name, const char *field_name){
+ interface="";
+ name = field_name; table=""; def=NULL; type=GB_COLREF;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ gb_t(const char *iface, const char *table_name, const char *field_name){
+ interface=iface;
+ name = field_name; table=""; def=NULL; type=GB_COLREF;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ gb_t( scalarexp_t *s, const char *gname){
+ name = gname; table = ""; def = s; type = GB_COMPUTED;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ std::string to_string(){
+ std::string retval;
+ if(type == GB_COLREF){
+ if(table != ""){
+ retval = table;
+ retval.append(".");
+ }
+ retval.append(name);
+ }
+ if(type == GB_COMPUTED){
+ retval = "(scalarexp) AS ";
+ retval.append(name);
+ }
+ return(retval);
+ };
+
+ gb_t *duplicate();
+
+};
+
+/*
+ A (null terminated) list of group by attributes
+*/
+
+class gb_list_t{
+public:
+ std::vector<gb_t *> gb_list;
+ int lineno, charno;
+
+ gb_list_t(gb_t *g){gb_list.push_back(g);
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ gb_list_t *append(gb_t *s){
+ gb_list.push_back(s);
+ return(this);
+ };
+ gb_list_t(int l, int c) : lineno(l), charno(c){ }
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+ for(i=0;i<gb_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(gb_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<gb_t *> get_gb_list(){return gb_list; };
+
+ gb_list_t *duplicate(){
+ gb_list_t *ret = new gb_list_t(lineno, charno);
+ int i;
+ for(i=0;i<gb_list.size();++i){
+ ret->append(gb_list[i]->duplicate());
+ }
+
+ return ret;
+ }
+
+
+};
+
+class list_of_gb_list_t{
+public:
+ std::vector<gb_list_t *> gb_lists;
+
+ list_of_gb_list_t(gb_list_t *gl){
+ gb_lists.push_back(gl);
+ }
+
+ list_of_gb_list_t *append(gb_list_t *gl){
+ gb_lists.push_back(gl);
+ return this;
+ }
+};
+
+
+enum extended_gb_type {no_egb_type, gb_egb_type, rollup_egb_type,
+ cube_egb_type, gsets_egb_type};
+class extended_gb_t{
+public:
+
+ extended_gb_type type;
+ gb_t *gb;
+ std::vector<gb_list_t *> gb_lists;
+
+ extended_gb_t(){
+ gb = NULL;
+ type = no_egb_type;
+ }
+
+ ~extended_gb_t(){
+ }
+
+ static extended_gb_t *create_from_gb(gb_t *g){
+ extended_gb_t *ret = new extended_gb_t();
+ ret->type = gb_egb_type;
+ ret->gb = g;
+ return ret;
+ }
+
+ static extended_gb_t *extended_create_from_rollup(gb_list_t *gl){
+ extended_gb_t *ret = new extended_gb_t();
+ ret->type = rollup_egb_type;
+ ret->gb_lists.push_back(gl);
+ return ret;
+ }
+
+ static extended_gb_t *extended_create_from_cube(gb_list_t *gl){
+ extended_gb_t *ret = new extended_gb_t();
+ ret->type = cube_egb_type;
+ ret->gb_lists.push_back(gl);
+ return ret;
+ }
+
+ static extended_gb_t *extended_create_from_gsets(list_of_gb_list_t *lgl){
+ extended_gb_t *ret = new extended_gb_t();
+ ret->type = gsets_egb_type;
+ ret->gb_lists = lgl->gb_lists;
+ return ret;
+ }
+
+ extended_gb_t *duplicate(){
+ extended_gb_t *ret = new extended_gb_t();
+ ret->type = type;
+ if(gb != NULL)
+ ret->gb = gb->duplicate();
+ int i;
+ for(i=0;i<gb_lists.size();++i){
+ ret->gb_lists.push_back(gb_lists[i]->duplicate());
+ }
+ return ret;
+ }
+
+
+ std::string to_string(){
+ std::string ret;
+ int i;
+
+ switch(type){
+ case no_egb_type:
+ return "Error, undefined extended gb type.";
+ case gb_egb_type:
+ return gb->to_string();
+ case rollup_egb_type:
+ return "ROLLUP("+gb_lists[0]->to_string()+")";
+ case cube_egb_type:
+ return "CUBE("+gb_lists[0]->to_string()+")";
+ case gsets_egb_type:
+ ret = "GROUPING_SETS(";
+ for(i=0;i<gb_lists.size();++i){
+ if(i>0) ret+=", ";
+ ret += "(" +gb_lists[i]->to_string()+")";
+ }
+ ret += ")";
+ return ret;
+ default:
+ break;
+ }
+ return "Error, unknown extended gb type.";
+ }
+
+};
+
+class extended_gb_list_t{
+public:
+ std::vector<extended_gb_t *> gb_list;
+ int lineno, charno;
+
+ extended_gb_list_t(extended_gb_t *g){gb_list.push_back(g);
+ lineno = flex_fta_lineno; charno = flex_fta_ch;};
+
+ extended_gb_list_t *append(extended_gb_t *s){
+ gb_list.push_back(s);
+ return(this);
+ };
+
+ std::string to_string(){
+ int i;
+ std::string retval;
+ for(i=0;i<gb_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(gb_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<extended_gb_t *> get_gb_list(){return gb_list; };
+};
+
+
+
+/*
+ A predicate tree. Structure is similar to
+ a scalar expression tree but the type is always boolean.
+ Used by
+ opt_where_clause, where_clause, opt_having_clause,
+ search_condition, predicate, comparison_predicate, repl_predicate
+*/
+
+#define PRED_COMPARE 1
+#define PRED_UNARY_OP 2
+#define PRED_BINARY_OP 3
+#define PRED_FUNC 4
+#define PRED_IN 5
+
+class predicate_t{
+public:
+ int operator_type;
+ std::string op;
+ union {
+ predicate_t *predp;
+ scalarexp_t *sexp;
+ }lhs;
+ union {
+ predicate_t *predp;
+ scalarexp_t *sexp;
+ literal_list_t *ll;
+ }rhs;
+ std::vector<scalarexp_t *> param_list; /// pred fcn params
+ int fcn_id; /// external pred fcn id
+ int combinable_ref;
+ bool is_sampling_fcn;
+ int lineno, charno;
+
+ predicate_t(scalarexp_t *s, literal_list_t *litl){
+ operator_type = PRED_IN;
+ op = "in";
+ lhs.sexp = s;
+ rhs.ll = litl;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ predicate_t(scalarexp_t *s, std::vector<literal_t *> litv){
+ operator_type = PRED_IN;
+ op = "in";
+ lhs.sexp = s;
+ rhs.ll = new literal_list_t(litv);
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+
+ predicate_t(scalarexp_t *l_op, const char *o, scalarexp_t *r_op){
+ operator_type = PRED_COMPARE;
+ op = o;
+ lhs.sexp = l_op;
+ rhs.sexp = r_op;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ predicate_t(const char *o, predicate_t *p){
+ operator_type = PRED_UNARY_OP;
+ op = o;
+ lhs.predp = p;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ predicate_t(const char *o, predicate_t *l_p, predicate_t *r_p){
+ operator_type = PRED_BINARY_OP;
+ op = o;
+ lhs.predp = l_p;
+ rhs.predp = r_p;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ predicate_t(const char *o, std::vector<scalarexp_t *> op_list){
+ operator_type = PRED_FUNC;
+ op = o;
+ param_list = op_list;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ predicate_t(const char *o){
+ op = o;
+ fcn_id = -1;
+ combinable_ref = -1;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+
+ static predicate_t *make_paramless_fcn_predicate(const char *o){
+ predicate_t *ret = new predicate_t(o);
+ ret->operator_type = PRED_FUNC;
+ ret->fcn_id = -1;
+ ret->combinable_ref = -1;
+ return(ret);
+ };
+
+ std::string to_string(){
+ if(operator_type == PRED_IN){
+ return( lhs.sexp->to_string() + " " + op + " [ " + rhs.ll->to_string() +" ]");
+ }
+ if(operator_type == PRED_COMPARE){
+ return( lhs.sexp->to_string() + " " + op + " " + rhs.sexp->to_string() );
+ }
+ if(operator_type == PRED_UNARY_OP){
+ return( op + " (" + lhs.predp->to_string() + ")" );
+ }
+ if(operator_type == PRED_BINARY_OP){
+ return( "(" + lhs.predp->to_string() + " " + op + " " + rhs.predp->to_string() + ")" );
+ }
+ if(operator_type == PRED_FUNC){
+ std::string ret = op + "[ ";
+ int i;
+ for(i=0;i<param_list.size();++i){
+ if(i>0) ret += ", ";
+ ret += param_list[i]->to_string();
+ }
+ ret += "] ";
+ return(ret);
+ }
+ return("");
+ };
+
+ std::vector<scalarexp_t *> get_op_list(){return param_list; };
+ int get_operator_type(){return operator_type; };
+ std::string get_op(){return op; };
+ int get_lineno(){return lineno; };
+ int get_charno(){return charno; };
+ int get_combinable_ref(){return combinable_ref;}
+ void set_combinable_ref(int f){combinable_ref = f;};
+ predicate_t *get_left_pr(){return(lhs.predp); };
+ predicate_t *get_right_pr(){return(rhs.predp); };
+ scalarexp_t *get_left_se(){return(lhs.sexp); };
+ scalarexp_t *get_right_se(){return(rhs.sexp); };
+ std::vector<literal_t *> get_lit_vec(){return(rhs.ll->get_literal_vector()); };
+
+ void swap_scalar_operands(){
+ if(operator_type != PRED_COMPARE){
+ fprintf(stderr,"INTERNAL ERROR: swap_scalar_operands called on predicate of type %d\n",operator_type);
+ exit(1);
+ }
+ scalarexp_t *tmp;
+ tmp = lhs.sexp; lhs.sexp = rhs.sexp; rhs.sexp = tmp;
+ if(op == ">"){op = "<"; return;}
+ if(op == ">="){op = "<="; return;}
+ if(op == "<"){op = ">"; return;}
+ if(op == "<="){op = ">="; return;}
+ };
+ void set_fcn_id(int i){fcn_id = i;};
+ int get_fcn_id(){return fcn_id;};
+
+
+};
+
+
+/*
+ A structure that holds the components of a query.
+ This is the root type.
+ Used by manipulative_statement, select_statement, table_exp
+*/
+
+#define SELECT_QUERY 1
+#define MERGE_QUERY 2
+
+class table_exp_t{
+public:
+ int query_type; // roughly, the type of the query.
+ ss_map nmap; // DEFINE block
+ std::vector<var_pair_t *> query_params; // PARAM block (uninterpreted)
+ select_list_t *sl; // SELECT
+ tablevar_list_t *fm; // FROM
+ predicate_t *wh; // WHERE
+ predicate_t *hv; // HAVING
+ predicate_t *cleaning_when; // CLEANING WHEN
+ predicate_t *cleaning_by; // CLEANING BY
+ predicate_t *closing_when; // CLOSING WHEN
+ std::vector<extended_gb_t *> gb; // GROUP BY
+ std::vector<colref_t *> mergevars; // merge colrefs.
+ std::vector<colref_t *> supergb; // supergroup.
+ scalarexp_t *slack; // merge slack
+ bool exernal_visible; // true iff. it can be subscribed to.
+ int lineno, charno;
+
+
+ table_exp_t(tablevar_list_t *f, predicate_t *p, extended_gb_list_t *g, colref_list_t *sg, predicate_t *h, predicate_t *cw, predicate_t *cb, predicate_t *closew)
+ {fm = f; wh = p; hv = h;
+ cleaning_when = cw; cleaning_by = cb;
+ closing_when = closew;
+ if(g != NULL)
+ gb = g->gb_list;
+ if(sg != NULL)
+ supergb = sg->get_clist();
+ slack = NULL;
+ query_type = SELECT_QUERY;
+ exernal_visible = true;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ table_exp_t(colref_list_t *mv, tablevar_list_t *f)
+ {fm = f; mergevars=mv->get_clist();
+ slack = NULL;
+ query_type = MERGE_QUERY;
+ exernal_visible = true;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+ table_exp_t(colref_list_t *mv, scalarexp_t *sl, tablevar_list_t *f)
+ {fm = f; mergevars=mv->get_clist();
+ slack = sl;
+ query_type = MERGE_QUERY;
+ exernal_visible = true;
+ lineno = flex_fta_lineno; charno = flex_fta_ch;
+ };
+
+// Figure out the temporal merge field at analyze_fta time.
+ static table_exp_t *make_deferred_merge(std::vector<std::string> src_tbls){
+ table_exp_t *ret = new table_exp_t();
+ ret->query_type = MERGE_QUERY;
+ ret->fm = new tablevar_list_t();
+ int t;
+ for(t=0;t<src_tbls.size();++t){
+ ret->fm->append_table(new tablevar_t(src_tbls[t].c_str()));
+ }
+ ret->lineno = 0; ret->charno = 0;
+ return ret;
+ }
+
+ table_exp_t(){
+ fm = NULL; sl = NULL; wh=NULL; hv=NULL;
+ slack = NULL;
+ cleaning_when=NULL; cleaning_by = NULL;
+ closing_when = NULL;
+ exernal_visible = true;
+ };
+
+ table_exp_t *add_selection(select_list_t *s){
+ sl = s;
+ return(this);
+ };
+
+ void add_nmap(var_defs_t *vd){
+ int n;
+ if(vd != NULL){
+ for(n=0;n<vd->size();++n){
+ nmap[vd->get_name(n)] = vd->get_def(n);
+//printf("Adding (%s, %s) to name map.\n",vd->get_name(n).c_str(), vd->get_def(n).c_str());
+ }
+ }
+ };
+
+ void add_param_list(var_defs_t *vd){
+ int n;
+ if(vd != NULL){
+ query_params = vd->get_nvec();
+ }
+ };
+
+
+ std::string to_string(){
+ std::string retval;
+ if(sl != NULL){
+ retval.append("Select " + sl->to_string() + "\n");
+ }
+ if(fm != NULL){
+ retval.append("From " + fm->to_string() + "\n");
+ }
+ if(wh != NULL){
+ retval.append("Where "+ wh->to_string() + "\n");
+ }
+ if(hv != NULL){
+ retval.append("Having "+hv->to_string() + "\n");
+ }
+ return(retval);
+ };
+
+ tablevar_list_t *get_from(){return fm; };
+ select_list_t *get_select(){return sl; };
+ std::vector<select_element *> get_sl_vec(){return sl->get_select_list(); };
+ predicate_t *get_where(){return wh; };
+ predicate_t *get_having(){return hv; };
+ predicate_t *get_cleaning_by(){return cleaning_by; };
+ predicate_t *get_cleaning_when(){return cleaning_when; };
+ predicate_t *get_closing_when(){return closing_when; };
+ std::vector<extended_gb_t *> get_groupby(){return(gb); };
+ std::vector<colref_t *> get_supergb(){return supergb;};
+
+ ss_map get_name_map(){return nmap;};
+
+ bool name_exists(std::string nm){
+ return(nmap.count(nm) > 0);
+ };
+
+ std::string get_val_of_name(std::string nm){
+ if(nmap.count(nm) == 0) return("");
+ else return nmap[nm];
+ };
+
+ void set_val_of_name(const std::string n, const std::string v){
+ nmap[n]=v;
+ }
+
+ void set_visible(bool v){exernal_visible=v;};
+ bool get_visible(){return exernal_visible;};
+};
+
+struct query_list_t{
+ std::vector<table_exp_t *> qlist;
+
+ query_list_t(table_exp_t *t){
+ qlist.push_back(t);
+ };
+ query_list_t *append(table_exp_t *t){
+ qlist.push_back(t);
+ return(this);
+ };
+};
+
+
+#define TABLE_PARSE 1
+#define QUERY_PARSE 2
+#define STREAM_PARSE 3
+
+struct fta_parse_t{
+ query_list_t *parse_tree_list;
+ table_exp_t *fta_parse_tree;
+ table_list *tables;
+ int parse_type;
+};
+
+
+
+
+
+ extern table_exp_t *fta_parse_tree;
+
+
+
+
+
+#endif
+
Code Review / com / gs-lite.git / blobdiff