-/* ------------------------------------------------\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 __SCHEMA_DEF_H_INCLUDED__\r
-#define __SCHEMA_DEF_H_INCLUDED__\r
-\r
-#include <string>\r
-#include <vector>\r
-#include <map>\r
-#include<set>\r
-\r
-#include <string.h>\r
-#include <stdlib.h>\r
-\r
-\r
-// A param_list is used to represent a list of\r
-// parameters with optional values.\r
-\r
-class param_list{\r
-private:\r
- std::map< std::string, std::string > pmap;\r
-\r
-public:\r
- param_list(){};\r
- param_list(const char *key){\r
- pmap[key]="";\r
- };\r
- param_list(const char *key, const char *val){\r
- pmap[key]=val;\r
- };\r
-\r
- param_list *append(const char *key){\r
- pmap[key]="";\r
- return(this);\r
- };\r
- param_list *append(const char *key, const char *val){\r
- pmap[key]=val;\r
- return(this);\r
- };\r
- param_list *append( std::string key){\r
- pmap[key]="";\r
- return(this);\r
- };\r
-\r
- int size(){return pmap.size();};\r
-\r
-\r
- bool contains_key(std::string key){\r
- return(pmap.count(key)>0);\r
- }\r
-\r
- int delete_key(std::string k){\r
- return pmap.erase(k);\r
- }\r
-\r
- std::string val_of(std::string key){\r
- if(pmap.count(key)>0)\r
- return(pmap[key]);\r
- return(std::string(""));\r
- }\r
-\r
- std::vector<std::string> get_key_vec(){\r
- std::vector<std::string> retval;\r
- std::map<std::string, std::string>::iterator mssi;\r
- for(mssi=pmap.begin();mssi!=pmap.end();++mssi){\r
- retval.push_back( (*mssi).first );\r
- }\r
- return(retval);\r
- }\r
-\r
- std::string to_string();\r
-};\r
-\r
-\r
-// list of names, order matters.\r
-class name_vec{\r
-public:\r
- std::vector<std::string> svec;\r
- std::vector<std::string> nvec;\r
- std::vector<param_list *> pvec;\r
-\r
- name_vec(char *c, char *n, param_list *p){\r
- svec.push_back(c);\r
- nvec.push_back(n);\r
- if(p) pvec.push_back(p);\r
- else pvec.push_back(new param_list());\r
- };\r
-\r
- name_vec *append(char *c, char *n, param_list *p){\r
- svec.push_back(c);\r
- nvec.push_back(n);\r
- if(p) pvec.push_back(p);\r
- else pvec.push_back(new param_list());\r
- return this;\r
- };\r
-};\r
-\r
-\r
-\r
-// A field in a STREAM or PROTOCOL\r
-\r
-\r
-class field_entry{\r
-private:\r
- std::string type; // data type\r
- std::string name; // name in a query\r
- std::string function; // access function, if any (PROTOCOL only).\r
- param_list *mod_list; // special properties.\r
- std::set<std::string> ufcns; // unpacking functions, if any.\r
-\r
- std::string base_table; // for hierarchically structured data sources,\r
- // the bast table where the field is defined.\r
- // mostly used for computing the LFTA prefilter.\r
-public:\r
-\r
- field_entry(const char *t, const char *n, const char *f, param_list *plist, param_list *ulist){\r
- if(plist == NULL)\r
- mod_list = new param_list();\r
- else\r
- mod_list = plist;\r
- if(ulist){\r
- int u;\r
- std::vector<std::string> tmp_ufl = ulist->get_key_vec();\r
- for(u=0;u<tmp_ufl.size();++u)\r
- ufcns.insert(tmp_ufl[u]);\r
- }\r
-\r
- type=t; name=n; function=f;\r
- base_table = "";\r
- };\r
-\r
- field_entry(std::string t, std::string n, std::string f, param_list *plist, const std::set<std::string> &ulist){\r
- if(plist == NULL)\r
- mod_list = new param_list();\r
- else\r
- mod_list = plist;\r
- ufcns = ulist;\r
- type=t; name=n; function=f;\r
- base_table = "";\r
- };\r
-\r
- field_entry(std::string n, std::string t){\r
- name = n;\r
- type = t;\r
- mod_list = new param_list();\r
- }\r
-\r
- void add_unpack_fcns(param_list *ufl){\r
- std::vector<std::string> new_ufl = ufl->get_key_vec();\r
- int u;\r
- for(u=0;u<new_ufl.size();++u)\r
- ufcns.insert(new_ufl[u]);\r
- }\r
-\r
-\r
- param_list *get_modifier_list(){return mod_list; };\r
- std::string get_type(){return(type);};\r
- std::string get_name(){return(name);};\r
- std::string get_fcn(){return(function);};\r
- std::set<std::string> get_unpack_fcns(){\r
- return ufcns;\r
- }\r
-\r
- void set_basetable(std::string b){base_table=b;};\r
- std::string get_basetable(){return base_table;};\r
-\r
- std::string to_string();\r
-\r
- int delete_modifier(std::string k){\r
- return mod_list->delete_key(k);\r
- }\r
- void add_modifier(const char *k, const char *v){\r
- mod_list->append(k,v);\r
- }\r
- void add_modifier(const char *k){\r
- mod_list->append(k);\r
- }\r
-\r
-};\r
-\r
-\r
-// list of fields. An intermediate parse structure.\r
-// it gets loaded into table_def.fields\r
-\r
-class field_entry_list{\r
-private:\r
- std::vector<field_entry *> fl;\r
-\r
-public:\r
- field_entry_list(){};\r
-\r
- field_entry_list(field_entry *f){\r
- fl.push_back(f);\r
- };\r
-\r
- field_entry_list *append_field(field_entry *f){\r
- fl.push_back(f);\r
- return(this);\r
- };\r
-\r
- std::vector<field_entry *> get_list(){return fl; };\r
-};\r
-\r
-class subquery_spec{\r
-public:\r
- std::string name;\r
- std::vector<std::string> types;\r
- std::vector<std::string> names;\r
- std::vector<param_list *> modifiers;\r
-\r
-\r
- subquery_spec(){}\r
-\r
- subquery_spec(const char *n, name_vec *t){\r
- name = n;\r
- types = t->svec;\r
- names = t->nvec;\r
- modifiers = t->pvec;\r
- };\r
-\r
- std::string to_string(){\r
- std::string ret = name+" (";\r
- int i;\r
- for(i=0;i<types.size();++i){\r
- if(i>0) ret+=", ";\r
- ret += types[i] + " " + names[i];\r
- if(modifiers[i]->size() >0){\r
- ret+=" ("+modifiers[i]->to_string()+") ";\r
- }\r
- }\r
- ret += ") ";\r
- return(ret);\r
- };\r
-\r
- subquery_spec *duplicate(){\r
- subquery_spec *ret = new subquery_spec();\r
- ret->name = name;\r
- ret->types = types;\r
- ret->names = names;\r
-\r
- return ret;\r
- }\r
-\r
-\r
-\r
-};\r
-\r
-class subqueryspec_list{\r
-public:\r
- std::vector<subquery_spec *> spec_list;\r
-\r
- subqueryspec_list(subquery_spec *ss){\r
- spec_list.push_back(ss);\r
- };\r
- subqueryspec_list *append(subquery_spec *ss){\r
- spec_list.push_back(ss);\r
- return this;\r
- };\r
-};\r
-\r
-class unpack_fcn{\r
-public:\r
- std::string name;\r
- std::string fcn;\r
- int cost;\r
-\r
- unpack_fcn(const char *n, const char *f, const char *c){\r
- name = n;\r
- fcn = f;\r
- cost = atoi(c);\r
- };\r
-};\r
-\r
-class unpack_fcn_list{\r
-public:\r
- std::vector<unpack_fcn *> ufcn_v;\r
-\r
- unpack_fcn_list(unpack_fcn *u){\r
- ufcn_v.push_back(u);\r
- };\r
-\r
- unpack_fcn_list *append(unpack_fcn *u){\r
- ufcn_v.push_back(u);\r
- return this;\r
- };\r
-};\r
-\r
-\r
-\r
-\r
-// forward definition, needed for table_def\r
-class table_exp_t;\r
-struct query_list_t;\r
-\r
-/* ============================================\r
- The schema can support several different\r
- flavors of table.\r
- PROTOCOL : the base data that an FTA can retrieve.\r
- STREAM : Data created by an FTA or a stream operator.\r
- More to come. Perhaps this is better handled by\r
- annotations in the schema def.\r
- ============================================= */\r
-\r
-#define PROTOCOL_SCHEMA 1\r
-#define STREAM_SCHEMA 2\r
-#define OPERATOR_VIEW_SCHEMA 3\r
-#define UNPACK_FCNS_SCHEMA 4\r
-\r
-// Represent a STREAM, PROTOCOL, OPERATOR_VIEW, or UNPACK_FCN list.\r
-\r
-class table_def{\r
-private:\r
- std::string table_name;\r
- std::vector<field_entry *> fields;\r
- param_list *base_tables; // if PROTOCOL, the PROTOCOLS that\r
- // this PROTOCOL inherits fields from.\r
- int schema_type; // STREAM_SCHEMA, PROTOCOL_SCHEMA, OPERATOR_VIEW_SCHEMA\r
-// For operator_view tables\r
- param_list *op_properties;\r
- std::vector<subquery_spec *> qspec_list;\r
- param_list *selpush;\r
-\r
-public:\r
-// for unpacking function group specs.\r
- std::vector<unpack_fcn *> ufcn_list;\r
-\r
-\r
-\r
-// Unpack functions defined at the PROTOCOL level are added to\r
-// PROTOCOL fields here ... implying that ony those fields\r
-// explicitly defined in the PROTOCOL (as opposed to inherited)\r
-// get the PROTOCOL-wide unpack functions.\r
- table_def(const char *name, param_list *plist, param_list *ufcn_l, field_entry_list *fel, int sch_t){\r
- int f;\r
- if(plist == NULL)\r
- base_tables = new param_list();\r
- else\r
- base_tables = plist;\r
- table_name =name;\r
- fields = fel->get_list();\r
- schema_type = sch_t;\r
-\r
-// fields inherit table-level unpacking functions, if any.\r
- if(ufcn_l){\r
- for(f=0;f<fields.size();++f)\r
- fields[f]->add_unpack_fcns(ufcn_l);\r
- }\r
-\r
- op_properties = new param_list();\r
- selpush = new param_list();\r
- };\r
-\r
- table_def(const char *name, param_list *oprop, field_entry_list *fel,\r
- subqueryspec_list *ql, param_list *selp);\r
-\r
- table_def(unpack_fcn_list *ufcn_l){\r
- schema_type = UNPACK_FCNS_SCHEMA;\r
- ufcn_list = ufcn_l->ufcn_v;\r
- }\r
-\r
- table_def(){};\r
-\r
- table_def *make_shallow_copy(std::string n);\r
-\r
- void mangle_subq_names(std::string mngl);\r
-\r
- std::string get_tbl_name(){return table_name; };\r
- std::vector<field_entry *> get_fields(){return(fields); };\r
-\r
- field_entry *get_field(int i){\r
- if(i>=0 && i<fields.size()) return(fields[i]);\r
- return NULL;\r
- };\r
-\r
- std::string get_field_name(int i){\r
- if(i>=0 && i<fields.size()) return(fields[i]->get_name());\r
- return "";\r
- };\r
-\r
- bool contains_field(std::string f);\r
- bool contains_field(int f);\r
-\r
- int get_field_idx(std::string f);\r
- std::string get_type_name(std::string f);\r
- param_list *get_modifier_list(std::string f);\r
- std::string get_fcn(std::string f);\r
-\r
- std::string get_op_prop(std::string s){\r
- return op_properties->val_of(s);\r
- };\r
-\r
-// Used in generating the LFTA prefilter\r
- std::string get_field_basetable(std::string f);\r
-\r
-\r
- int verify_no_duplicates(std::string &err);\r
- int verify_access_fcns(std::string &err);\r
-\r
-\r
- std::vector<std::string> get_pred_tbls(){\r
- return base_tables->get_key_vec() ;\r
- };\r
-\r
- int add_field(field_entry *fe);\r
-\r
- int get_schema_type(){return schema_type;};\r
-\r
- std::vector<subquery_spec *> get_subqueryspecs(){return qspec_list;};\r
-\r
- std::string to_string();\r
- std::string to_stream_string(){\r
- int tmp_sch = schema_type;\r
- schema_type = STREAM_SCHEMA;\r
- std::string ret = this->to_string();\r
- schema_type = tmp_sch;\r
- return ret;\r
- }\r
-};\r
-\r
-\r
-// A Schema -- a collection of stream layout definitions.\r
-\r
-class table_list{\r
-private:\r
- std::vector<table_def *> tbl_list;\r
- // for an unpack_fcn_list, collect from the set of\r
- // UNPACK_FCNS_SCHEMA in the table list.\r
- std::map<std::string, std::string> ufcn_fcn;\r
- std::map<std::string, int> ufcn_cost;\r
-\r
-\r
-public:\r
- table_list(table_def *td){tbl_list.push_back(td); };\r
- table_list(){};\r
-\r
- table_list *append_table(table_def *td){\r
- tbl_list.push_back(td);\r
- return(this);\r
- };\r
-\r
- int add_table(table_def *td);\r
- table_def *get_table(int t){\r
- if(t<0 || t>tbl_list.size()) return(NULL);\r
- return(tbl_list[t]);\r
- };\r
-\r
- int add_duplicate_table(std::string src, std::string dest){\r
- int src_pos = this->find_tbl(src);\r
- if(src_pos<0)\r
- return src_pos;\r
- table_def *dest_tbl = tbl_list[src_pos]->make_shallow_copy(dest);\r
- tbl_list.push_back(dest_tbl);\r
- return tbl_list.size()-1;\r
- }\r
-\r
- void mangle_subq_names(int pos, std::string mngl){\r
- tbl_list[pos]->mangle_subq_names(mngl);\r
- }\r
-\r
-\r
- int size(){return tbl_list.size();};\r
-\r
-/////////////\r
-// Accessor methods : get table and field info without\r
-// descending into the underlying data structures.\r
-// Can specify a table by name (string), or by index (int)\r
-// (e.g. returned by get_table_ref)\r
-\r
- int get_ufcn_cost(std::string fname){\r
- if(ufcn_cost.count(fname))\r
- return ufcn_cost[fname];\r
- else\r
- return -1;\r
- }\r
- std::string get_ufcn_fcn(std::string fname){\r
- if(ufcn_fcn.count(fname))\r
- return ufcn_fcn[fname];\r
- else\r
- return "ERROR_ufcn_fcn_of_"+fname+"_not_found";\r
- }\r
-\r
- std::string get_table_name(int i){\r
- if(i>tbl_list.size()) return("");\r
- else return tbl_list[i]->get_tbl_name();\r
- };\r
- std::vector<std::string> get_table_names();\r
-\r
- std::vector<field_entry *> get_fields(std::string t);\r
- field_entry *get_field(std::string t, int i);\r
- field_entry *get_field(int t, std::string f){\r
- return tbl_list[t]->get_field(tbl_list[t]->get_field_idx(f));\r
- }\r
- int get_field_idx(std::string t, std::string f);\r
-\r
- int find_tbl(std::string t);\r
-\r
- std::vector<int> get_tblref_of_field(std::string f);\r
-\r
- int get_table_ref(std::string t);\r
-\r
- std::string get_type_name(int t, std::string f){\r
- return(tbl_list[t]->get_type_name(f));\r
- };\r
-\r
- param_list *get_modifier_list(int t, std::string f){\r
- return(tbl_list[t]->get_modifier_list(f));\r
- };\r
-\r
- std::string get_fcn(int t, std::string f){\r
- return(tbl_list[t]->get_fcn(f));\r
- };\r
-\r
- int get_schema_type(int t){\r
- return(tbl_list[t]->get_schema_type());\r
- };\r
-\r
- std::string get_op_prop(int t, std::string s){\r
- return(tbl_list[t]->get_op_prop(s));\r
- };\r
-\r
- std::vector<subquery_spec *> get_subqueryspecs(int t){\r
- return tbl_list[t]->get_subqueryspecs();\r
- };\r
-\r
-\r
-// Used in generating the LFTA prefilter\r
- std::string get_basetbl_name(int t, std::string f){\r
- return(tbl_list[t]->get_field_basetable(f));\r
- };\r
-\r
- bool contains_field(int t, std::string f){\r
- return(tbl_list[t]->contains_field(f));\r
- };\r
-\r
-\r
-//////////////\r
-// Additional methods\r
-\r
-// Process field inheritance for PROTOCOL tables.\r
- int unroll_tables(std::string &err);\r
-\r
- std::string to_string();\r
-};\r
-#endif\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 __SCHEMA_DEF_H_INCLUDED__
+#define __SCHEMA_DEF_H_INCLUDED__
+
+#include <string>
+#include <vector>
+#include <map>
+#include<set>
+
+#include <string.h>
+#include <stdlib.h>
+
+
+// A param_list is used to represent a list of
+// parameters with optional values.
+
+class param_list{
+private:
+ std::map< std::string, std::string > pmap;
+
+public:
+ param_list(){};
+ param_list(const char *key){
+ pmap[key]="";
+ };
+ param_list(const char *key, const char *val){
+ pmap[key]=val;
+ };
+
+ param_list *append(const char *key){
+ pmap[key]="";
+ return(this);
+ };
+ param_list *append(const char *key, const char *val){
+ pmap[key]=val;
+ return(this);
+ };
+ param_list *append( std::string key){
+ pmap[key]="";
+ return(this);
+ };
+
+ int size(){return pmap.size();};
+
+
+ bool contains_key(std::string key){
+ return(pmap.count(key)>0);
+ }
+
+ int delete_key(std::string k){
+ return pmap.erase(k);
+ }
+
+ std::string val_of(std::string key){
+ if(pmap.count(key)>0)
+ return(pmap[key]);
+ return(std::string(""));
+ }
+
+ std::vector<std::string> get_key_vec(){
+ std::vector<std::string> retval;
+ std::map<std::string, std::string>::iterator mssi;
+ for(mssi=pmap.begin();mssi!=pmap.end();++mssi){
+ retval.push_back( (*mssi).first );
+ }
+ return(retval);
+ }
+
+ std::string to_string();
+};
+
+
+// list of names, order matters.
+class name_vec{
+public:
+ std::vector<std::string> svec;
+ std::vector<std::string> nvec;
+ std::vector<param_list *> pvec;
+
+ name_vec(char *c, char *n, param_list *p){
+ svec.push_back(c);
+ nvec.push_back(n);
+ if(p) pvec.push_back(p);
+ else pvec.push_back(new param_list());
+ };
+
+ name_vec *append(char *c, char *n, param_list *p){
+ svec.push_back(c);
+ nvec.push_back(n);
+ if(p) pvec.push_back(p);
+ else pvec.push_back(new param_list());
+ return this;
+ };
+};
+
+
+
+// A field in a STREAM or PROTOCOL
+
+
+class field_entry{
+private:
+ std::string type; // data type
+ std::string name; // name in a query
+ std::string function; // access function, if any (PROTOCOL only).
+ param_list *mod_list; // special properties.
+ std::set<std::string> ufcns; // unpacking functions, if any.
+
+ std::string base_table; // for hierarchically structured data sources,
+ // the bast table where the field is defined.
+ // mostly used for computing the LFTA prefilter.
+public:
+
+ field_entry(const char *t, const char *n, const char *f, param_list *plist, param_list *ulist){
+ if(plist == NULL)
+ mod_list = new param_list();
+ else
+ mod_list = plist;
+ if(ulist){
+ int u;
+ std::vector<std::string> tmp_ufl = ulist->get_key_vec();
+ for(u=0;u<tmp_ufl.size();++u)
+ ufcns.insert(tmp_ufl[u]);
+ }
+
+ type=t; name=n; function=f;
+ base_table = "";
+ };
+
+ field_entry(std::string t, std::string n, std::string f, param_list *plist, const std::set<std::string> &ulist){
+ if(plist == NULL)
+ mod_list = new param_list();
+ else
+ mod_list = plist;
+ ufcns = ulist;
+ type=t; name=n; function=f;
+ base_table = "";
+ };
+
+ field_entry(std::string n, std::string t){
+ name = n;
+ type = t;
+ mod_list = new param_list();
+ }
+
+ void add_unpack_fcns(param_list *ufl){
+ std::vector<std::string> new_ufl = ufl->get_key_vec();
+ int u;
+ for(u=0;u<new_ufl.size();++u)
+ ufcns.insert(new_ufl[u]);
+ }
+
+
+ param_list *get_modifier_list(){return mod_list; };
+ std::string get_type(){return(type);};
+ std::string get_name(){return(name);};
+ std::string get_fcn(){return(function);};
+ std::set<std::string> get_unpack_fcns(){
+ return ufcns;
+ }
+
+ void set_basetable(std::string b){base_table=b;};
+ std::string get_basetable(){return base_table;};
+
+ std::string to_string();
+
+ int delete_modifier(std::string k){
+ return mod_list->delete_key(k);
+ }
+ void add_modifier(const char *k, const char *v){
+ mod_list->append(k,v);
+ }
+ void add_modifier(const char *k){
+ mod_list->append(k);
+ }
+
+};
+
+
+// list of fields. An intermediate parse structure.
+// it gets loaded into table_def.fields
+
+class field_entry_list{
+private:
+ std::vector<field_entry *> fl;
+
+public:
+ field_entry_list(){};
+
+ field_entry_list(field_entry *f){
+ fl.push_back(f);
+ };
+
+ field_entry_list *append_field(field_entry *f){
+ fl.push_back(f);
+ return(this);
+ };
+
+ std::vector<field_entry *> get_list(){return fl; };
+};
+
+class subquery_spec{
+public:
+ std::string name;
+ std::vector<std::string> types;
+ std::vector<std::string> names;
+ std::vector<param_list *> modifiers;
+
+
+ subquery_spec(){}
+
+ subquery_spec(const char *n, name_vec *t){
+ name = n;
+ types = t->svec;
+ names = t->nvec;
+ modifiers = t->pvec;
+ };
+
+ std::string to_string(){
+ std::string ret = name+" (";
+ int i;
+ for(i=0;i<types.size();++i){
+ if(i>0) ret+=", ";
+ ret += types[i] + " " + names[i];
+ if(modifiers[i]->size() >0){
+ ret+=" ("+modifiers[i]->to_string()+") ";
+ }
+ }
+ ret += ") ";
+ return(ret);
+ };
+
+ subquery_spec *duplicate(){
+ subquery_spec *ret = new subquery_spec();
+ ret->name = name;
+ ret->types = types;
+ ret->names = names;
+
+ return ret;
+ }
+
+
+
+};
+
+class subqueryspec_list{
+public:
+ std::vector<subquery_spec *> spec_list;
+
+ subqueryspec_list(subquery_spec *ss){
+ spec_list.push_back(ss);
+ };
+ subqueryspec_list *append(subquery_spec *ss){
+ spec_list.push_back(ss);
+ return this;
+ };
+};
+
+class unpack_fcn{
+public:
+ std::string name;
+ std::string fcn;
+ int cost;
+
+ unpack_fcn(const char *n, const char *f, const char *c){
+ name = n;
+ fcn = f;
+ cost = atoi(c);
+ };
+};
+
+class unpack_fcn_list{
+public:
+ std::vector<unpack_fcn *> ufcn_v;
+
+ unpack_fcn_list(unpack_fcn *u){
+ ufcn_v.push_back(u);
+ };
+
+ unpack_fcn_list *append(unpack_fcn *u){
+ ufcn_v.push_back(u);
+ return this;
+ };
+};
+
+
+
+
+// forward definition, needed for table_def
+class table_exp_t;
+struct query_list_t;
+
+/* ============================================
+ The schema can support several different
+ flavors of table.
+ PROTOCOL : the base data that an FTA can retrieve.
+ STREAM : Data created by an FTA or a stream operator.
+ More to come. Perhaps this is better handled by
+ annotations in the schema def.
+ ============================================= */
+
+#define PROTOCOL_SCHEMA 1
+#define STREAM_SCHEMA 2
+#define OPERATOR_VIEW_SCHEMA 3
+#define UNPACK_FCNS_SCHEMA 4
+
+// Represent a STREAM, PROTOCOL, OPERATOR_VIEW, or UNPACK_FCN list.
+
+class table_def{
+private:
+ std::string table_name;
+ std::vector<field_entry *> fields;
+ param_list *base_tables; // if PROTOCOL, the PROTOCOLS that
+ // this PROTOCOL inherits fields from.
+ int schema_type; // STREAM_SCHEMA, PROTOCOL_SCHEMA, OPERATOR_VIEW_SCHEMA
+// For operator_view tables
+ param_list *op_properties;
+ std::vector<subquery_spec *> qspec_list;
+ param_list *selpush;
+
+public:
+// for unpacking function group specs.
+ std::vector<unpack_fcn *> ufcn_list;
+
+
+
+// Unpack functions defined at the PROTOCOL level are added to
+// PROTOCOL fields here ... implying that ony those fields
+// explicitly defined in the PROTOCOL (as opposed to inherited)
+// get the PROTOCOL-wide unpack functions.
+ table_def(const char *name, param_list *plist, param_list *ufcn_l, field_entry_list *fel, int sch_t){
+ int f;
+ if(plist == NULL)
+ base_tables = new param_list();
+ else
+ base_tables = plist;
+ table_name =name;
+ fields = fel->get_list();
+ schema_type = sch_t;
+
+// fields inherit table-level unpacking functions, if any.
+ if(ufcn_l){
+ for(f=0;f<fields.size();++f)
+ fields[f]->add_unpack_fcns(ufcn_l);
+ }
+
+ op_properties = new param_list();
+ selpush = new param_list();
+ };
+
+ table_def(const char *name, param_list *oprop, field_entry_list *fel,
+ subqueryspec_list *ql, param_list *selp);
+
+ table_def(unpack_fcn_list *ufcn_l){
+ schema_type = UNPACK_FCNS_SCHEMA;
+ ufcn_list = ufcn_l->ufcn_v;
+ }
+
+ table_def(){};
+
+ table_def *make_shallow_copy(std::string n);
+
+ void mangle_subq_names(std::string mngl);
+
+ std::string get_tbl_name(){return table_name; };
+ std::vector<field_entry *> get_fields(){return(fields); };
+
+ field_entry *get_field(int i){
+ if(i>=0 && i<fields.size()) return(fields[i]);
+ return NULL;
+ };
+
+ std::string get_field_name(int i){
+ if(i>=0 && i<fields.size()) return(fields[i]->get_name());
+ return "";
+ };
+
+ bool contains_field(std::string f);
+ bool contains_field(int f);
+
+ int get_field_idx(std::string f);
+ std::string get_type_name(std::string f);
+ param_list *get_modifier_list(std::string f);
+ std::string get_fcn(std::string f);
+
+ std::string get_op_prop(std::string s){
+ return op_properties->val_of(s);
+ };
+
+// Used in generating the LFTA prefilter
+ std::string get_field_basetable(std::string f);
+
+
+ int verify_no_duplicates(std::string &err);
+ int verify_access_fcns(std::string &err);
+
+
+ std::vector<std::string> get_pred_tbls(){
+ return base_tables->get_key_vec() ;
+ };
+
+ int add_field(field_entry *fe);
+
+ int get_schema_type(){return schema_type;};
+
+ std::vector<subquery_spec *> get_subqueryspecs(){return qspec_list;};
+
+ std::string to_string();
+ std::string to_stream_string(){
+ int tmp_sch = schema_type;
+ schema_type = STREAM_SCHEMA;
+ std::string ret = this->to_string();
+ schema_type = tmp_sch;
+ return ret;
+ }
+};
+
+
+// A Schema -- a collection of stream layout definitions.
+
+class table_list{
+private:
+ std::vector<table_def *> tbl_list;
+ // for an unpack_fcn_list, collect from the set of
+ // UNPACK_FCNS_SCHEMA in the table list.
+ std::map<std::string, std::string> ufcn_fcn;
+ std::map<std::string, int> ufcn_cost;
+
+
+public:
+ table_list(table_def *td){tbl_list.push_back(td); };
+ table_list(){};
+
+ table_list *append_table(table_def *td){
+ tbl_list.push_back(td);
+ return(this);
+ };
+
+ int add_table(table_def *td);
+ table_def *get_table(int t){
+ if(t<0 || t>tbl_list.size()) return(NULL);
+ return(tbl_list[t]);
+ };
+
+ int add_duplicate_table(std::string src, std::string dest){
+ int src_pos = this->find_tbl(src);
+ if(src_pos<0)
+ return src_pos;
+ table_def *dest_tbl = tbl_list[src_pos]->make_shallow_copy(dest);
+ tbl_list.push_back(dest_tbl);
+ return tbl_list.size()-1;
+ }
+
+ void mangle_subq_names(int pos, std::string mngl){
+ tbl_list[pos]->mangle_subq_names(mngl);
+ }
+
+
+ int size(){return tbl_list.size();};
+
+/////////////
+// Accessor methods : get table and field info without
+// descending into the underlying data structures.
+// Can specify a table by name (string), or by index (int)
+// (e.g. returned by get_table_ref)
+
+ int get_ufcn_cost(std::string fname){
+ if(ufcn_cost.count(fname))
+ return ufcn_cost[fname];
+ else
+ return -1;
+ }
+ std::string get_ufcn_fcn(std::string fname){
+ if(ufcn_fcn.count(fname))
+ return ufcn_fcn[fname];
+ else
+ return "ERROR_ufcn_fcn_of_"+fname+"_not_found";
+ }
+
+ std::string get_table_name(int i){
+ if(i>tbl_list.size()) return("");
+ else return tbl_list[i]->get_tbl_name();
+ };
+ std::vector<std::string> get_table_names();
+
+ std::vector<field_entry *> get_fields(std::string t);
+ field_entry *get_field(std::string t, int i);
+ field_entry *get_field(int t, std::string f){
+ return tbl_list[t]->get_field(tbl_list[t]->get_field_idx(f));
+ }
+ int get_field_idx(std::string t, std::string f);
+
+ int find_tbl(std::string t);
+
+ std::vector<int> get_tblref_of_field(std::string f);
+
+ int get_table_ref(std::string t);
+
+ std::string get_type_name(int t, std::string f){
+ return(tbl_list[t]->get_type_name(f));
+ };
+
+ param_list *get_modifier_list(int t, std::string f){
+ return(tbl_list[t]->get_modifier_list(f));
+ };
+
+ std::string get_fcn(int t, std::string f){
+ return(tbl_list[t]->get_fcn(f));
+ };
+
+ int get_schema_type(int t){
+ return(tbl_list[t]->get_schema_type());
+ };
+
+ std::string get_op_prop(int t, std::string s){
+ return(tbl_list[t]->get_op_prop(s));
+ };
+
+ std::vector<subquery_spec *> get_subqueryspecs(int t){
+ return tbl_list[t]->get_subqueryspecs();
+ };
+
+
+// Used in generating the LFTA prefilter
+ std::string get_basetbl_name(int t, std::string f){
+ return(tbl_list[t]->get_field_basetable(f));
+ };
+
+ bool contains_field(int t, std::string f){
+ return(tbl_list[t]->contains_field(f));
+ };
+
+
+//////////////
+// Additional methods
+
+// Process field inheritance for PROTOCOL tables.
+ int unroll_tables(std::string &err);
+
+ std::string to_string();
+};
+#endif
Code Review / com / gs-lite.git / blobdiff