src/ftacmp/analyze_fta.h

   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
   6
   7      http://www.apache.org/licenses/LICENSE-2.0
   8
   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
  16 #ifndef __ANALYZE_FTA_H_DEFINED__
  17 #define __ANALYZE_FTA_H_DEFINED__
  18
  19
  20
  21 #include "parse_fta.h"
  22 #include "parse_schema.h"
  23 #include"type_objects.h"
  24 #include "parse_ext_fcns.h"
  25 #include "iface_q.h"
  26
  27
  28 #include<set>
  29 #include<algorithm>
  30 using namespace std;
  31
  32
  33 //              Represent a component of a predicate,
  34 //              these components are ANDed together.
  35 //              Often they are simple enough to analyze.
  36 class cnf_elem{
  37 public:
  38         int is_atom;    // i.e., is an atomic predicate
  39         int eq_pred;    // And, it is a test for equality
  40         int in_pred;    // Or, it is a an IN predicate
  41
  42         int pr_gb;              // the predicate refs a gb column.
  43         int pr_attr;    // the predicate refs a table column.
  44         int pr_aggr;    // the predicate refs an aggregate
  45
  46         int l_simple;   // the lhs is simple (just a colref)
  47         int l_gb;               // the lhs refs a gb var
  48         int l_attr;             // the lhs refs a table column
  49         int l_aggr;             // the lhs refs an aggregate.
  50
  51         int r_simple;   // the rhs is simple (just a colref)
  52         int r_gb;               // the rhs refs a gb var
  53         int r_attr;             // the rhs refs a table column
  54         int r_aggr;             // the rhs refs an aggregate.
  55
  56         int cost;               // an estiamte of the evaluation cost.
  57
  58    predicate_t *pr;
  59
  60         cnf_elem(predicate_t *p){
  61                 is_atom = 0;
  62                 eq_pred = 0; in_pred = 0;
  63                 pr_gb = pr_attr = pr_aggr = 0;
  64                 l_simple = l_gb = l_attr = l_aggr = 0;
  65                 r_simple = r_gb = r_attr = r_aggr = 0;
  66                 pr = p;
  67         };
  68
  69         cnf_elem(){ is_atom = 0;
  70                 eq_pred = 0; in_pred = 0;
  71                 pr_gb = pr_attr = pr_aggr = 0;
  72                 l_simple = l_gb = l_attr = l_aggr = 0;
  73                 r_simple = r_gb = r_attr = r_aggr = 0;
  74                 pr = NULL;
  75         };
  76
  77
  78
  79         void swap_scalar_operands(){
  80         int tmp;
  81         if(in_pred) return;     // can't swap IN predicates, se list always on right.
  82         if(! is_atom) return;   // can only swap scalar expressions.
  83
  84         tmp = l_simple; l_simple = r_simple; r_simple = tmp;
  85         tmp = l_gb; l_gb = r_gb; r_gb = tmp;
  86         tmp = l_attr; l_attr = r_attr; r_attr = tmp;
  87         tmp = l_aggr; l_aggr = r_aggr; r_aggr = tmp;
  88
  89         pr->swap_scalar_operands();
  90   }
  91 };
  92
  93 //      Make visible for predicate insertion
  94 void make_cnf_from_pr(predicate_t *pr, std::vector<cnf_elem *> &clist);
  95
  96
  97 //              A GB variable is identified by its name and
  98 //              its source table variable -- so that joins can be expressed.
  99 //              GB Vars defined AS a scalar expression have a null tableref.
 100
 101 struct col_id{
 102   std::string field;
 103   int tblvar_ref;
 104 //              Also carry the schema ref -- used to get data type info
 105 //              when defining variables.
 106   int schema_ref;
 107
 108   col_id(){tblvar_ref = -1;};
 109   col_id(colref_t *cr){
 110           field = cr->field;
 111           tblvar_ref = cr-> get_tablevar_ref();
 112           schema_ref = cr->get_schema_ref();
 113   };
 114
 115
 116
 117   void load_from_colref(colref_t *cr){
 118           field = cr->field;
 119           tblvar_ref = cr-> get_tablevar_ref();
 120           schema_ref = cr->get_schema_ref();
 121   };
 122 };
 123
 124 struct lt_col_id{
 125   bool operator()(const col_id &cr1, const col_id &cr2) const{
 126         if(cr1.tblvar_ref < cr2.tblvar_ref) return(1);
 127         if(cr1.tblvar_ref == cr2.tblvar_ref)
 128            return (cr1.field < cr2.field);
 129         return(0);
 130   }
 131 };
 132
 133   bool operator<(const col_id &cr1, const col_id &cr2);
 134
 135
 136 //              Every GB variable is represented by its name
 137 //              (defined above) and the scalar expression which
 138 //              defines its value.  If the GB var is devlared as a
 139 //              colref, the add_gb_attr method of gb_table will
 140 //              create an SE consisting of the colref.
 141 //                      NOTE : using col_id is dangerous when the
 142 //                                      agregation operator is defiend over a self-join
 143
 144 #define GBVAR_COLREF 1
 145 #define GBVAR_SE 2
 146
 147 struct gb_table_entry{
 148         col_id name;            // tblref in col_id refers to the tablevar.
 149         scalarexp_t *definition;
 150         int ref_type;
 151
 152         gb_table_entry(){
 153                 definition = NULL;
 154         };
 155         data_type *get_data_type(){
 156                 return(definition->get_data_type());
 157         };
 158         void reset_temporal(){
 159                 if(definition) definition->reset_temporal();
 160         }
 161 };
 162
 163
 164 //              The GB table is the symbol table containing
 165 //              the GB vars.  This object puts a wrapper around
 166 //              access to the table.
 167
 168 class gb_table{
 169 private:
 170         std::vector<gb_table_entry *> gtbl;
 171
 172 public:
 173         std::vector<vector<bool> > gb_patterns;
 174 //              rollup, cube, and grouping_sets cannot be readily reconstructed by
 175 //              analyzing the patterns, so explicitly record them here.
 176 //              used only so that sgah_qpn::to_query_string produces
 177 //              something meaningful.
 178         std::vector<std::string> gb_entry_type;
 179         std::vector<int> gb_entry_count;
 180         std::vector<std::vector<std::vector<bool> > > pattern_components;
 181
 182         gb_table(){};
 183
 184         int add_gb_attr(gb_t *c, tablevar_list_t *fm, table_list *schema,
 185                                         table_exp_t *fta_tree, ext_fcn_list *Ext_fcns);
 186
 187         void add_gb_var(std::string n, int t, scalarexp_t *d, int rt){
 188                 gb_table_entry *entry = new gb_table_entry();
 189                 entry->name.field = n;
 190                 entry->name.tblvar_ref = t;
 191                 entry->definition = d;
 192                 entry->ref_type = rt;
 193                 gtbl.push_back(entry);
 194         };
 195         data_type *get_data_type(int g){return(gtbl[g]->get_data_type());       };
 196         int find_gb(colref_t *c, tablevar_list_t *fm, table_list *schema);
 197         scalarexp_t *get_def(int i){return gtbl[i]->definition; };
 198         std::string get_name(int i){return gtbl[i]->name.field; };
 199         int get_tblvar_ref(int i){return gtbl[i]->name.tblvar_ref;      };
 200         int get_reftype(int i){return gtbl[i]->ref_type;        };
 201         int size(){return(gtbl.size()); };
 202         void set_pattern_info(gb_table *g){
 203                 gb_patterns = g->gb_patterns;
 204                 gb_entry_type = g->gb_entry_type;
 205                 gb_entry_count = g->gb_entry_count;
 206                 pattern_components = g->pattern_components;
 207         }
 208         void reset_temporal(int i){
 209                 gtbl[i]->reset_temporal();
 210         }
 211 };
 212
 213
 214
 215 //                      Represent an aggregate to be calculated.
 216 //                      The unique identifier is the aggregate fcn, and the
 217 //                      expression aggregated over.
 218 //                      TODO: unify udaf with built-in better
 219 //                              (but then again, the core dumps help with debugging)
 220
 221 struct aggr_table_entry{
 222         std::string op;
 223         scalarexp_t *operand;
 224         std::vector<scalarexp_t *> oplist;
 225         int fcn_id;             // -1 for built-in aggrs.
 226         data_type *sdt; // storage data type.
 227         data_type *rdt; // return value data type.
 228         bool is_superag;
 229         bool is_running;
 230         bool bailout;
 231
 232         aggr_table_entry(){ sdt = NULL; rdt = NULL; is_superag = false;};
 233         aggr_table_entry(std::string o, scalarexp_t *se, bool s){
 234                 op = o; operand = se; fcn_id = -1; sdt = NULL;
 235                 if(se){
 236                         rdt = new data_type();
 237                         rdt->set_aggr_data_type(o,se->get_data_type());
 238                 }else{
 239                         rdt = new data_type("INT");
 240                 }
 241                 is_superag = s;
 242                 is_running = false;
 243                 bailout = false;
 244         };
 245         aggr_table_entry(std::string o, int f, std::vector<scalarexp_t *> s, data_type *st, bool spr, bool r, bool b_o){
 246                 op = o;
 247                 fcn_id = f;
 248                 operand = NULL;
 249                 oplist = s;
 250                 sdt = st;
 251                 rdt = NULL;
 252                 is_superag = spr;
 253                 is_running = r;
 254                 bailout = b_o;
 255         }
 256
 257         bool fta_legal(ext_fcn_list *Ext_fcns);
 258     bool is_star_aggr(){return operand==NULL;};
 259         bool is_builtin(){return fcn_id < 0;};
 260         int get_fcn_id(){return fcn_id;};
 261         bool is_superaggr(){return is_superag;};
 262         bool is_running_aggr(){return is_running;};
 263         bool has_bailout(){return bailout;};
 264     void set_super(bool s){is_superag = s;};
 265
 266         std::vector<std::string> get_subaggr_fcns(std::vector<bool> &use_se);
 267         std::vector<data_type *> get_subaggr_dt();
 268         scalarexp_t *make_superaggr_se(std::vector<scalarexp_t *> se_refs);
 269         data_type *get_storage_type(){return sdt;};
 270         std::vector<scalarexp_t *> get_operand_list(){return oplist;};
 271
 272         aggr_table_entry *duplicate(){
 273                 aggr_table_entry *dup = new aggr_table_entry();
 274                 dup->op = op;
 275                 dup->operand = operand;
 276                 dup->oplist = oplist;
 277                 dup->fcn_id = fcn_id;
 278                 dup->sdt = sdt;
 279                 dup->rdt = rdt;
 280                 dup->is_superag = is_superag;
 281                 dup->is_running = is_running;
 282                 dup->bailout = bailout;
 283                 return dup;
 284         }
 285
 286         static bool superaggr_allowed(std::string op, ext_fcn_list *Ext_fcns){
 287                 if(op == "SUM" || op == "COUNT" || op == "MIN" || op=="MAX")
 288                         return true;
 289                 return false;
 290         }
 291
 292         bool superaggr_allowed(){
 293                 if(is_builtin())
 294                         return aggr_table_entry::superaggr_allowed(op,NULL);
 295 //              Currently, no UDAFS allowed as superaggregates
 296                 return false;
 297         }
 298
 299         static bool multiple_return_allowed(bool is_built_in, ext_fcn_list *Ext_fcns, int fcn_id){
 300                 if(is_built_in)
 301                         return true;
 302 //                      Currently, no UDAFS allowed as stateful fcn params.
 303 //                      in cleaning_when, cleaning_by clauses.
 304                 if(Ext_fcns->is_running_aggr(fcn_id) || Ext_fcns->multiple_returns(fcn_id))
 305                         return true;
 306                 return false;
 307         }
 308
 309 };
 310
 311
 312 class aggregate_table{
 313 public:
 314         std::vector<aggr_table_entry *> agr_tbl;
 315
 316         aggregate_table(){};
 317
 318         int add_aggr(std::string op, scalarexp_t *se, bool is_spr);
 319         int add_aggr(std::string op, int fcn_id, std::vector<scalarexp_t *> opl, data_type *sdt, bool is_spr, bool is_running, bool has_lfta_bailout);
 320         int add_aggr(aggr_table_entry *a){agr_tbl.push_back(a); return agr_tbl.size(); };
 321         int size(){return(agr_tbl.size());      };
 322         scalarexp_t *get_aggr_se(int i){return agr_tbl[i]->operand;     };
 323
 324         data_type *get_data_type(int i){
 325 //              if(agr_tbl[i]->op == "COUNT")
 326 //                       return new data_type("uint");
 327 //              else
 328                         if(! agr_tbl[i]->rdt){
 329                                 fprintf(stderr,"INTERNAL ERROR in aggregate_table::get_data_type : rdt is NULL.\n");
 330                                 exit(1);
 331                         }
 332                         return agr_tbl[i]->rdt;
 333         };
 334
 335         std::string get_op(int i){return agr_tbl[i]->op;};
 336
 337         bool fta_legal(int i,ext_fcn_list *Ext_fcns){return agr_tbl[i]->fta_legal(Ext_fcns);    };
 338     bool is_star_aggr(int i){return agr_tbl[i]->is_star_aggr(); };
 339         bool is_builtin(int i){return agr_tbl[i]->is_builtin(); };
 340         int get_fcn_id(int i){return agr_tbl[i]->get_fcn_id();};
 341         bool is_superaggr(int i){return agr_tbl[i]->is_superaggr();};
 342         bool is_running_aggr(int i){return agr_tbl[i]->is_running_aggr();};
 343         bool has_bailout(int i){return agr_tbl[i]->has_bailout();};
 344 //      bool multiple_return_allowed(int i){
 345 //              return agr_tbl[i]->multiple_return_allowed(agr_tbl[i]->is_builtin(),NULL);
 346 //      };
 347         bool superaggr_allowed(int i){return agr_tbl[i]->superaggr_allowed();};
 348         std::vector<scalarexp_t *> get_operand_list(int i){
 349                 return agr_tbl[i]->get_operand_list();
 350         }
 351
 352         std::vector<std::string> get_subaggr_fcns(int i, std::vector<bool> &use_se){
 353                 return(agr_tbl[i]->get_subaggr_fcns(use_se) );
 354         };
 355
 356         std::vector<data_type *> get_subaggr_dt(int i){
 357                 return(agr_tbl[i]->get_subaggr_dt() );
 358         }
 359         data_type *get_storage_type(int i){
 360                 return( agr_tbl[i]->get_storage_type());
 361         }
 362
 363         aggr_table_entry *duplicate(int i){
 364                 return agr_tbl[i]->duplicate();
 365         };
 366
 367         scalarexp_t *make_superaggr_se(int i, std::vector<scalarexp_t *> se_refs){
 368                 return(agr_tbl[i]->make_superaggr_se(se_refs) );
 369         };
 370 };
 371
 372
 373 class cplx_lit_table{
 374         std::vector<literal_t *> cplx_lit_tbl;
 375         std::vector<bool> hdl_ref_tbl;
 376
 377 public:
 378         cplx_lit_table(){};
 379
 380         int add_cpx_lit(literal_t *, bool);
 381         int size(){return cplx_lit_tbl.size();};
 382         literal_t *get_literal(int i){return cplx_lit_tbl[i];};
 383         bool is_handle_ref(int i){return hdl_ref_tbl[i];};
 384
 385 };
 386
 387 enum param_handle_type { cplx_lit_e, litval_e, param_e};
 388
 389 class handle_param_tbl_entry{
 390 private:
 391
 392 public:
 393         std::string fcn_name;
 394         int param_slot;
 395         literal_t *litval;
 396         int complex_literal_idx;
 397         std::string param_name;
 398         param_handle_type val_type;
 399     std::string type_name;
 400
 401         handle_param_tbl_entry(std::string fname, int slot,
 402                                                         literal_t *l, std::string tnm){
 403                 fcn_name = fname; param_slot = slot;
 404                 val_type = litval_e;
 405                 litval = l;
 406                 type_name = tnm;
 407         };
 408         handle_param_tbl_entry(std::string fname, int slot, std::string p, std::string tnm){
 409                 fcn_name = fname; param_slot = slot;
 410                 val_type = param_e;
 411                 param_name = p;
 412                 type_name = tnm;
 413         };
 414         handle_param_tbl_entry(std::string fname, int slot, int ci, std::string tnm){
 415                 fcn_name = fname; param_slot = slot;
 416                 val_type = cplx_lit_e;
 417                 complex_literal_idx = ci;
 418                 type_name = tnm;
 419         };
 420
 421         std::string lfta_registration_fcn(){
 422                 char tmps[500];
 423                 sprintf(tmps,"register_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);
 424                 return(tmps);
 425         };
 426         std::string hfta_registration_fcn(){return lfta_registration_fcn();};
 427
 428         std::string lfta_deregistration_fcn(){
 429                 char tmps[500];
 430                 sprintf(tmps,"deregister_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);
 431                 return(tmps);
 432         };
 433         std::string hfta_rdeegistration_fcn(){return lfta_registration_fcn();};
 434
 435 };
 436
 437
 438 class param_table{
 439 //                      Store the data in vectors to preserve
 440 //                      listing order.
 441         std::vector<std::string> pname;
 442         std::vector<data_type *> pdtype;
 443         std::vector<bool> phandle;
 444
 445         int find_name(std::string n){
 446                 int p;
 447                 for(p=0;p<pname.size();++p){
 448                         if(pname[p] == n) break;
 449                 }
 450                 if(p == pname.size()) return(-1);
 451                 return(p);
 452         };
 453
 454 public:
 455         param_table(){};
 456
 457 //                      Add the param with the given name and associated
 458 //                      data type and handle use.
 459 //                      if its a new name, return true.
 460 //                      Else, take OR of use_handle, return false.
 461 //                      (builds param table and collects handle references).
 462         bool add_param(std::string pnm, data_type *pdt, bool use_handle){
 463                 int p = find_name(pnm);
 464                 if(p == -1){
 465                         pname.push_back(pnm);
 466                         pdtype.push_back(pdt);
 467                         phandle.push_back(use_handle);
 468                         return(true);
 469         }else{
 470                         if(use_handle) phandle[p] = use_handle;
 471                         return(false);
 472                 }
 473
 474         };
 475
 476         int size(){return pname.size(); };
 477
 478         std::vector<std::string> get_param_names(){
 479                 return(pname);
 480         };
 481
 482         data_type *get_data_type(std::string pnm){
 483                 int p = find_name(pnm);
 484                 if(p >= 0){
 485                         return(pdtype[p]);
 486                 }
 487                 return(new data_type("undefined_type"));
 488         };
 489
 490         bool handle_access(std::string pnm){
 491                 int p = find_name(pnm);
 492                 if(p >= 0){
 493                         return(phandle[p]);
 494                 }
 495                 return(false);
 496         };
 497
 498 };
 499
 500
 501 //                      Two columns are the same if they come from the
 502 //                      same source, and have the same field name.
 503 //                      (use to determine which fields must be unpacked).
 504 //                      NOTE : dangerous in the presence of self-joins.
 505 typedef std::set<col_id, lt_col_id> col_id_set;
 506
 507 bool contains_gb_pr(predicate_t *pr, std::set<int> &gref_set);
 508 bool contains_gb_se(scalarexp_t *se, std::set<int> &gref_set);
 509
 510
 511 void gather_se_col_ids(scalarexp_t *se, col_id_set &cid_set,  gb_table *gtbl);
 512 void gather_pr_col_ids(predicate_t *pr, col_id_set &cid_set, gb_table *gtbl);
 513
 514 void gather_se_opcmp_fcns(scalarexp_t *se, std::set<std::string> &fcn_set);
 515 void gather_pr_opcmp_fcns(predicate_t *pr, std::set<std::string> &fcn_set);
 516
 517 ////////////////////////////////////////////
 518 //              Structures to record usage of operator views.
 519
 520 class opview_entry{
 521 public:
 522         std::string parent_qname;
 523         std::string root_name;
 524         std::string view_name;
 525         std::string exec_fl;            // name of executable file (if any)
 526         std::string udop_alias;         // unique ID of the UDOP
 527         std::string mangler;
 528         int liveness_timeout;           // maximum delay between hearbeats from udop
 529         int pos;
 530         std::vector<std::string> subq_names;
 531
 532         opview_entry(){mangler="";};
 533 };
 534
 535 class opview_set{
 536 public:
 537         std::vector<opview_entry *> opview_list;
 538
 539         int append(opview_entry *opv){opview_list.push_back(opv);
 540                                                                   return opview_list.size()-1;};
 541         int size(){return opview_list.size();};
 542         opview_entry *get_entry(int i){ return opview_list[i];};
 543 };
 544
 545 /////////////////////////////////////////////////////////////////
 546 //              Wrap up all of the analysis of the FTA into this package.
 547 //
 548 //              There is some duplication between query_summary_class,
 549 //              but I'd rather avoid pushing analysis structures
 550 //              into the parse modules.
 551 //
 552 //              TODO: revisit the issue when nested subqueries are implemented.
 553 //              One possibility: implement accessor methods to hide the
 554 //              complexity
 555 //              For now: this class contains data structures not in table_exp_t
 556 //              (with a bit of duplication)
 557
 558 struct query_summary_class{
 559         std::string query_name;                 // the name of the query, becomes the name
 560                                                                         // of the output.
 561         int query_type;         // e.g. SELECT, MERGE, etc.
 562
 563         gb_table *gb_tbl;                       // Table of all group-by attributes.
 564         std::set<int> sg_tbl;           // Names of the superGB attributes
 565         aggregate_table *aggr_tbl;      // Table of all referenced aggregates.
 566         std::set<std::string> states_refd;      // states ref'd by stateful fcns.
 567
 568
 569 //              copied from parse tree, then into query node.
 570 //              interpret the string representation of data type into a type_object
 571         param_table *param_tbl;         // Table of all query parameters.
 572
 573 //              There is stuff that is not copied over by analyze_fta,
 574 //              it still resides in fta_tree.
 575     table_exp_t *fta_tree;              // The (decorated) parse tree.
 576
 577
 578 //              This is copied from the parse tree (except for "query_name")
 579 //              then copied to the query node in query_plan.cc:145
 580         std::map<std::string, std::string> definitions; // additional definitions.
 581
 582
 583 //              CNF representation of the where and having predicates.
 584         std::vector<cnf_elem *> wh_cnf;
 585         std::vector<cnf_elem *> hav_cnf;
 586         std::vector<cnf_elem *> cb_cnf;
 587         std::vector<cnf_elem *> cw_cnf;
 588         std::vector<cnf_elem *> closew_cnf;
 589
 590
 591
 592
 593 //              For MERGE type queries.
 594         std::vector<colref_t *> mvars;
 595         scalarexp_t *slack;
 596
 597 ////////                        Constructors
 598         query_summary_class(){
 599                 init();
 600         }
 601
 602         query_summary_class(table_exp_t *f){
 603                 fta_tree = f;
 604                 init();
 605         }
 606
 607 /////                   Methods
 608
 609         bool add_query_param(std::string pnm, data_type *pdt, bool use_handle){
 610                 return( param_tbl->add_param(pnm,pdt,use_handle));
 611         };
 612
 613
 614 private:
 615         void init(){
 616 //              Create the gb_tbl, aggr_tbl, and param_tbl objects
 617                 gb_tbl = new gb_table();
 618                 aggr_tbl = new aggregate_table();
 619                 param_tbl = new param_table();
 620
 621         }
 622 };
 623
 624 int verify_colref(scalarexp_t *se, tablevar_list_t *fm,
 625                                         table_list *schema, gb_table *gtbl);
 626 std::string impute_query_name(table_exp_t *fta_tree, std::string default_nm);
 627
 628 query_summary_class *analyze_fta(table_exp_t *fta_tree, table_list *schema, ext_fcn_list *Ext_fcns, std::string qname);
 629 bool is_equivalent_se(scalarexp_t *se1, scalarexp_t *se2);
 630 bool is_equivalent_se_base(scalarexp_t *se1, scalarexp_t *se2, table_list *Schema);
 631 bool is_equivalent_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema);
 632
 633 bool is_equivalent_class_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema,ext_fcn_list *Ext_fcns);
 634 void analyze_cnf(cnf_elem *c);
 635
 636 void find_partial_fcns(scalarexp_t *se, std::vector<scalarexp_t *> *pf_list, std::vector<int> *fcn_ref_cnt, std::vector<bool> *is_partial_fcn, ext_fcn_list *Ext_fcns);
 637 void find_partial_fcns_pr(predicate_t *pr, std::vector<scalarexp_t *> *pf_list,std::vector<int> *fcn_ref_cnt, std::vector<bool> *is_partial_fcn, ext_fcn_list *Ext_fcns);
 638 void collect_partial_fcns(scalarexp_t *se, std::set<int> &pfcn_refs);
 639 void collect_partial_fcns_pr(predicate_t *pr,  std::set<int> &pfcn_refs);
 640
 641 void find_combinable_preds(predicate_t *pr,  vector<predicate_t *> *pr_list,
 642                                                                 table_list *Schema, ext_fcn_list *Ext_fcns);
 643
 644 void collect_agg_refs(scalarexp_t *se, std::set<int> &agg_refs);
 645 void collect_aggr_refs_pr(predicate_t *pr,  std::set<int> &agg_refs);
 646
 647 int bind_to_schema_pr(predicate_t *pr, tablevar_list_t *fm, table_list *schema);
 648 int bind_to_schema_se(scalarexp_t *se, tablevar_list_t *fm, table_list *schema);
 649
 650 temporal_type compute_se_temporal(scalarexp_t *se, std::map<col_id, temporal_type> &tcol);
 651
 652
 653 bool find_complex_literal_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,
 654                                                                 cplx_lit_table *complex_literals);
 655 void find_complex_literal_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,
 656                                                                 cplx_lit_table *complex_literals);
 657 void find_param_handles_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,
 658                                                 std::vector<handle_param_tbl_entry *> &handle_tbl);
 659 void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,
 660                                                 std::vector<handle_param_tbl_entry *> &handle_tbl);
 661
 662 //              Copy a scalar expression / predicate tree
 663 scalarexp_t *dup_se(scalarexp_t *se, aggregate_table *aggr_tbl);
 664 select_element *dup_select(select_element *sl, aggregate_table *aggr_tbl);
 665 predicate_t *dup_pr(predicate_t *pr, aggregate_table *aggr_tbl);
 666
 667 //              Expand gbvars
 668 void expand_gbvars_pr(predicate_t *pr, gb_table &gb_tbl);
 669 scalarexp_t *expand_gbvars_se(scalarexp_t *se, gb_table &gb_tbl);
 670
 671
 672 //              copy a query
 673 table_exp_t *dup_table_exp(table_exp_t *te);
 674
 675
 676 //              Tie colrefs to a new range var
 677 void bind_colref_se(scalarexp_t *se,
 678                                   std::vector<tablevar_t *> &fm,
 679                                   int prev_ref, int new_ref
 680                                  );
 681 void bind_colref_pr(predicate_t *pr,
 682                                   std::vector<tablevar_t *> &fm,
 683                                   int prev_ref, int new_ref
 684                                  );
 685
 686
 687 std::string impute_colname(std::vector<select_element *> &sel_list, scalarexp_t *se);
 688 std::string impute_colname(std::set<std::string> &curr_names, scalarexp_t *se);
 689
 690 bool is_literal_or_param_only(scalarexp_t *se);
 691
 692
 693 void build_aggr_tbl_fm_pred(predicate_t *pr, aggregate_table *agr_tbl);
 694 void build_aggr_tbl_fm_se(scalarexp_t *se, aggregate_table *agr_tbl);
 695
 696 void compute_cnf_cost(cnf_elem *cm, ext_fcn_list *Ext_fcns);
 697 struct compare_cnf_cost{
 698   bool operator()(const cnf_elem *c1, const cnf_elem *c2) const{
 699         if(c1->cost < c2->cost) return(true);
 700         return(false);
 701   }
 702 };
 703
 704 void get_tablevar_ref_se(scalarexp_t *se, std::vector<int> &reflist);
 705 void get_tablevar_ref_pr(predicate_t *pr, std::vector<int> &reflist);
 706
 707 long long int find_temporal_divisor(scalarexp_t *se, gb_table *gbt, std::string &fnm);
 708
 709
 710 int count_se_ifp_refs(scalarexp_t *se, std::set<std::string> &ifpnames);
 711 int count_pr_ifp_refs(predicate_t *pr, std::set<std::string> &ifpnames);
 712 int resolve_se_ifp_refs(scalarexp_t *se, std::string ifm, std::string ifn, ifq_t *ifdb,  std::string &err);
 713 int resolve_pr_ifp_refs(predicate_t *pr, std::string ifm, std::string ifn, ifq_t *ifdb,  std::string &err);
 714
 715 int pred_refs_sfun(predicate_t *pr);
 716 int se_refs_sfun(scalarexp_t *se);
 717
 718
 719 //              Represent preds for the prefilter, and
 720 //              the LFTAs which reference them.
 721 struct cnf_set{
 722         predicate_t *pr;
 723         std::set<int> lfta_id;
 724         std::set<unsigned int> pred_id;
 725
 726         cnf_set(){};
 727         cnf_set(predicate_t *p, unsigned int l, unsigned int i){
 728                 pr = dup_pr(p,NULL);            // NEED TO UPDATE dup_se TO PROPAGATE
 729                 lfta_id.insert(l);
 730                 pred_id.insert((l << 16)+i);
 731         }
 732         void subsume(cnf_set *c){
 733                 std::set<int>::iterator ssi;
 734                 for(ssi=c->lfta_id.begin();ssi!=c->lfta_id.end();++ssi){
 735                         lfta_id.insert((*ssi));
 736                 }
 737                 std::set<unsigned int >::iterator spi;
 738                 for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){
 739                         pred_id.insert((*spi));
 740                 }
 741         }
 742         void combine_pred(cnf_set *c){
 743                 pr = new predicate_t("AND",pr,c->pr);
 744                 std::set<unsigned int >::iterator spi;
 745                 for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){
 746                         pred_id.insert((*spi));
 747                 }
 748         }
 749
 750         void add_pred_ids(set<unsigned int> &pred_set){
 751                 std::set<unsigned int >::iterator spi;
 752                 for(spi=pred_id.begin();spi!=pred_id.end();++spi){
 753                         pred_set.insert((*spi));
 754                 }
 755         }
 756
 757         static unsigned int make_lfta_key(unsigned int l){
 758                 return l << 16;
 759         }
 760
 761
 762         ~cnf_set(){};
 763 };
 764 struct compare_cnf_set{
 765   bool operator()(const cnf_set *c1, const cnf_set *c2) const{
 766         if(c1->lfta_id.size() > c2->lfta_id.size()) return(true);
 767         return(false);
 768   }
 769 };
 770
 771 bool operator<(const cnf_set &c1, const cnf_set &c2);
 772
 773
 774 void find_common_filter(std::vector< std::vector<cnf_elem *> > &where_list, table_list *Schema, ext_fcn_list *Ext_fcns, std::vector<cnf_set *> &prefilter_preds, std::set<unsigned int> &pred_ids);
 775
 776
 777 cnf_elem *find_common_filter(std::vector< std::vector<cnf_elem *> > &where_list, table_list *Schema);
 778
 779 std::string int_to_string(int i);
 780 void insert_gb_def_pr(predicate_t *pr, gb_table *gtbl);
 781 void insert_gb_def_se(scalarexp_t *se, gb_table *gtbl);
 782
 783
 784
 785
 786 #endif
 787