1 /* ------------------------------------------------
2 Copyright 2014 AT&T Intellectual Property
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
7 http://www.apache.org/licenses/LICENSE-2.0
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ------------------------------------------- */
15 #ifndef __SCHEMA_DEF_H_INCLUDED__
16 #define __SCHEMA_DEF_H_INCLUDED__
27 // A param_list is used to represent a list of
28 // parameters with optional values.
32 std::map< std::string, std::string > pmap;
36 param_list(const char *key){
39 param_list(const char *key, const char *val){
43 param_list *append(const char *key){
47 param_list *append(const char *key, const char *val){
51 param_list *append( std::string key){
56 int size(){return pmap.size();};
59 bool contains_key(std::string key){
60 return(pmap.count(key)>0);
63 int delete_key(std::string k){
67 std::string val_of(std::string key){
70 return(std::string(""));
73 std::vector<std::string> get_key_vec(){
74 std::vector<std::string> retval;
75 std::map<std::string, std::string>::iterator mssi;
76 for(mssi=pmap.begin();mssi!=pmap.end();++mssi){
77 retval.push_back( (*mssi).first );
82 std::string to_string();
86 // list of names, order matters.
89 std::vector<std::string> svec;
90 std::vector<std::string> nvec;
91 std::vector<param_list *> pvec;
93 name_vec(char *c, char *n, param_list *p){
96 if(p) pvec.push_back(p);
97 else pvec.push_back(new param_list());
100 name_vec *append(char *c, char *n, param_list *p){
103 if(p) pvec.push_back(p);
104 else pvec.push_back(new param_list());
111 // A field in a STREAM or PROTOCOL
116 std::string type; // data type
117 std::string name; // name in a query
118 std::string function; // access function, if any (PROTOCOL only).
119 param_list *mod_list; // special properties.
120 std::set<std::string> ufcns; // unpacking functions, if any.
122 std::string base_table; // for hierarchically structured data sources,
123 // the bast table where the field is defined.
124 // mostly used for computing the LFTA prefilter.
127 field_entry(const char *t, const char *n, const char *f, param_list *plist, param_list *ulist){
129 mod_list = new param_list();
134 std::vector<std::string> tmp_ufl = ulist->get_key_vec();
135 for(u=0;u<tmp_ufl.size();++u)
136 ufcns.insert(tmp_ufl[u]);
139 type=t; name=n; function=f;
143 field_entry(std::string t, std::string n, std::string f, param_list *plist, const std::set<std::string> &ulist){
145 mod_list = new param_list();
149 type=t; name=n; function=f;
153 field_entry(std::string n, std::string t){
156 mod_list = new param_list();
159 void add_unpack_fcns(param_list *ufl){
160 std::vector<std::string> new_ufl = ufl->get_key_vec();
162 for(u=0;u<new_ufl.size();++u)
163 ufcns.insert(new_ufl[u]);
167 param_list *get_modifier_list(){return mod_list; };
168 std::string get_type(){return(type);};
169 std::string get_name(){return(name);};
170 std::string get_fcn(){return(function);};
171 std::set<std::string> get_unpack_fcns(){
175 void set_basetable(std::string b){base_table=b;};
176 std::string get_basetable(){return base_table;};
178 std::string to_string();
180 int delete_modifier(std::string k){
181 return mod_list->delete_key(k);
183 void add_modifier(const char *k, const char *v){
184 mod_list->append(k,v);
186 void add_modifier(const char *k){
193 // list of fields. An intermediate parse structure.
194 // it gets loaded into table_def.fields
196 class field_entry_list{
198 std::vector<field_entry *> fl;
201 field_entry_list(){};
203 field_entry_list(field_entry *f){
207 field_entry_list *append_field(field_entry *f){
212 std::vector<field_entry *> get_list(){return fl; };
218 std::vector<std::string> types;
219 std::vector<std::string> names;
220 std::vector<param_list *> modifiers;
225 subquery_spec(const char *n, name_vec *t){
232 std::string to_string(){
233 std::string ret = name+" (";
235 for(i=0;i<types.size();++i){
237 ret += types[i] + " " + names[i];
238 if(modifiers[i]->size() >0){
239 ret+=" ("+modifiers[i]->to_string()+") ";
246 subquery_spec *duplicate(){
247 subquery_spec *ret = new subquery_spec();
259 class subqueryspec_list{
261 std::vector<subquery_spec *> spec_list;
263 subqueryspec_list(subquery_spec *ss){
264 spec_list.push_back(ss);
266 subqueryspec_list *append(subquery_spec *ss){
267 spec_list.push_back(ss);
278 unpack_fcn(const char *n, const char *f, const char *c){
285 class unpack_fcn_list{
287 std::vector<unpack_fcn *> ufcn_v;
289 unpack_fcn_list(unpack_fcn *u){
293 unpack_fcn_list *append(unpack_fcn *u){
302 // forward definition, needed for table_def
306 /* ============================================
307 The schema can support several different
309 PROTOCOL : the base data that an FTA can retrieve.
310 STREAM : Data created by an FTA or a stream operator.
311 More to come. Perhaps this is better handled by
312 annotations in the schema def.
313 ============================================= */
315 #define PROTOCOL_SCHEMA 1
316 #define STREAM_SCHEMA 2
317 #define OPERATOR_VIEW_SCHEMA 3
318 #define UNPACK_FCNS_SCHEMA 4
320 // Represent a STREAM, PROTOCOL, OPERATOR_VIEW, or UNPACK_FCN list.
324 std::string table_name;
325 std::vector<field_entry *> fields;
326 param_list *base_tables; // if PROTOCOL, the PROTOCOLS that
327 // this PROTOCOL inherits fields from.
328 int schema_type; // STREAM_SCHEMA, PROTOCOL_SCHEMA, OPERATOR_VIEW_SCHEMA
329 // For operator_view tables
330 param_list *op_properties;
331 std::vector<subquery_spec *> qspec_list;
335 // for unpacking function group specs.
336 std::vector<unpack_fcn *> ufcn_list;
340 // Unpack functions defined at the PROTOCOL level are added to
341 // PROTOCOL fields here ... implying that ony those fields
342 // explicitly defined in the PROTOCOL (as opposed to inherited)
343 // get the PROTOCOL-wide unpack functions.
344 table_def(const char *name, param_list *plist, param_list *ufcn_l, field_entry_list *fel, int sch_t){
347 base_tables = new param_list();
351 fields = fel->get_list();
354 // fields inherit table-level unpacking functions, if any.
356 for(f=0;f<fields.size();++f)
357 fields[f]->add_unpack_fcns(ufcn_l);
360 op_properties = new param_list();
361 selpush = new param_list();
364 table_def(const char *name, param_list *oprop, field_entry_list *fel,
365 subqueryspec_list *ql, param_list *selp);
367 table_def(unpack_fcn_list *ufcn_l){
368 schema_type = UNPACK_FCNS_SCHEMA;
369 ufcn_list = ufcn_l->ufcn_v;
374 table_def *make_shallow_copy(std::string n);
376 void mangle_subq_names(std::string mngl);
378 std::string get_tbl_name(){return table_name; };
379 std::vector<field_entry *> get_fields(){return(fields); };
381 field_entry *get_field(int i){
382 if(i>=0 && i<fields.size()) return(fields[i]);
386 std::string get_field_name(int i){
387 if(i>=0 && i<fields.size()) return(fields[i]->get_name());
391 bool contains_field(std::string f);
392 bool contains_field(int f);
394 int get_field_idx(std::string f);
395 std::string get_type_name(std::string f);
396 param_list *get_modifier_list(std::string f);
397 std::string get_fcn(std::string f);
399 std::string get_op_prop(std::string s){
400 return op_properties->val_of(s);
403 // Used in generating the LFTA prefilter
404 std::string get_field_basetable(std::string f);
407 int verify_no_duplicates(std::string &err);
408 int verify_access_fcns(std::string &err);
411 std::vector<std::string> get_pred_tbls(){
412 return base_tables->get_key_vec() ;
415 int add_field(field_entry *fe);
417 int get_schema_type(){return schema_type;};
419 std::vector<subquery_spec *> get_subqueryspecs(){return qspec_list;};
421 std::string to_string();
422 std::string to_stream_string(){
423 int tmp_sch = schema_type;
424 schema_type = STREAM_SCHEMA;
425 std::string ret = this->to_string();
426 schema_type = tmp_sch;
432 // A Schema -- a collection of stream layout definitions.
436 std::vector<table_def *> tbl_list;
437 // for an unpack_fcn_list, collect from the set of
438 // UNPACK_FCNS_SCHEMA in the table list.
439 std::map<std::string, std::string> ufcn_fcn;
440 std::map<std::string, int> ufcn_cost;
444 table_list(table_def *td){tbl_list.push_back(td); };
447 table_list *append_table(table_def *td){
448 tbl_list.push_back(td);
452 int add_table(table_def *td);
453 table_def *get_table(int t){
454 if(t<0 || t>tbl_list.size()) return(NULL);
458 int add_duplicate_table(std::string src, std::string dest){
459 int src_pos = this->find_tbl(src);
462 table_def *dest_tbl = tbl_list[src_pos]->make_shallow_copy(dest);
463 tbl_list.push_back(dest_tbl);
464 return tbl_list.size()-1;
467 void mangle_subq_names(int pos, std::string mngl){
468 tbl_list[pos]->mangle_subq_names(mngl);
472 int size(){return tbl_list.size();};
475 // Accessor methods : get table and field info without
476 // descending into the underlying data structures.
477 // Can specify a table by name (string), or by index (int)
478 // (e.g. returned by get_table_ref)
480 int get_ufcn_cost(std::string fname){
481 if(ufcn_cost.count(fname))
482 return ufcn_cost[fname];
486 std::string get_ufcn_fcn(std::string fname){
487 if(ufcn_fcn.count(fname))
488 return ufcn_fcn[fname];
490 return "ERROR_ufcn_fcn_of_"+fname+"_not_found";
493 std::string get_table_name(int i){
494 if(i>tbl_list.size()) return("");
495 else return tbl_list[i]->get_tbl_name();
497 std::vector<std::string> get_table_names();
499 std::vector<field_entry *> get_fields(std::string t);
500 field_entry *get_field(std::string t, int i);
501 field_entry *get_field(int t, std::string f){
502 return tbl_list[t]->get_field(tbl_list[t]->get_field_idx(f));
504 int get_field_idx(std::string t, std::string f);
506 int find_tbl(std::string t);
508 std::vector<int> get_tblref_of_field(std::string f);
510 int get_table_ref(std::string t);
512 std::string get_type_name(int t, std::string f){
513 return(tbl_list[t]->get_type_name(f));
516 param_list *get_modifier_list(int t, std::string f){
517 return(tbl_list[t]->get_modifier_list(f));
520 std::string get_fcn(int t, std::string f){
521 return(tbl_list[t]->get_fcn(f));
524 int get_schema_type(int t){
525 return(tbl_list[t]->get_schema_type());
528 std::string get_op_prop(int t, std::string s){
529 return(tbl_list[t]->get_op_prop(s));
532 std::vector<subquery_spec *> get_subqueryspecs(int t){
533 return tbl_list[t]->get_subqueryspecs();
537 // Used in generating the LFTA prefilter
538 std::string get_basetbl_name(int t, std::string f){
539 return(tbl_list[t]->get_field_basetable(f));
542 bool contains_field(int t, std::string f){
543 return(tbl_list[t]->contains_field(f));
548 // Additional methods
550 // Process field inheritance for PROTOCOL tables.
551 int unroll_tables(std::string &err);
553 std::string to_string();