imagining trees of queries

D(X,Y) <- A(Z,X),B(X,Y)

Get table A()
Get table B()
D <-- Project(X,Y) <-- Join(on=X) < -- get(A,vars=(Z,X))
                                  < -- get(B,vars=(X,Y))

A(X,Y) <-- B(X),C(Z),D(Z)->(Y)

A <-- Project(X,Y) <-- Join(on=None) <-- get(B,vars=[X])
                                     <-- Calc(D,out_vars=Y in_rel=C(Z) ) <-- get(C,[z])

A(X,Y) <-- B(X),C(Z),D(Z)->(Y,Z) same as A(X,Y) <-- B(X),D(Z)->(Y,Z),C(Z)


A <-- Project(X,Y) <-- Join(on=None) <-- get(B,vars=[X])
                                     <-- Join(on=[Z])   <-- C(Z)
                                                        <-- Calc(D,out_vars=Y in_rel=C(Z) ) <-- get(C,[z])

A(X,Y) <-- B(X),C(Z),D(Z)->(Y),E(X)

A <-- Project(X,Y) <-- Join(on=None) <-- Join(on=[X]) <-- get(B,vars=[X])
                                                      <-- get(E,vars=[X])
                                     <-- Calc(D,out_vars=Y in_rel=C(Z) ) <-- get(C,[z])

A(X) <-- B(X),C(X,"5")

A <-- Project(X) <-- Join(on=X) <-- get(B, vars=[X])
                                <-- select(column=Temp1, value=5) <-- get(C, vars=[X, Temp1])

A(X) <-- B(X),C("5")

A <-- Project(X) <-- Join(on=None) <-- select(column=Temp1,value=5) <-- get(C, vars=[Temp1])
                                   <-- get(B, vars=[X])

A(Y) <-- D(Z)->(Y,Z),C(Z),E(Z,Y)

A <-- Project(Y) <-- Join(on=[Z,Y]) <-- get(C, vars=[Z])
                                    <-- Calc(D, out_vars=[Y,Z], in_rel=C(Z) ) <-- get(C,[z])
                                    <-- get(E, vars=[Z,Y])

A(Y) <-- D(Z)->(Y,Z),C(Z),E(Z,V)

A <-- Project(Y) <-- Join(on=[Z,Y]) <-- get(C, vars=[Z])
                                    <-- Calc(D, out_vars=[Y,Z], in_rel=C(Z)) <-- join(on=Z) <--get(C,[Z])
                                                                                            <--get(E,[Z,V])
                                    <-- get(E, vars=[Z,V])

also works:

A <-- Project(Y) <-- Join(on=[Z,Y]) <-- get(C, vars=[Z])
                                    <-- Calc(D, out_vars=[Y,Z], in_rel=C(Z) ) <-- get(C,[z])
                                    <-- get(E, vars=[Z,V])

also also works:

A <-- Project(Y) <-- Join(on=[Z,Y]) <-- get(C, vars=[Z])
                                    <-- Calc(D, out_vars=[Y,Z], in_rel=Temp(Z) ) <-- project(Z) <--get(E,[Z,V])
                                    <-- get(E, vars=[Z,V])

A(X,Y) <-- B(X),D(Z)->(Y,Z),C(Z),F(Z,Y,X)->(X)

A <-- Project(Y,X) <-- Join(on=[X,Y,Z]) <-- get(B, vars=[X])
                                        <-- get(C, vars=[Z])
                                        <-- Calc(D, out_vars=[Y,Z], in_rel=C(Z) ) <--get(C,[Z])
                                        <-- Calc(F, out_vars=[X], in_vars=(Z,Y,X) ) <-- join(on=[Z,X,Y]) <-- get(C, [Z])
                                                                                                         <-- get(B, [X])
                                                                                                         <-- Calc(D, out_vars=[Y,Z], in_rel=C(Z)) <-- get(C,[Z])

A(X,Y) <-- D(Z)->(Y,Z),C(Z),F(X)->(X),B(X)

A <-- Project(X,Y) <--  Join(on=[X,Y,Z]) <-- calc(D, out=[Y,Z], in=C(Z)) <-- get(C, [Z])
                                         <-- get(C, [Z])
                                         <-- calc(F, out=[X], in=B(X)) <-- get(B, [X])
                                         <-- get(B, [X])

A(X,Y) <-- C(X,Y) A(X, Y) <-- D(X, Y) A(X,Z) <-- A(Y,Z),A(X,Y) A(X,Z) <-- A(Y,Z), B(X,Y)

i:   A <-- Project(X, Z) <-- Join(on=None) <-- get(C, [X, Y])

ii:  A <-- Project(X, Z) <-- Join(on=None) <-- get(D, [X, Y])

iii: A <- Project(X, Z) <-- Join(on=[Y]) <-- get(A, [X, Y])
                                         <-- get(A, [Y, Z])

iii: A <- Project(X, Z) <-- Join(on=[Y]) <-- get(B, [X, Y])
                                         <-- get(A, [Y, Z])

A.base_trees = [i, ii]    # one union
A.rec_trees  = [iii, iv]   # iterative union

A <-- FixPoint <-- Union <-- i
                         <-- ii
               <-- Loop  <--- Union <-- iii
                                    <-- iv

def Fix_point: Calc the rules that are not recursive Run the recursive rules on each other (in every combination) until an iteration doesn't change the output use fix point util from last semester

DeanLight / spannerlib

imagining trees of queries #61