-/* ------------------------------------------------\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
-\r
-#ifndef __ANALYZE_FTA_H_DEFINED__\r
-#define __ANALYZE_FTA_H_DEFINED__\r
-\r
-\r
-\r
-#include "parse_fta.h"\r
-#include "parse_schema.h"\r
-#include"type_objects.h"\r
-#include "parse_ext_fcns.h"\r
-#include "iface_q.h"\r
-\r
-\r
-#include<set>\r
-#include<algorithm>\r
-using namespace std;\r
-\r
-\r
-// Represent a component of a predicate,\r
-// these components are ANDed together.\r
-// Often they are simple enough to analyze.\r
-class cnf_elem{\r
-public:\r
- int is_atom; // i.e., is an atomic predicate\r
- int eq_pred; // And, it is a test for equality\r
- int in_pred; // Or, it is a an IN predicate\r
-\r
- int pr_gb; // the predicate refs a gb column.\r
- int pr_attr; // the predicate refs a table column.\r
- int pr_aggr; // the predicate refs an aggregate\r
-\r
- int l_simple; // the lhs is simple (just a colref)\r
- int l_gb; // the lhs refs a gb var\r
- int l_attr; // the lhs refs a table column\r
- int l_aggr; // the lhs refs an aggregate.\r
-\r
- int r_simple; // the rhs is simple (just a colref)\r
- int r_gb; // the rhs refs a gb var\r
- int r_attr; // the rhs refs a table column\r
- int r_aggr; // the rhs refs an aggregate.\r
-\r
- int cost; // an estiamte of the evaluation cost.\r
-\r
- predicate_t *pr;\r
-\r
- cnf_elem(predicate_t *p){\r
- is_atom = 0;\r
- eq_pred = 0; in_pred = 0;\r
- pr_gb = pr_attr = pr_aggr = 0;\r
- l_simple = l_gb = l_attr = l_aggr = 0;\r
- r_simple = r_gb = r_attr = r_aggr = 0;\r
- pr = p;\r
- };\r
-\r
- cnf_elem(){ is_atom = 0;\r
- eq_pred = 0; in_pred = 0;\r
- pr_gb = pr_attr = pr_aggr = 0;\r
- l_simple = l_gb = l_attr = l_aggr = 0;\r
- r_simple = r_gb = r_attr = r_aggr = 0;\r
- pr = NULL;\r
- };\r
-\r
-\r
-\r
- void swap_scalar_operands(){\r
- int tmp;\r
- if(in_pred) return; // can't swap IN predicates, se list always on right.\r
- if(! is_atom) return; // can only swap scalar expressions.\r
-\r
- tmp = l_simple; l_simple = r_simple; r_simple = tmp;\r
- tmp = l_gb; l_gb = r_gb; r_gb = tmp;\r
- tmp = l_attr; l_attr = r_attr; r_attr = tmp;\r
- tmp = l_aggr; l_aggr = r_aggr; r_aggr = tmp;\r
-\r
- pr->swap_scalar_operands();\r
- }\r
-};\r
-\r
-\r
-// A GB variable is identified by its name and\r
-// its source table variable -- so that joins can be expressed.\r
-// GB Vars defined AS a scalar expression have a null tableref.\r
-\r
-struct col_id{\r
- std::string field;\r
- int tblvar_ref;\r
-// Also carry the schema ref -- used to get data type info\r
-// when defining variables.\r
- int schema_ref;\r
-\r
- col_id(){tblvar_ref = -1;};\r
- col_id(colref_t *cr){\r
- field = cr->field;\r
- tblvar_ref = cr-> get_tablevar_ref();\r
- schema_ref = cr->get_schema_ref();\r
- };\r
-\r
-\r
-\r
- void load_from_colref(colref_t *cr){\r
- field = cr->field;\r
- tblvar_ref = cr-> get_tablevar_ref();\r
- schema_ref = cr->get_schema_ref();\r
- };\r
-};\r
-\r
-struct lt_col_id{\r
- bool operator()(const col_id &cr1, const col_id &cr2) const{\r
- if(cr1.tblvar_ref < cr2.tblvar_ref) return(1);\r
- if(cr1.tblvar_ref == cr2.tblvar_ref)\r
- return (cr1.field < cr2.field);\r
- return(0);\r
- }\r
-};\r
-\r
- bool operator<(const col_id &cr1, const col_id &cr2);\r
-\r
-\r
-// Every GB variable is represented by its name\r
-// (defined above) and the scalar expression which\r
-// defines its value. If the GB var is devlared as a\r
-// colref, the add_gb_attr method of gb_table will\r
-// create an SE consisting of the colref.\r
-// NOTE : using col_id is dangerous when the\r
-// agregation operator is defiend over a self-join\r
-\r
-#define GBVAR_COLREF 1\r
-#define GBVAR_SE 2\r
-\r
-struct gb_table_entry{\r
- col_id name; // tblref in col_id refers to the tablevar.\r
- scalarexp_t *definition;\r
- int ref_type;\r
-\r
- gb_table_entry(){\r
- definition = NULL;\r
- };\r
- data_type *get_data_type(){\r
- return(definition->get_data_type());\r
- };\r
- void reset_temporal(){\r
- if(definition) definition->reset_temporal();\r
- }\r
-};\r
-\r
-\r
-// The GB table is the symbol table containing\r
-// the GB vars. This object puts a wrapper around\r
-// access to the table.\r
-\r
-class gb_table{\r
-private:\r
- std::vector<gb_table_entry *> gtbl;\r
-\r
-public:\r
- std::vector<vector<bool> > gb_patterns;\r
-// rollup, cube, and grouping_sets cannot be readily reconstructed by\r
-// analyzing the patterns, so explicitly record them here.\r
-// used only so that sgah_qpn::to_query_string produces \r
-// something meaningful.\r
- std::vector<std::string> gb_entry_type;\r
- std::vector<int> gb_entry_count;\r
- std::vector<std::vector<std::vector<bool> > > pattern_components;\r
-\r
- gb_table(){};\r
-\r
- int add_gb_attr(gb_t *c, tablevar_list_t *fm, table_list *schema,\r
- table_exp_t *fta_tree, ext_fcn_list *Ext_fcns);\r
-\r
- void add_gb_var(std::string n, int t, scalarexp_t *d, int rt){\r
- gb_table_entry *entry = new gb_table_entry();\r
- entry->name.field = n;\r
- entry->name.tblvar_ref = t;\r
- entry->definition = d;\r
- entry->ref_type = rt;\r
- gtbl.push_back(entry);\r
- };\r
- data_type *get_data_type(int g){return(gtbl[g]->get_data_type()); };\r
- int find_gb(colref_t *c, tablevar_list_t *fm, table_list *schema);\r
- scalarexp_t *get_def(int i){return gtbl[i]->definition; };\r
- std::string get_name(int i){return gtbl[i]->name.field; };\r
- int get_tblvar_ref(int i){return gtbl[i]->name.tblvar_ref; };\r
- int get_reftype(int i){return gtbl[i]->ref_type; };\r
- int size(){return(gtbl.size()); };\r
- void set_pattern_info(gb_table *g){\r
- gb_patterns = g->gb_patterns;\r
- gb_entry_type = g->gb_entry_type;\r
- gb_entry_count = g->gb_entry_count;\r
- pattern_components = g->pattern_components;\r
- }\r
- void reset_temporal(int i){\r
- gtbl[i]->reset_temporal();\r
- }\r
-};\r
-\r
-\r
-\r
-// Represent an aggregate to be calculated.\r
-// The unique identifier is the aggregate fcn, and the\r
-// expression aggregated over.\r
-// TODO: unify udaf with built-in better\r
-// (but then again, the core dumps help with debugging)\r
-\r
-struct aggr_table_entry{\r
- std::string op;\r
- scalarexp_t *operand;\r
- std::vector<scalarexp_t *> oplist;\r
- int fcn_id; // -1 for built-in aggrs.\r
- data_type *sdt; // storage data type.\r
- data_type *rdt; // return value data type.\r
- bool is_superag;\r
- bool is_running;\r
- bool bailout;\r
-\r
- aggr_table_entry(){ sdt = NULL; rdt = NULL; is_superag = false;};\r
- aggr_table_entry(std::string o, scalarexp_t *se, bool s){\r
- op = o; operand = se; fcn_id = -1; sdt = NULL;\r
- if(se){\r
- rdt = new data_type();\r
- rdt->set_aggr_data_type(o,se->get_data_type());\r
- }else{\r
- rdt = new data_type("INT");\r
- }\r
- is_superag = s;\r
- is_running = false;\r
- bailout = false;\r
- };\r
- aggr_table_entry(std::string o, int f, std::vector<scalarexp_t *> s, data_type *st, bool spr, bool r, bool b_o){\r
- op = o;\r
- fcn_id = f;\r
- operand = NULL;\r
- oplist = s;\r
- sdt = st;\r
- rdt = NULL;\r
- is_superag = spr;\r
- is_running = r;\r
- bailout = b_o;\r
- }\r
-\r
- bool fta_legal(ext_fcn_list *Ext_fcns);\r
- bool is_star_aggr(){return operand==NULL;};\r
- bool is_builtin(){return fcn_id < 0;};\r
- int get_fcn_id(){return fcn_id;};\r
- bool is_superaggr(){return is_superag;};\r
- bool is_running_aggr(){return is_running;};\r
- bool has_bailout(){return bailout;};\r
- void set_super(bool s){is_superag = s;};\r
-\r
- std::vector<std::string> get_subaggr_fcns(std::vector<bool> &use_se);\r
- std::vector<data_type *> get_subaggr_dt();\r
- scalarexp_t *make_superaggr_se(std::vector<scalarexp_t *> se_refs);\r
- data_type *get_storage_type(){return sdt;};\r
- std::vector<scalarexp_t *> get_operand_list(){return oplist;};\r
-\r
- aggr_table_entry *duplicate(){\r
- aggr_table_entry *dup = new aggr_table_entry();\r
- dup->op = op;\r
- dup->operand = operand;\r
- dup->oplist = oplist;\r
- dup->fcn_id = fcn_id;\r
- dup->sdt = sdt;\r
- dup->rdt = rdt;\r
- dup->is_superag = is_superag;\r
- dup->is_running = is_running;\r
- dup->bailout = bailout;\r
- return dup;\r
- }\r
-\r
- static bool superaggr_allowed(std::string op, ext_fcn_list *Ext_fcns){\r
- if(op == "SUM" || op == "COUNT" || op == "MIN" || op=="MAX")\r
- return true;\r
- return false;\r
- }\r
-\r
- bool superaggr_allowed(){\r
- if(is_builtin())\r
- return aggr_table_entry::superaggr_allowed(op,NULL);\r
-// Currently, no UDAFS allowed as superaggregates\r
- return false;\r
- }\r
-\r
- static bool multiple_return_allowed(bool is_built_in, ext_fcn_list *Ext_fcns, int fcn_id){\r
- if(is_built_in)\r
- return true;\r
-// Currently, no UDAFS allowed as stateful fcn params.\r
-// in cleaning_when, cleaning_by clauses.\r
- if(Ext_fcns->is_running_aggr(fcn_id) || Ext_fcns->multiple_returns(fcn_id))\r
- return true;\r
- return false;\r
- }\r
-\r
-};\r
-\r
-\r
-class aggregate_table{\r
-public:\r
- std::vector<aggr_table_entry *> agr_tbl;\r
-\r
- aggregate_table(){};\r
-\r
- int add_aggr(std::string op, scalarexp_t *se, bool is_spr);\r
- 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);\r
- int add_aggr(aggr_table_entry *a){agr_tbl.push_back(a); return agr_tbl.size(); };\r
- int size(){return(agr_tbl.size()); };\r
- scalarexp_t *get_aggr_se(int i){return agr_tbl[i]->operand; };\r
-\r
- data_type *get_data_type(int i){\r
-// if(agr_tbl[i]->op == "COUNT")\r
-// return new data_type("uint");\r
-// else\r
- if(! agr_tbl[i]->rdt){\r
- fprintf(stderr,"INTERNAL ERROR in aggregate_table::get_data_type : rdt is NULL.\n");\r
- exit(1);\r
- }\r
- return agr_tbl[i]->rdt;\r
- };\r
-\r
- std::string get_op(int i){return agr_tbl[i]->op;};\r
-\r
- bool fta_legal(int i,ext_fcn_list *Ext_fcns){return agr_tbl[i]->fta_legal(Ext_fcns); };\r
- bool is_star_aggr(int i){return agr_tbl[i]->is_star_aggr(); };\r
- bool is_builtin(int i){return agr_tbl[i]->is_builtin(); };\r
- int get_fcn_id(int i){return agr_tbl[i]->get_fcn_id();};\r
- bool is_superaggr(int i){return agr_tbl[i]->is_superaggr();};\r
- bool is_running_aggr(int i){return agr_tbl[i]->is_running_aggr();};\r
- bool has_bailout(int i){return agr_tbl[i]->has_bailout();};\r
-// bool multiple_return_allowed(int i){\r
-// return agr_tbl[i]->multiple_return_allowed(agr_tbl[i]->is_builtin(),NULL);\r
-// };\r
- bool superaggr_allowed(int i){return agr_tbl[i]->superaggr_allowed();};\r
- std::vector<scalarexp_t *> get_operand_list(int i){\r
- return agr_tbl[i]->get_operand_list();\r
- }\r
-\r
- std::vector<std::string> get_subaggr_fcns(int i, std::vector<bool> &use_se){\r
- return(agr_tbl[i]->get_subaggr_fcns(use_se) );\r
- };\r
-\r
- std::vector<data_type *> get_subaggr_dt(int i){\r
- return(agr_tbl[i]->get_subaggr_dt() );\r
- }\r
- data_type *get_storage_type(int i){\r
- return( agr_tbl[i]->get_storage_type());\r
- }\r
-\r
- aggr_table_entry *duplicate(int i){\r
- return agr_tbl[i]->duplicate();\r
- };\r
-\r
- scalarexp_t *make_superaggr_se(int i, std::vector<scalarexp_t *> se_refs){\r
- return(agr_tbl[i]->make_superaggr_se(se_refs) );\r
- };\r
-};\r
-\r
-\r
-class cplx_lit_table{\r
- std::vector<literal_t *> cplx_lit_tbl;\r
- std::vector<bool> hdl_ref_tbl;\r
-\r
-public:\r
- cplx_lit_table(){};\r
-\r
- int add_cpx_lit(literal_t *, bool);\r
- int size(){return cplx_lit_tbl.size();};\r
- literal_t *get_literal(int i){return cplx_lit_tbl[i];};\r
- bool is_handle_ref(int i){return hdl_ref_tbl[i];};\r
-\r
-};\r
-\r
-enum param_handle_type { cplx_lit_e, litval_e, param_e};\r
-\r
-class handle_param_tbl_entry{\r
-private:\r
-\r
-public:\r
- std::string fcn_name;\r
- int param_slot;\r
- literal_t *litval;\r
- int complex_literal_idx;\r
- std::string param_name;\r
- param_handle_type val_type;\r
- std::string type_name;\r
-\r
- handle_param_tbl_entry(std::string fname, int slot,\r
- literal_t *l, std::string tnm){\r
- fcn_name = fname; param_slot = slot;\r
- val_type = litval_e;\r
- litval = l;\r
- type_name = tnm;\r
- };\r
- handle_param_tbl_entry(std::string fname, int slot, std::string p, std::string tnm){\r
- fcn_name = fname; param_slot = slot;\r
- val_type = param_e;\r
- param_name = p;\r
- type_name = tnm;\r
- };\r
- handle_param_tbl_entry(std::string fname, int slot, int ci, std::string tnm){\r
- fcn_name = fname; param_slot = slot;\r
- val_type = cplx_lit_e;\r
- complex_literal_idx = ci;\r
- type_name = tnm;\r
- };\r
-\r
- std::string lfta_registration_fcn(){\r
- char tmps[500];\r
- sprintf(tmps,"register_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);\r
- return(tmps);\r
- };\r
- std::string hfta_registration_fcn(){return lfta_registration_fcn();};\r
-\r
- std::string lfta_deregistration_fcn(){\r
- char tmps[500];\r
- sprintf(tmps,"deregister_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);\r
- return(tmps);\r
- };\r
- std::string hfta_rdeegistration_fcn(){return lfta_registration_fcn();};\r
-\r
-};\r
-\r
-\r
-class param_table{\r
-// Store the data in vectors to preserve\r
-// listing order.\r
- std::vector<std::string> pname;\r
- std::vector<data_type *> pdtype;\r
- std::vector<bool> phandle;\r
-\r
- int find_name(std::string n){\r
- int p;\r
- for(p=0;p<pname.size();++p){\r
- if(pname[p] == n) break;\r
- }\r
- if(p == pname.size()) return(-1);\r
- return(p);\r
- };\r
-\r
-public:\r
- param_table(){};\r
-\r
-// Add the param with the given name and associated\r
-// data type and handle use.\r
-// if its a new name, return true.\r
-// Else, take OR of use_handle, return false.\r
-// (builds param table and collects handle references).\r
- bool add_param(std::string pnm, data_type *pdt, bool use_handle){\r
- int p = find_name(pnm);\r
- if(p == -1){\r
- pname.push_back(pnm);\r
- pdtype.push_back(pdt);\r
- phandle.push_back(use_handle);\r
- return(true);\r
- }else{\r
- if(use_handle) phandle[p] = use_handle;\r
- return(false);\r
- }\r
-\r
- };\r
-\r
- int size(){return pname.size(); };\r
-\r
- std::vector<std::string> get_param_names(){\r
- return(pname);\r
- };\r
-\r
- data_type *get_data_type(std::string pnm){\r
- int p = find_name(pnm);\r
- if(p >= 0){\r
- return(pdtype[p]);\r
- }\r
- return(new data_type("undefined_type"));\r
- };\r
-\r
- bool handle_access(std::string pnm){\r
- int p = find_name(pnm);\r
- if(p >= 0){\r
- return(phandle[p]);\r
- }\r
- return(false);\r
- };\r
-\r
-};\r
-\r
-\r
-// Two columns are the same if they come from the\r
-// same source, and have the same field name.\r
-// (use to determine which fields must be unpacked).\r
-// NOTE : dangerous in the presence of self-joins.\r
-typedef std::set<col_id, lt_col_id> col_id_set;\r
-\r
-bool contains_gb_pr(predicate_t *pr, std::set<int> &gref_set);\r
-bool contains_gb_se(scalarexp_t *se, std::set<int> &gref_set);\r
-\r
-\r
-void gather_se_col_ids(scalarexp_t *se, col_id_set &cid_set, gb_table *gtbl);\r
-void gather_pr_col_ids(predicate_t *pr, col_id_set &cid_set, gb_table *gtbl);\r
-\r
-void gather_se_opcmp_fcns(scalarexp_t *se, std::set<std::string> &fcn_set);\r
-void gather_pr_opcmp_fcns(predicate_t *pr, std::set<std::string> &fcn_set);\r
-\r
-////////////////////////////////////////////\r
-// Structures to record usage of operator views.\r
-\r
-class opview_entry{\r
-public:\r
- std::string parent_qname;\r
- std::string root_name;\r
- std::string view_name;\r
- std::string exec_fl; // name of executable file (if any)\r
- std::string udop_alias; // unique ID of the UDOP\r
- std::string mangler;\r
- int liveness_timeout; // maximum delay between hearbeats from udop\r
- int pos;\r
- std::vector<std::string> subq_names;\r
-\r
- opview_entry(){mangler="";};\r
-};\r
-\r
-class opview_set{\r
-public:\r
- std::vector<opview_entry *> opview_list;\r
-\r
- int append(opview_entry *opv){opview_list.push_back(opv);\r
- return opview_list.size()-1;};\r
- int size(){return opview_list.size();};\r
- opview_entry *get_entry(int i){ return opview_list[i];};\r
-};\r
-\r
-/////////////////////////////////////////////////////////////////\r
-// Wrap up all of the analysis of the FTA into this package.\r
-//\r
-// There is some duplication between query_summary_class,\r
-// but I'd rather avoid pushing analysis structures\r
-// into the parse modules.\r
-//\r
-// TODO: revisit the issue when nested subqueries are implemented.\r
-// One possibility: implement accessor methods to hide the\r
-// complexity\r
-// For now: this class contains data structures not in table_exp_t\r
-// (with a bit of duplication)\r
-\r
-struct query_summary_class{\r
- std::string query_name; // the name of the query, becomes the name\r
- // of the output.\r
- int query_type; // e.g. SELECT, MERGE, etc.\r
-\r
- gb_table *gb_tbl; // Table of all group-by attributes.\r
- std::set<int> sg_tbl; // Names of the superGB attributes\r
- aggregate_table *aggr_tbl; // Table of all referenced aggregates.\r
- std::set<std::string> states_refd; // states ref'd by stateful fcns.\r
-\r
-\r
-// copied from parse tree, then into query node.\r
-// interpret the string representation of data type into a type_object\r
- param_table *param_tbl; // Table of all query parameters.\r
-\r
-// There is stuff that is not copied over by analyze_fta,\r
-// it still resides in fta_tree.\r
- table_exp_t *fta_tree; // The (decorated) parse tree.\r
-\r
-\r
-// This is copied from the parse tree (except for "query_name")\r
-// then copied to the query node in query_plan.cc:145\r
- std::map<std::string, std::string> definitions; // additional definitions.\r
-\r
-\r
-// CNF representation of the where and having predicates.\r
- std::vector<cnf_elem *> wh_cnf;\r
- std::vector<cnf_elem *> hav_cnf;\r
- std::vector<cnf_elem *> cb_cnf;\r
- std::vector<cnf_elem *> cw_cnf;\r
- std::vector<cnf_elem *> closew_cnf;\r
-\r
-\r
-\r
-\r
-// For MERGE type queries.\r
- std::vector<colref_t *> mvars;\r
- scalarexp_t *slack;\r
-\r
-//////// Constructors\r
- query_summary_class(){\r
- init();\r
- }\r
-\r
- query_summary_class(table_exp_t *f){\r
- fta_tree = f;\r
- init();\r
- }\r
-\r
-///// Methods\r
-\r
- bool add_query_param(std::string pnm, data_type *pdt, bool use_handle){\r
- return( param_tbl->add_param(pnm,pdt,use_handle));\r
- };\r
-\r
-\r
-private:\r
- void init(){\r
-// Create the gb_tbl, aggr_tbl, and param_tbl objects\r
- gb_tbl = new gb_table();\r
- aggr_tbl = new aggregate_table();\r
- param_tbl = new param_table();\r
-\r
- }\r
-};\r
-\r
-int verify_colref(scalarexp_t *se, tablevar_list_t *fm,\r
- table_list *schema, gb_table *gtbl);\r
-std::string impute_query_name(table_exp_t *fta_tree, std::string default_nm);\r
-\r
-query_summary_class *analyze_fta(table_exp_t *fta_tree, table_list *schema, ext_fcn_list *Ext_fcns, std::string qname);\r
-bool is_equivalent_se(scalarexp_t *se1, scalarexp_t *se2);\r
-bool is_equivalent_se_base(scalarexp_t *se1, scalarexp_t *se2, table_list *Schema);\r
-bool is_equivalent_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema);\r
-\r
-bool is_equivalent_class_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema,ext_fcn_list *Ext_fcns);\r
-void analyze_cnf(cnf_elem *c);\r
-\r
-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);\r
-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);\r
-void collect_partial_fcns(scalarexp_t *se, std::set<int> &pfcn_refs);\r
-void collect_partial_fcns_pr(predicate_t *pr, std::set<int> &pfcn_refs);\r
-\r
-void find_combinable_preds(predicate_t *pr, vector<predicate_t *> *pr_list,\r
- table_list *Schema, ext_fcn_list *Ext_fcns);\r
-\r
-void collect_agg_refs(scalarexp_t *se, std::set<int> &agg_refs);\r
-void collect_aggr_refs_pr(predicate_t *pr, std::set<int> &agg_refs);\r
-\r
-int bind_to_schema_pr(predicate_t *pr, tablevar_list_t *fm, table_list *schema);\r
-int bind_to_schema_se(scalarexp_t *se, tablevar_list_t *fm, table_list *schema);\r
-\r
-temporal_type compute_se_temporal(scalarexp_t *se, std::map<col_id, temporal_type> &tcol);\r
-\r
-\r
-bool find_complex_literal_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,\r
- cplx_lit_table *complex_literals);\r
-void find_complex_literal_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,\r
- cplx_lit_table *complex_literals);\r
-void find_param_handles_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,\r
- std::vector<handle_param_tbl_entry *> &handle_tbl);\r
-void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,\r
- std::vector<handle_param_tbl_entry *> &handle_tbl);\r
-\r
-// Copy a scalar expression / predicate tree\r
-scalarexp_t *dup_se(scalarexp_t *se, aggregate_table *aggr_tbl);\r
-select_element *dup_select(select_element *sl, aggregate_table *aggr_tbl);\r
-predicate_t *dup_pr(predicate_t *pr, aggregate_table *aggr_tbl);\r
-\r
-// Expand gbvars\r
-void expand_gbvars_pr(predicate_t *pr, gb_table &gb_tbl);\r
-scalarexp_t *expand_gbvars_se(scalarexp_t *se, gb_table &gb_tbl);\r
-\r
-\r
-// copy a query\r
-table_exp_t *dup_table_exp(table_exp_t *te);\r
-\r
-\r
-// Tie colrefs to a new range var\r
-void bind_colref_se(scalarexp_t *se,\r
- std::vector<tablevar_t *> &fm,\r
- int prev_ref, int new_ref\r
- );\r
-void bind_colref_pr(predicate_t *pr,\r
- std::vector<tablevar_t *> &fm,\r
- int prev_ref, int new_ref\r
- );\r
-\r
-\r
-std::string impute_colname(std::vector<select_element *> &sel_list, scalarexp_t *se);\r
-std::string impute_colname(std::set<std::string> &curr_names, scalarexp_t *se);\r
-\r
-bool is_literal_or_param_only(scalarexp_t *se);\r
-\r
-\r
-void build_aggr_tbl_fm_pred(predicate_t *pr, aggregate_table *agr_tbl);\r
-void build_aggr_tbl_fm_se(scalarexp_t *se, aggregate_table *agr_tbl);\r
-\r
-void compute_cnf_cost(cnf_elem *cm, ext_fcn_list *Ext_fcns);\r
-struct compare_cnf_cost{\r
- bool operator()(const cnf_elem *c1, const cnf_elem *c2) const{\r
- if(c1->cost < c2->cost) return(true);\r
- return(false);\r
- }\r
-};\r
-\r
-void get_tablevar_ref_se(scalarexp_t *se, std::vector<int> &reflist);\r
-void get_tablevar_ref_pr(predicate_t *pr, std::vector<int> &reflist);\r
-\r
-long long int find_temporal_divisor(scalarexp_t *se, gb_table *gbt, std::string &fnm);\r
-\r
-\r
-int count_se_ifp_refs(scalarexp_t *se, std::set<std::string> &ifpnames);\r
-int count_pr_ifp_refs(predicate_t *pr, std::set<std::string> &ifpnames);\r
-int resolve_se_ifp_refs(scalarexp_t *se, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err);\r
-int resolve_pr_ifp_refs(predicate_t *pr, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err);\r
-\r
-int pred_refs_sfun(predicate_t *pr);\r
-int se_refs_sfun(scalarexp_t *se);\r
-\r
-\r
-// Represent preds for the prefilter, and\r
-// the LFTAs which reference them.\r
-struct cnf_set{\r
- predicate_t *pr;\r
- std::set<int> lfta_id;\r
- std::set<unsigned int> pred_id;\r
-\r
- cnf_set(){};\r
- cnf_set(predicate_t *p, unsigned int l, unsigned int i){\r
- pr = dup_pr(p,NULL); // NEED TO UPDATE dup_se TO PROPAGATE\r
- lfta_id.insert(l);\r
- pred_id.insert((l << 16)+i);\r
- }\r
- void subsume(cnf_set *c){\r
- std::set<int>::iterator ssi;\r
- for(ssi=c->lfta_id.begin();ssi!=c->lfta_id.end();++ssi){\r
- lfta_id.insert((*ssi));\r
- }\r
- std::set<unsigned int >::iterator spi;\r
- for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){\r
- pred_id.insert((*spi));\r
- }\r
- }\r
- void combine_pred(cnf_set *c){\r
- pr = new predicate_t("AND",pr,c->pr);\r
- std::set<unsigned int >::iterator spi;\r
- for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){\r
- pred_id.insert((*spi));\r
- }\r
- }\r
-\r
- void add_pred_ids(set<unsigned int> &pred_set){\r
- std::set<unsigned int >::iterator spi;\r
- for(spi=pred_id.begin();spi!=pred_id.end();++spi){\r
- pred_set.insert((*spi));\r
- }\r
- }\r
-\r
- static unsigned int make_lfta_key(unsigned int l){\r
- return l << 16;\r
- }\r
-\r
-\r
- ~cnf_set(){};\r
-};\r
-struct compare_cnf_set{\r
- bool operator()(const cnf_set *c1, const cnf_set *c2) const{\r
- if(c1->lfta_id.size() > c2->lfta_id.size()) return(true);\r
- return(false);\r
- }\r
-};\r
-\r
-bool operator<(const cnf_set &c1, const cnf_set &c2);\r
-\r
-\r
-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);\r
-\r
-\r
-cnf_elem *find_common_filter(std::vector< std::vector<cnf_elem *> > &where_list, table_list *Schema);\r
-\r
-std::string int_to_string(int i);\r
-void insert_gb_def_pr(predicate_t *pr, gb_table *gtbl);\r
-void insert_gb_def_se(scalarexp_t *se, gb_table *gtbl);\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 __ANALYZE_FTA_H_DEFINED__
+#define __ANALYZE_FTA_H_DEFINED__
+
+
+
+#include "parse_fta.h"
+#include "parse_schema.h"
+#include"type_objects.h"
+#include "parse_ext_fcns.h"
+#include "iface_q.h"
+
+
+#include<set>
+#include<algorithm>
+using namespace std;
+
+
+// Represent a component of a predicate,
+// these components are ANDed together.
+// Often they are simple enough to analyze.
+class cnf_elem{
+public:
+ int is_atom; // i.e., is an atomic predicate
+ int eq_pred; // And, it is a test for equality
+ int in_pred; // Or, it is a an IN predicate
+
+ int pr_gb; // the predicate refs a gb column.
+ int pr_attr; // the predicate refs a table column.
+ int pr_aggr; // the predicate refs an aggregate
+
+ int l_simple; // the lhs is simple (just a colref)
+ int l_gb; // the lhs refs a gb var
+ int l_attr; // the lhs refs a table column
+ int l_aggr; // the lhs refs an aggregate.
+
+ int r_simple; // the rhs is simple (just a colref)
+ int r_gb; // the rhs refs a gb var
+ int r_attr; // the rhs refs a table column
+ int r_aggr; // the rhs refs an aggregate.
+
+ int cost; // an estiamte of the evaluation cost.
+
+ predicate_t *pr;
+
+ cnf_elem(predicate_t *p){
+ is_atom = 0;
+ eq_pred = 0; in_pred = 0;
+ pr_gb = pr_attr = pr_aggr = 0;
+ l_simple = l_gb = l_attr = l_aggr = 0;
+ r_simple = r_gb = r_attr = r_aggr = 0;
+ pr = p;
+ };
+
+ cnf_elem(){ is_atom = 0;
+ eq_pred = 0; in_pred = 0;
+ pr_gb = pr_attr = pr_aggr = 0;
+ l_simple = l_gb = l_attr = l_aggr = 0;
+ r_simple = r_gb = r_attr = r_aggr = 0;
+ pr = NULL;
+ };
+
+
+
+ void swap_scalar_operands(){
+ int tmp;
+ if(in_pred) return; // can't swap IN predicates, se list always on right.
+ if(! is_atom) return; // can only swap scalar expressions.
+
+ tmp = l_simple; l_simple = r_simple; r_simple = tmp;
+ tmp = l_gb; l_gb = r_gb; r_gb = tmp;
+ tmp = l_attr; l_attr = r_attr; r_attr = tmp;
+ tmp = l_aggr; l_aggr = r_aggr; r_aggr = tmp;
+
+ pr->swap_scalar_operands();
+ }
+};
+
+
+// A GB variable is identified by its name and
+// its source table variable -- so that joins can be expressed.
+// GB Vars defined AS a scalar expression have a null tableref.
+
+struct col_id{
+ std::string field;
+ int tblvar_ref;
+// Also carry the schema ref -- used to get data type info
+// when defining variables.
+ int schema_ref;
+
+ col_id(){tblvar_ref = -1;};
+ col_id(colref_t *cr){
+ field = cr->field;
+ tblvar_ref = cr-> get_tablevar_ref();
+ schema_ref = cr->get_schema_ref();
+ };
+
+
+
+ void load_from_colref(colref_t *cr){
+ field = cr->field;
+ tblvar_ref = cr-> get_tablevar_ref();
+ schema_ref = cr->get_schema_ref();
+ };
+};
+
+struct lt_col_id{
+ bool operator()(const col_id &cr1, const col_id &cr2) const{
+ if(cr1.tblvar_ref < cr2.tblvar_ref) return(1);
+ if(cr1.tblvar_ref == cr2.tblvar_ref)
+ return (cr1.field < cr2.field);
+ return(0);
+ }
+};
+
+ bool operator<(const col_id &cr1, const col_id &cr2);
+
+
+// Every GB variable is represented by its name
+// (defined above) and the scalar expression which
+// defines its value. If the GB var is devlared as a
+// colref, the add_gb_attr method of gb_table will
+// create an SE consisting of the colref.
+// NOTE : using col_id is dangerous when the
+// agregation operator is defiend over a self-join
+
+#define GBVAR_COLREF 1
+#define GBVAR_SE 2
+
+struct gb_table_entry{
+ col_id name; // tblref in col_id refers to the tablevar.
+ scalarexp_t *definition;
+ int ref_type;
+
+ gb_table_entry(){
+ definition = NULL;
+ };
+ data_type *get_data_type(){
+ return(definition->get_data_type());
+ };
+ void reset_temporal(){
+ if(definition) definition->reset_temporal();
+ }
+};
+
+
+// The GB table is the symbol table containing
+// the GB vars. This object puts a wrapper around
+// access to the table.
+
+class gb_table{
+private:
+ std::vector<gb_table_entry *> gtbl;
+
+public:
+ std::vector<vector<bool> > gb_patterns;
+// rollup, cube, and grouping_sets cannot be readily reconstructed by
+// analyzing the patterns, so explicitly record them here.
+// used only so that sgah_qpn::to_query_string produces
+// something meaningful.
+ std::vector<std::string> gb_entry_type;
+ std::vector<int> gb_entry_count;
+ std::vector<std::vector<std::vector<bool> > > pattern_components;
+
+ gb_table(){};
+
+ int add_gb_attr(gb_t *c, tablevar_list_t *fm, table_list *schema,
+ table_exp_t *fta_tree, ext_fcn_list *Ext_fcns);
+
+ void add_gb_var(std::string n, int t, scalarexp_t *d, int rt){
+ gb_table_entry *entry = new gb_table_entry();
+ entry->name.field = n;
+ entry->name.tblvar_ref = t;
+ entry->definition = d;
+ entry->ref_type = rt;
+ gtbl.push_back(entry);
+ };
+ data_type *get_data_type(int g){return(gtbl[g]->get_data_type()); };
+ int find_gb(colref_t *c, tablevar_list_t *fm, table_list *schema);
+ scalarexp_t *get_def(int i){return gtbl[i]->definition; };
+ std::string get_name(int i){return gtbl[i]->name.field; };
+ int get_tblvar_ref(int i){return gtbl[i]->name.tblvar_ref; };
+ int get_reftype(int i){return gtbl[i]->ref_type; };
+ int size(){return(gtbl.size()); };
+ void set_pattern_info(gb_table *g){
+ gb_patterns = g->gb_patterns;
+ gb_entry_type = g->gb_entry_type;
+ gb_entry_count = g->gb_entry_count;
+ pattern_components = g->pattern_components;
+ }
+ void reset_temporal(int i){
+ gtbl[i]->reset_temporal();
+ }
+};
+
+
+
+// Represent an aggregate to be calculated.
+// The unique identifier is the aggregate fcn, and the
+// expression aggregated over.
+// TODO: unify udaf with built-in better
+// (but then again, the core dumps help with debugging)
+
+struct aggr_table_entry{
+ std::string op;
+ scalarexp_t *operand;
+ std::vector<scalarexp_t *> oplist;
+ int fcn_id; // -1 for built-in aggrs.
+ data_type *sdt; // storage data type.
+ data_type *rdt; // return value data type.
+ bool is_superag;
+ bool is_running;
+ bool bailout;
+
+ aggr_table_entry(){ sdt = NULL; rdt = NULL; is_superag = false;};
+ aggr_table_entry(std::string o, scalarexp_t *se, bool s){
+ op = o; operand = se; fcn_id = -1; sdt = NULL;
+ if(se){
+ rdt = new data_type();
+ rdt->set_aggr_data_type(o,se->get_data_type());
+ }else{
+ rdt = new data_type("INT");
+ }
+ is_superag = s;
+ is_running = false;
+ bailout = false;
+ };
+ aggr_table_entry(std::string o, int f, std::vector<scalarexp_t *> s, data_type *st, bool spr, bool r, bool b_o){
+ op = o;
+ fcn_id = f;
+ operand = NULL;
+ oplist = s;
+ sdt = st;
+ rdt = NULL;
+ is_superag = spr;
+ is_running = r;
+ bailout = b_o;
+ }
+
+ bool fta_legal(ext_fcn_list *Ext_fcns);
+ bool is_star_aggr(){return operand==NULL;};
+ bool is_builtin(){return fcn_id < 0;};
+ int get_fcn_id(){return fcn_id;};
+ bool is_superaggr(){return is_superag;};
+ bool is_running_aggr(){return is_running;};
+ bool has_bailout(){return bailout;};
+ void set_super(bool s){is_superag = s;};
+
+ std::vector<std::string> get_subaggr_fcns(std::vector<bool> &use_se);
+ std::vector<data_type *> get_subaggr_dt();
+ scalarexp_t *make_superaggr_se(std::vector<scalarexp_t *> se_refs);
+ data_type *get_storage_type(){return sdt;};
+ std::vector<scalarexp_t *> get_operand_list(){return oplist;};
+
+ aggr_table_entry *duplicate(){
+ aggr_table_entry *dup = new aggr_table_entry();
+ dup->op = op;
+ dup->operand = operand;
+ dup->oplist = oplist;
+ dup->fcn_id = fcn_id;
+ dup->sdt = sdt;
+ dup->rdt = rdt;
+ dup->is_superag = is_superag;
+ dup->is_running = is_running;
+ dup->bailout = bailout;
+ return dup;
+ }
+
+ static bool superaggr_allowed(std::string op, ext_fcn_list *Ext_fcns){
+ if(op == "SUM" || op == "COUNT" || op == "MIN" || op=="MAX")
+ return true;
+ return false;
+ }
+
+ bool superaggr_allowed(){
+ if(is_builtin())
+ return aggr_table_entry::superaggr_allowed(op,NULL);
+// Currently, no UDAFS allowed as superaggregates
+ return false;
+ }
+
+ static bool multiple_return_allowed(bool is_built_in, ext_fcn_list *Ext_fcns, int fcn_id){
+ if(is_built_in)
+ return true;
+// Currently, no UDAFS allowed as stateful fcn params.
+// in cleaning_when, cleaning_by clauses.
+ if(Ext_fcns->is_running_aggr(fcn_id) || Ext_fcns->multiple_returns(fcn_id))
+ return true;
+ return false;
+ }
+
+};
+
+
+class aggregate_table{
+public:
+ std::vector<aggr_table_entry *> agr_tbl;
+
+ aggregate_table(){};
+
+ int add_aggr(std::string op, scalarexp_t *se, bool is_spr);
+ 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);
+ int add_aggr(aggr_table_entry *a){agr_tbl.push_back(a); return agr_tbl.size(); };
+ int size(){return(agr_tbl.size()); };
+ scalarexp_t *get_aggr_se(int i){return agr_tbl[i]->operand; };
+
+ data_type *get_data_type(int i){
+// if(agr_tbl[i]->op == "COUNT")
+// return new data_type("uint");
+// else
+ if(! agr_tbl[i]->rdt){
+ fprintf(stderr,"INTERNAL ERROR in aggregate_table::get_data_type : rdt is NULL.\n");
+ exit(1);
+ }
+ return agr_tbl[i]->rdt;
+ };
+
+ std::string get_op(int i){return agr_tbl[i]->op;};
+
+ bool fta_legal(int i,ext_fcn_list *Ext_fcns){return agr_tbl[i]->fta_legal(Ext_fcns); };
+ bool is_star_aggr(int i){return agr_tbl[i]->is_star_aggr(); };
+ bool is_builtin(int i){return agr_tbl[i]->is_builtin(); };
+ int get_fcn_id(int i){return agr_tbl[i]->get_fcn_id();};
+ bool is_superaggr(int i){return agr_tbl[i]->is_superaggr();};
+ bool is_running_aggr(int i){return agr_tbl[i]->is_running_aggr();};
+ bool has_bailout(int i){return agr_tbl[i]->has_bailout();};
+// bool multiple_return_allowed(int i){
+// return agr_tbl[i]->multiple_return_allowed(agr_tbl[i]->is_builtin(),NULL);
+// };
+ bool superaggr_allowed(int i){return agr_tbl[i]->superaggr_allowed();};
+ std::vector<scalarexp_t *> get_operand_list(int i){
+ return agr_tbl[i]->get_operand_list();
+ }
+
+ std::vector<std::string> get_subaggr_fcns(int i, std::vector<bool> &use_se){
+ return(agr_tbl[i]->get_subaggr_fcns(use_se) );
+ };
+
+ std::vector<data_type *> get_subaggr_dt(int i){
+ return(agr_tbl[i]->get_subaggr_dt() );
+ }
+ data_type *get_storage_type(int i){
+ return( agr_tbl[i]->get_storage_type());
+ }
+
+ aggr_table_entry *duplicate(int i){
+ return agr_tbl[i]->duplicate();
+ };
+
+ scalarexp_t *make_superaggr_se(int i, std::vector<scalarexp_t *> se_refs){
+ return(agr_tbl[i]->make_superaggr_se(se_refs) );
+ };
+};
+
+
+class cplx_lit_table{
+ std::vector<literal_t *> cplx_lit_tbl;
+ std::vector<bool> hdl_ref_tbl;
+
+public:
+ cplx_lit_table(){};
+
+ int add_cpx_lit(literal_t *, bool);
+ int size(){return cplx_lit_tbl.size();};
+ literal_t *get_literal(int i){return cplx_lit_tbl[i];};
+ bool is_handle_ref(int i){return hdl_ref_tbl[i];};
+
+};
+
+enum param_handle_type { cplx_lit_e, litval_e, param_e};
+
+class handle_param_tbl_entry{
+private:
+
+public:
+ std::string fcn_name;
+ int param_slot;
+ literal_t *litval;
+ int complex_literal_idx;
+ std::string param_name;
+ param_handle_type val_type;
+ std::string type_name;
+
+ handle_param_tbl_entry(std::string fname, int slot,
+ literal_t *l, std::string tnm){
+ fcn_name = fname; param_slot = slot;
+ val_type = litval_e;
+ litval = l;
+ type_name = tnm;
+ };
+ handle_param_tbl_entry(std::string fname, int slot, std::string p, std::string tnm){
+ fcn_name = fname; param_slot = slot;
+ val_type = param_e;
+ param_name = p;
+ type_name = tnm;
+ };
+ handle_param_tbl_entry(std::string fname, int slot, int ci, std::string tnm){
+ fcn_name = fname; param_slot = slot;
+ val_type = cplx_lit_e;
+ complex_literal_idx = ci;
+ type_name = tnm;
+ };
+
+ std::string lfta_registration_fcn(){
+ char tmps[500];
+ sprintf(tmps,"register_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);
+ return(tmps);
+ };
+ std::string hfta_registration_fcn(){return lfta_registration_fcn();};
+
+ std::string lfta_deregistration_fcn(){
+ char tmps[500];
+ sprintf(tmps,"deregister_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot);
+ return(tmps);
+ };
+ std::string hfta_rdeegistration_fcn(){return lfta_registration_fcn();};
+
+};
+
+
+class param_table{
+// Store the data in vectors to preserve
+// listing order.
+ std::vector<std::string> pname;
+ std::vector<data_type *> pdtype;
+ std::vector<bool> phandle;
+
+ int find_name(std::string n){
+ int p;
+ for(p=0;p<pname.size();++p){
+ if(pname[p] == n) break;
+ }
+ if(p == pname.size()) return(-1);
+ return(p);
+ };
+
+public:
+ param_table(){};
+
+// Add the param with the given name and associated
+// data type and handle use.
+// if its a new name, return true.
+// Else, take OR of use_handle, return false.
+// (builds param table and collects handle references).
+ bool add_param(std::string pnm, data_type *pdt, bool use_handle){
+ int p = find_name(pnm);
+ if(p == -1){
+ pname.push_back(pnm);
+ pdtype.push_back(pdt);
+ phandle.push_back(use_handle);
+ return(true);
+ }else{
+ if(use_handle) phandle[p] = use_handle;
+ return(false);
+ }
+
+ };
+
+ int size(){return pname.size(); };
+
+ std::vector<std::string> get_param_names(){
+ return(pname);
+ };
+
+ data_type *get_data_type(std::string pnm){
+ int p = find_name(pnm);
+ if(p >= 0){
+ return(pdtype[p]);
+ }
+ return(new data_type("undefined_type"));
+ };
+
+ bool handle_access(std::string pnm){
+ int p = find_name(pnm);
+ if(p >= 0){
+ return(phandle[p]);
+ }
+ return(false);
+ };
+
+};
+
+
+// Two columns are the same if they come from the
+// same source, and have the same field name.
+// (use to determine which fields must be unpacked).
+// NOTE : dangerous in the presence of self-joins.
+typedef std::set<col_id, lt_col_id> col_id_set;
+
+bool contains_gb_pr(predicate_t *pr, std::set<int> &gref_set);
+bool contains_gb_se(scalarexp_t *se, std::set<int> &gref_set);
+
+
+void gather_se_col_ids(scalarexp_t *se, col_id_set &cid_set, gb_table *gtbl);
+void gather_pr_col_ids(predicate_t *pr, col_id_set &cid_set, gb_table *gtbl);
+
+void gather_se_opcmp_fcns(scalarexp_t *se, std::set<std::string> &fcn_set);
+void gather_pr_opcmp_fcns(predicate_t *pr, std::set<std::string> &fcn_set);
+
+////////////////////////////////////////////
+// Structures to record usage of operator views.
+
+class opview_entry{
+public:
+ std::string parent_qname;
+ std::string root_name;
+ std::string view_name;
+ std::string exec_fl; // name of executable file (if any)
+ std::string udop_alias; // unique ID of the UDOP
+ std::string mangler;
+ int liveness_timeout; // maximum delay between hearbeats from udop
+ int pos;
+ std::vector<std::string> subq_names;
+
+ opview_entry(){mangler="";};
+};
+
+class opview_set{
+public:
+ std::vector<opview_entry *> opview_list;
+
+ int append(opview_entry *opv){opview_list.push_back(opv);
+ return opview_list.size()-1;};
+ int size(){return opview_list.size();};
+ opview_entry *get_entry(int i){ return opview_list[i];};
+};
+
+/////////////////////////////////////////////////////////////////
+// Wrap up all of the analysis of the FTA into this package.
+//
+// There is some duplication between query_summary_class,
+// but I'd rather avoid pushing analysis structures
+// into the parse modules.
+//
+// TODO: revisit the issue when nested subqueries are implemented.
+// One possibility: implement accessor methods to hide the
+// complexity
+// For now: this class contains data structures not in table_exp_t
+// (with a bit of duplication)
+
+struct query_summary_class{
+ std::string query_name; // the name of the query, becomes the name
+ // of the output.
+ int query_type; // e.g. SELECT, MERGE, etc.
+
+ gb_table *gb_tbl; // Table of all group-by attributes.
+ std::set<int> sg_tbl; // Names of the superGB attributes
+ aggregate_table *aggr_tbl; // Table of all referenced aggregates.
+ std::set<std::string> states_refd; // states ref'd by stateful fcns.
+
+
+// copied from parse tree, then into query node.
+// interpret the string representation of data type into a type_object
+ param_table *param_tbl; // Table of all query parameters.
+
+// There is stuff that is not copied over by analyze_fta,
+// it still resides in fta_tree.
+ table_exp_t *fta_tree; // The (decorated) parse tree.
+
+
+// This is copied from the parse tree (except for "query_name")
+// then copied to the query node in query_plan.cc:145
+ std::map<std::string, std::string> definitions; // additional definitions.
+
+
+// CNF representation of the where and having predicates.
+ std::vector<cnf_elem *> wh_cnf;
+ std::vector<cnf_elem *> hav_cnf;
+ std::vector<cnf_elem *> cb_cnf;
+ std::vector<cnf_elem *> cw_cnf;
+ std::vector<cnf_elem *> closew_cnf;
+
+
+
+
+// For MERGE type queries.
+ std::vector<colref_t *> mvars;
+ scalarexp_t *slack;
+
+//////// Constructors
+ query_summary_class(){
+ init();
+ }
+
+ query_summary_class(table_exp_t *f){
+ fta_tree = f;
+ init();
+ }
+
+///// Methods
+
+ bool add_query_param(std::string pnm, data_type *pdt, bool use_handle){
+ return( param_tbl->add_param(pnm,pdt,use_handle));
+ };
+
+
+private:
+ void init(){
+// Create the gb_tbl, aggr_tbl, and param_tbl objects
+ gb_tbl = new gb_table();
+ aggr_tbl = new aggregate_table();
+ param_tbl = new param_table();
+
+ }
+};
+
+int verify_colref(scalarexp_t *se, tablevar_list_t *fm,
+ table_list *schema, gb_table *gtbl);
+std::string impute_query_name(table_exp_t *fta_tree, std::string default_nm);
+
+query_summary_class *analyze_fta(table_exp_t *fta_tree, table_list *schema, ext_fcn_list *Ext_fcns, std::string qname);
+bool is_equivalent_se(scalarexp_t *se1, scalarexp_t *se2);
+bool is_equivalent_se_base(scalarexp_t *se1, scalarexp_t *se2, table_list *Schema);
+bool is_equivalent_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema);
+
+bool is_equivalent_class_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema,ext_fcn_list *Ext_fcns);
+void analyze_cnf(cnf_elem *c);
+
+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);
+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);
+void collect_partial_fcns(scalarexp_t *se, std::set<int> &pfcn_refs);
+void collect_partial_fcns_pr(predicate_t *pr, std::set<int> &pfcn_refs);
+
+void find_combinable_preds(predicate_t *pr, vector<predicate_t *> *pr_list,
+ table_list *Schema, ext_fcn_list *Ext_fcns);
+
+void collect_agg_refs(scalarexp_t *se, std::set<int> &agg_refs);
+void collect_aggr_refs_pr(predicate_t *pr, std::set<int> &agg_refs);
+
+int bind_to_schema_pr(predicate_t *pr, tablevar_list_t *fm, table_list *schema);
+int bind_to_schema_se(scalarexp_t *se, tablevar_list_t *fm, table_list *schema);
+
+temporal_type compute_se_temporal(scalarexp_t *se, std::map<col_id, temporal_type> &tcol);
+
+
+bool find_complex_literal_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,
+ cplx_lit_table *complex_literals);
+void find_complex_literal_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,
+ cplx_lit_table *complex_literals);
+void find_param_handles_se(scalarexp_t *se, ext_fcn_list *Ext_fcns,
+ std::vector<handle_param_tbl_entry *> &handle_tbl);
+void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,
+ std::vector<handle_param_tbl_entry *> &handle_tbl);
+
+// Copy a scalar expression / predicate tree
+scalarexp_t *dup_se(scalarexp_t *se, aggregate_table *aggr_tbl);
+select_element *dup_select(select_element *sl, aggregate_table *aggr_tbl);
+predicate_t *dup_pr(predicate_t *pr, aggregate_table *aggr_tbl);
+
+// Expand gbvars
+void expand_gbvars_pr(predicate_t *pr, gb_table &gb_tbl);
+scalarexp_t *expand_gbvars_se(scalarexp_t *se, gb_table &gb_tbl);
+
+
+// copy a query
+table_exp_t *dup_table_exp(table_exp_t *te);
+
+
+// Tie colrefs to a new range var
+void bind_colref_se(scalarexp_t *se,
+ std::vector<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ );
+void bind_colref_pr(predicate_t *pr,
+ std::vector<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ );
+
+
+std::string impute_colname(std::vector<select_element *> &sel_list, scalarexp_t *se);
+std::string impute_colname(std::set<std::string> &curr_names, scalarexp_t *se);
+
+bool is_literal_or_param_only(scalarexp_t *se);
+
+
+void build_aggr_tbl_fm_pred(predicate_t *pr, aggregate_table *agr_tbl);
+void build_aggr_tbl_fm_se(scalarexp_t *se, aggregate_table *agr_tbl);
+
+void compute_cnf_cost(cnf_elem *cm, ext_fcn_list *Ext_fcns);
+struct compare_cnf_cost{
+ bool operator()(const cnf_elem *c1, const cnf_elem *c2) const{
+ if(c1->cost < c2->cost) return(true);
+ return(false);
+ }
+};
+
+void get_tablevar_ref_se(scalarexp_t *se, std::vector<int> &reflist);
+void get_tablevar_ref_pr(predicate_t *pr, std::vector<int> &reflist);
+
+long long int find_temporal_divisor(scalarexp_t *se, gb_table *gbt, std::string &fnm);
+
+
+int count_se_ifp_refs(scalarexp_t *se, std::set<std::string> &ifpnames);
+int count_pr_ifp_refs(predicate_t *pr, std::set<std::string> &ifpnames);
+int resolve_se_ifp_refs(scalarexp_t *se, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err);
+int resolve_pr_ifp_refs(predicate_t *pr, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err);
+
+int pred_refs_sfun(predicate_t *pr);
+int se_refs_sfun(scalarexp_t *se);
+
+
+// Represent preds for the prefilter, and
+// the LFTAs which reference them.
+struct cnf_set{
+ predicate_t *pr;
+ std::set<int> lfta_id;
+ std::set<unsigned int> pred_id;
+
+ cnf_set(){};
+ cnf_set(predicate_t *p, unsigned int l, unsigned int i){
+ pr = dup_pr(p,NULL); // NEED TO UPDATE dup_se TO PROPAGATE
+ lfta_id.insert(l);
+ pred_id.insert((l << 16)+i);
+ }
+ void subsume(cnf_set *c){
+ std::set<int>::iterator ssi;
+ for(ssi=c->lfta_id.begin();ssi!=c->lfta_id.end();++ssi){
+ lfta_id.insert((*ssi));
+ }
+ std::set<unsigned int >::iterator spi;
+ for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){
+ pred_id.insert((*spi));
+ }
+ }
+ void combine_pred(cnf_set *c){
+ pr = new predicate_t("AND",pr,c->pr);
+ std::set<unsigned int >::iterator spi;
+ for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){
+ pred_id.insert((*spi));
+ }
+ }
+
+ void add_pred_ids(set<unsigned int> &pred_set){
+ std::set<unsigned int >::iterator spi;
+ for(spi=pred_id.begin();spi!=pred_id.end();++spi){
+ pred_set.insert((*spi));
+ }
+ }
+
+ static unsigned int make_lfta_key(unsigned int l){
+ return l << 16;
+ }
+
+
+ ~cnf_set(){};
+};
+struct compare_cnf_set{
+ bool operator()(const cnf_set *c1, const cnf_set *c2) const{
+ if(c1->lfta_id.size() > c2->lfta_id.size()) return(true);
+ return(false);
+ }
+};
+
+bool operator<(const cnf_set &c1, const cnf_set &c2);
+
+
+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);
+
+
+cnf_elem *find_common_filter(std::vector< std::vector<cnf_elem *> > &where_list, table_list *Schema);
+
+std::string int_to_string(int i);
+void insert_gb_def_pr(predicate_t *pr, gb_table *gtbl);
+void insert_gb_def_se(scalarexp_t *se, gb_table *gtbl);
+
+
+
+
+#endif
+
Code Review / com / gs-lite.git / blobdiff