def __init__(self, case_when, from_clause, cte, cte_name, rename): #print(json.dumps(case_when, indent=2)) self.case_when = case_when self.expr = None self.result = None self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.rename = rename if "A_Expr" in self.case_when["expr"]: temp_case = self.case_when["expr"]["A_Expr"] left = temp_case["lexpr"] right = temp_case["rexpr"] operator = temp_case["name"][0]["String"]["str"] self.expr = AExpression(left, operator, right, self.from_clause, self.cte, self.cte_name, self.rename) if "A_Const" in self.case_when["result"]: temp_case = self.case_when["result"]["A_Const"]["val"] if "Integer" in temp_case: self.result = temp_case["Integer"]["ival"] elif "String" in temp_case: self.result = temp_case["String"]["str"] elif "Float" in temp_case: self.result = temp_case["Float"]["str"] elif "Null" in temp_case: self.result = "NULL" elif "ColumnRef" in self.case_when["result"]: col = Column(self.case_when["result"]["ColumnRef"], self.from_clause, self.cte, self.cte_name, self.rename) self.result = col.transform_into_cypher()
def __init__(self, left, operator, right, from_clause=None, cte=None, cte_name=None, rename=None): self.left_initial = left self.left = None self.operator = operator self.right_initial = right self.right = None self.col_refer = None self.expr = None self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.rename = rename if "A_Const" in self.left_initial.keys(): temp_left = self.left_initial["A_Const"]["val"] if "String" in temp_left: self.left = temp_left["String"]["str"] elif "Integer" in temp_left: self.left = temp_left["Integer"]["ival"] elif "Float" in temp_left: self.left = temp_left["Float"]["str"] elif "FuncCall" in self.left_initial.keys(): self.left = FuncCall( self.left_initial["FuncCall"], self.from_clause, self.cte, self.cte_name, self.rename) self.col_refer = self.left.get_col_refer() elif "ColumnRef" in self.left_initial.keys(): self.left = Column( self.left_initial["ColumnRef"], self.from_clause, True, self.cte_name, self.rename) if "A_Const" in self.right_initial.keys(): temp_right = self.right_initial["A_Const"]["val"] if "String" in temp_right: self.right = temp_right["String"]["str"] elif "Integer" in temp_right: self.right = temp_right["Integer"]["ival"] elif "Float" in temp_right: self.right = temp_right["Float"]["str"] elif "FuncCall" in self.right_initial.keys(): self.right = FuncCall( self.right_initial["FuncCall"], self.from_clause, self.cte, self.cte_name, self.rename) self.col_refer = self.right.get_col_refer() elif "ColumnRef" in self.right_initial.keys(): self.right = Column( self.right_initial["ColumnRef"], self.from_clause, True, self.cte_name, self.rename)
def __init__(self, raw_join_cond, left, right): self.raw_join_cond = raw_join_cond self.location = None self.left_alias = left self.right_alias = right self.operator = None if "A_Expr" in self.raw_join_cond.keys(): self.operator = self.raw_join_cond["A_Expr"]["name"][0]["String"][ "str"] if "A_Expr" in self.raw_join_cond.keys(): self.location = self.raw_join_cond["A_Expr"]["location"] if "ColumnRef" in self.raw_join_cond["A_Expr"]["lexpr"]: self.left = Column( self.raw_join_cond["A_Expr"]["lexpr"]["ColumnRef"]) if "ColumnRef" in self.raw_join_cond["A_Expr"]["rexpr"]: self.right = Column( self.raw_join_cond["A_Expr"]["rexpr"]["ColumnRef"])
def __init__(self, target_list, from_clause, cte=False, cte_name=""): self.res_target = target_list self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.columns = [] self.functions = [] self.aexpressions = [] for i, elem in enumerate(target_list): if "ResTarget" in elem: rename = None if "name" in elem["ResTarget"]: rename = elem["ResTarget"]["name"] if "val" in elem["ResTarget"]: temp_val = elem["ResTarget"]["val"] if "ColumnRef" in temp_val: col = Column( temp_val["ColumnRef"], self.from_clause, self.cte, self.cte_name, rename) self.columns.append(col) elif "FuncCall" in temp_val: func = FuncCall( temp_val["FuncCall"], self.from_clause, self.cte, self.cte_name, rename, i) col_refer = func.get_col_refer() self.columns.append(col_refer) self.functions.append(func) elif "A_Expr" in temp_val: left = temp_val["A_Expr"]["lexpr"] right = temp_val["A_Expr"]["rexpr"] operator = temp_val["A_Expr"]["name"][0]["String"]["str"] a_expr = AExpression( left, operator, right, self.from_clause, self.cte, self.cte_name, rename) col_refer = a_expr.get_col_refer() self.columns.append(col_refer) self.aexpressions.append(a_expr) elif "CaseExpr" in temp_val: case_expr = CaseExpression( temp_val["CaseExpr"], self.from_clause, self.cte, self.cte_name, rename) self.columns.append(case_expr)
def __init__(self, raw_expr, from_clause, cte=False, cte_name=""): self.raw_expr = raw_expr self.sources = [] self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.boolop = self.raw_expr["boolop"] self.mapped_boolop = None self.edge_types = graph_db.get_edge_types() self.joins = [] self.possible_joins = [] self.filters = [] if self.boolop == 0: self.mapped_boolop = "AND" elif self.boolop == 1: self.mapped_boolop = "OR" elif self.boolop == 2: self.mapped_boolop = "NOT" # First possible join conditions are extracted from the boolean expression # Those joins that cannot be transformed into pattern match are appended to filter conditions for elem in self.raw_expr["args"]: if "A_Expr" in elem.keys(): left_side = elem["A_Expr"]["lexpr"] right_side = elem["A_Expr"]["rexpr"] operator = elem["A_Expr"]["name"][0]["String"]["str"] if type(left_side) == dict and type(right_side) == dict: if "ColumnRef" in left_side.keys( ) and "ColumnRef" in right_side.keys(): left = Column(left_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) right = Column(right_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) left_table = left.get_collection() right_table = right.get_collection() if left_table and right_table: if rel_db.contains_table( left_table) and rel_db.contains_table( right_table) and operator == "=": fk = left.get_field() pk = right.get_field() """ It is not a trivial task to check if a collection of equalities given in the where clause defines a graph pattern. This part relies on certain assumptions in the underlaying data transformation. But nothing guarantees that the data transformation follows those assumptions and it does not need to follow them. """ if fk + "_" + pk in self.edge_types: self.from_clause.add_join(left, right) elif pk + "_" + fk in self.edge_types: self.from_clause.add_join(right, left) else: self.filters.append(elem) else: self.filters.append(elem) else: self.filters.append(elem) else: self.filters.append(elem) else: self.filters.append(elem) else: self.filters.append(elem) # Analyze those conditions that do not define graph patterns for elem in self.filters: if "BoolExpr" in elem.keys(): self.sources.append( BooleanExpression(elem["BoolExpr"], self.from_clause, self.cte, self.cte_name)) elif "A_Expr" in elem.keys(): self.sources.append( Where(elem, self.from_clause, self.cte, self.cte_name)) elif "NullTest" in elem.keys(): self.sources.append( Where(elem, self.from_clause, self.cte, self.cte_name))
def __init__(self, func_call, from_clause, cte, cte_name, rename, index=0): self.func_call = func_call self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.rename = rename self.col_refer = None self.func = None self.index = index self.distinct = False if "agg_distinct" in self.func_call: self.distinct = self.func_call["agg_distinct"] func_name = self.func_call["funcname"][-1]["String"]["str"] if func_name == "count": star = False if "agg_star" in self.func_call: star = self.func_call["agg_star"] if star: self.func = "count(*)" self.col_refer = Column( {"fields": [{ "String": { "str": "c" + str(self.index) } }]}, self.from_clause, self.cte, self.cte_name, rename=self.rename, accept_collection_alias=False) else: for elem in self.func_call["args"]: if "CaseExpr" in elem: from model_transformations.query_transformations.parse_tree_trasformations.case_expression import CaseExpression case_expr = CaseExpression(elem["CaseExpr"], self.from_clause, self.cte, self.cte_name, self.rename) if self.distinct: self.func = "count(distinct " + \ case_expr.transform_into_cypher() + ")" else: self.func = "count( " + \ case_expr.transform_into_cypher() + ")" self.col_refer = Column( { "fields": [{ "String": { "str": "c" + str(self.index) } }] }, self.from_clause, self.cte, self.cte_name, rename=self.rename, accept_collection_alias=False) elif "ColumnRef": col = Column(elem["ColumnRef"], self.from_clause, True, self.cte_name, self.rename) if self.distinct: self.func = "count(distinct " else: self.func = "count(" self.func += col.transform_into_cypher( with_with=False) + ")" self.col_refer = Column( { "fields": [{ "String": { "str": "c" + str(self.index) } }] }, self.from_clause, self.cte, self.cte_name, rename=self.rename, accept_collection_alias=False) else: call = pg_functions_to_neo4j_functions(self.func_call, self.from_clause, self.cte, self.cte_name, self.rename) for elem in call["fields"]: self.func = call["func"]["pre"] + elem.transform_into_cypher( False) + call["func"]["post"] self.col_refer = Column( {"fields": [{ "String": { "str": "func" + str(self.index) } }]}, self.from_clause, self.cte, self.cte_name, self.rename, accept_collection_alias=False)
def __init__(self, where_clause, from_clause, cte=False, cte_name=""): #print(json.dumps(where_clause, indent = 2)) self.where_clause = where_clause self.left = None self.operator = None self.right = None self.joins = [] self.from_clause = from_clause self.cte = cte self.cte_name = cte_name self.type = None self.left_side_typecasted = False self.right_side_typecasted = False self.kind = None if "A_Expr" in self.where_clause.keys(): self.left_side = self.where_clause["A_Expr"]["lexpr"] self.right_side = self.where_clause["A_Expr"]["rexpr"] self.operator = self.where_clause["A_Expr"]["name"][0]["String"]["str"] self.kind = self.where_clause["A_Expr"]["kind"] if self.kind == 0: if type(self.left_side) == dict and type(self.right_side) == dict: if "ColumnRef" in self.left_side.keys() and "ColumnRef" in self.right_side.keys(): self.left = Column( self.left_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) self.right = Column( self.right_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) else: if "ColumnRef" in self.left_side.keys(): self.left = Column( self.left_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) elif "A_Const" in self.left_side.keys(): self.left = self.handle_a_const(self.left_side) elif "TypeCast" in self.left_side.keys(): self.left, self.type = self.handle_typecast( self.left_side) self.left_side_typecasted = True if "ColumnRef" in self.right_side.keys(): self.right = Column( self.right_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) elif "A_Const" in self.right_side.keys(): self.right = self.handle_a_const(self.right_side) elif "TypeCast" in self.right_side.keys(): self.right, self.type = self.handle_typecast( self.right_side) self.right_side_typecasted = True elif self.kind == 7: if type(self.left_side) == dict and type(self.right_side) == list: if "ColumnRef" in self.left_side.keys(): self.left = Column( self.left_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) self.right = [] for elem in self.right_side: if "A_Const" in elem.keys(): self.right.append(self.handle_a_const(elem)) elif "TypeCast" in elem.keys(): res, self.type = self.handle_typecast( self.right_side) self.right.append(res) self.right_side_typecasted = True elif self.kind == 11: if type(self.left_side) == dict and type(self.right_side) == list: if "ColumnRef" in self.left_side.keys(): self.left = Column( self.left_side["ColumnRef"], self.from_clause, self.cte, self.cte_name) self.right = [] for elem in self.right_side: if "A_Const" in elem.keys(): self.right.append(self.handle_a_const(elem)) elif "TypeCast" in elem.keys(): res, self.type = self.handle_typecast(elem) self.right.append(res) self.right_side_typecasted = True elif "NullTest" in self.where_clause.keys(): self.kind = "nulltest" self.left = Column( self.where_clause["NullTest"]["arg"]["ColumnRef"], self.from_clause, self.cte, self.cte_name) self.operator = "IS" self.right = "NULL"