def pythonmain(): testexpr1 = Join([("object","subject")], Scan("R"), Scan("R")) R = Scan(Rr) #sR = Select("lambda t: t.predicate == 'knows'", R) #sS = Select("lambda t: t.predicate == 'holdsAccount'", R) #sT = Select("lambda t: t.predicate == 'accountServiceHomepage'", R) sR = Select(EQ(NamedAttributeRef("predicate"), StringLiteral("knows")), R) sS = Select(EQ(NamedAttributeRef("predicate"), StringLiteral("holdsAccount")), R) sT = Select(EQ(NamedAttributeRef("predicate"), StringLiteral("accountServiceHomepage")), R) sRsS = Join([("object","subject")], sR, sS) sRsSsT = Join([("object1", "subject")], sRsS, sT) ssR = Select(EQ(NamedAttributeRef("predicate"), StringLiteral("holdsAccount")), sR) test = Select(OR(EQ(NamedAttributeRef("predicate"), StringLiteral("knows")),EQ(NamedAttributeRef("predicate"), StringLiteral("holdsAccount"))), R) #print ssR ossR = optimize(test, target=PythonAlgebra, source=LogicalAlgebra) #ossR = optimize(ssR, target=PseudoCodeAlgebra, source=LogicalAlgebra) #print ossR #print compile(ossR) #print compile(sRsSsT) #print [gensym() for i in range(5)] #sR = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(330337405)), R) osR = optimize(sRsSsT, target=PythonAlgebra, source=LogicalAlgebra) print compile(osR)
def to_json(self): """ Convert this query into an optimized JSON plan """ # TODO deep copy, since optimize mutates sequence = Sequence([self.query]) optimized = compile.optimize(sequence, OptLogicalAlgebra()) myria = compile.optimize(optimized, MyriaLeftDeepTreeAlgebra()) return compile_to_json(str(self.query), optimized, myria)
def get_plan(self, statements, logical=False): """Get the query plan""" self.logical = compile.optimize(statements, OptLogicalAlgebra()) self.physical = compile.optimize(self.logical, MyriaLeftDeepTreeAlgebra()) plan = self.logical if logical else self.physical # Verify that we can stringify assert str(plan) # Verify that we can convert to a dot raco.viz.get_dot(plan) # verify repr return replace_with_repr(plan)
def ccmain(): # c implementation doesn't support string literals R = Scan(btc_schema["trial"]) sR = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(1133564893)), R) sS = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(77645021)), R) sT = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(77645021)), R) sRsS = Join([("object","subject")], sR, sS) sRsSsT = Join([("object","subject")], sRsS, sT) """ """ result = optimize([('ans', sRsSsT)], target=CCAlgebra, source=LogicalAlgebra) #result = optimize(sR, target=CCAlgebra, source=LogicalAlgebra) return compile(result) def f(op): yield op #.__class__.__name__ def g(op, vars): if op in vars: del vars[op] yield (op,vars.copy()) def show(op): yield op.test #vars = dict([(x,1) for x in sR.postorder(f)]) #vars.pop(sR, None) parents = {sRsSsT:[None]} sRsSsT.collectParents(parents)
def get_json(self): lp = self.get_logical_plan() pps = optimize([(None, lp)], target=MyriaAlgebra, source=LogicalAlgebra) # TODO This is not correct. The first argument is the raw query string, # not the string representation of the logical plan return compile_to_json(str(lp), pps[0][1], pps[0][1])
def optimize(self, target=MyriaAlgebra, eliminate_common_subexpressions=False): """Convert logical plan to physical plan""" self.target = target self.physicalplan = optimize( self.logicalplan, target=self.target, source=LogicalAlgebra, eliminate_common_subexpressions=eliminate_common_subexpressions )
def get_physical_plan(self): """Return an operator representing the physical query plan.""" # TODO: Get rid of the dummy label argument here. # Return first (only) plan; strip off dummy label. logical_plan = self.get_logical_plan() physical_plans = optimize([('root', logical_plan)], target=MyriaAlgebra, source=LogicalAlgebra) return physical_plans[0][1]
def __get_physical_plan_for__(self, target_phys_algebra, **kwargs): logical_plan = self.get_logical_plan(**kwargs) kwargs['target'] = target_phys_algebra return optimize(logical_plan, **kwargs)
def logical_to_physical(lp, **kwargs): if kwargs.get('hypercube', False): algebra = MyriaHyperCubeAlgebra(FakeCatalog(64)) else: algebra = MyriaLeftDeepTreeAlgebra() return optimize(lp, algebra, **kwargs)
def optimize(self, target, **kwargs): """Convert logical plan to physical plan""" self.physicalplan = optimize(self.logicalplan, target, **kwargs)
def logical_to_physical(lp): physical_plans = optimize([('root', lp)], target=MyriaAlgebra, source=LogicalAlgebra) return physical_plans[0][1]
sch = raco.scheme.Scheme([("subject", int), ("predicate", int), ("object", int)]) # Create a relation object. We can add formats here as needed. trialdat = raco.catalog.ASCIIFile("trial.dat", sch) print sch # Now write the RA expression # Scan just takes a pointer to a relation object R = Scan(trialdat, sch) #TODO: is this supposed to pass sch? print R.scheme() # Select # EQ(x,y) means x=y, GT(x,y) means x>y, etc. sR = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(1133564893)), R) sS = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(77645021)), R) #sT = Select(EQ(NamedAttributeRef("predicate"), NumericLiteral(77645021)), R) sT = Select(EQ(NamedAttributeRef("object"), NumericLiteral(1018848684)), R) # Join([(w,x),(y,z)], R, S) means "JOIN R, S ON (R.w = S.x AND R.y = S.z)" sRsS = Join([("object","subject")], sR, sS) sRsSsT = Join([("object","subject")], sRsS, sT) # optimize applies a set of rules to translate a source # expression to a target expression result = optimize([("Ans", sT)], CCAlgebra) # compile generates the linear code from the expression tree print compile(result)
#ra = onlyrule.toRA(parsedprogram) #print exprs ra = exprs print query print ra print "//-------" # optimize applies a set of rules to translate a source # expression to a target expression #result = optimize(ra, target=PseudoCodeAlgebra, source=LogicalAlgebra) #result = optimize(ra, target=ProtobufAlgebra, source=LogicalAlgebra) result = optimize(ra, target=MyriaAlgebra, source=LogicalAlgebra) print result #comment(result) physicalplan = result #physicalplan = common_subexpression_elimination(result) #comment(physicalplan) #for x in showids(physicalplan): # print x # generate code in the target language #print compile(physicalplan) #compile(physicalplan) print compile(physicalplan)
#query = 'symmetric(a,b) :- edges1(a,b),edges2(b,a)' query = 'TwoPath(a,b,c) :- R(a,b),R(b,c)' import re p = re.compile('[^(]*') headname = p.match(query).group(0) print "query:", query, "\n" parsedprogram = parse(query) print "parsed:", parsedprogram, "\n" ra = parsedprogram.toRA() generateDot(ra,headname+'.dot') print "ra:", ra, "\n" physicalplan = optimize(ra, target=CCAlgebra, source=LogicalAlgebra) LOG.info("physical: %s",physicalplan[0]) LOG.info('args=%s',physicalplan[0][1].args) LOG.info('joinconditions=%s',physicalplan[0][1].joinconditions) LOG.info('leftconditions=%s',physicalplan[0][1].leftconditions) LOG.info('rightconditions=%s',physicalplan[0][1].rightconditions) LOG.info('final=%s',physicalplan[0][1].finalcondition) tmp = sc.cpp_code(physicalplan,headname,dis=set_sem) LOG.info('cpp_code obj:%s',tmp) tmp.gen_code()