[Checkins] SVN: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/
complete rewriter adaptation. Query objects are rewriten to
matching algebra objects via adapters
Charith Paranaliyanage
paranaliyanage at gmail.com
Thu Jul 24 14:17:21 EDT 2008
Log message for revision 88797:
complete rewriter adaptation. Query objects are rewriten to matching algebra objects via adapters
Changed:
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.py
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/rewriter.py
-=-
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py 2008-07-24 17:44:53 UTC (rev 88796)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py 2008-07-24 18:17:20 UTC (rev 88797)
@@ -21,6 +21,7 @@
from ocql.queryobject.queryobject import *
from ocql.interfaces import IQueryParser
+from ocql.rewriter.rewriter import registerAdapters
DEBUG = 0
@@ -544,6 +545,7 @@
class QueryParser(object):
implements(IQueryParser)
adapts(basestring)
+ registerAdapters()
def __init__(self, context):
self.context = context
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.py
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.py 2008-07-24 17:44:53 UTC (rev 88796)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.py 2008-07-24 18:17:20 UTC (rev 88797)
@@ -30,10 +30,6 @@
def __repr__(self):
return ('%s') % (self.tree)
- def rewrite(self, algebra):
- return self.tree
-
-
class Child(Location):
implements(IObjectQueryChild)
@@ -53,7 +49,6 @@
locate(term, self, 'term')
self.children.extend(value)
-
class QueryObject(Child):
#TODO: this is dirty here, at the end we'll need to have a tree of
#QueryObject's whose topmost element will only get this IF
@@ -78,7 +73,6 @@
except AttributeError:
from pub.dbgpclient import brk; brk()
-
def get_collection_type(self, klass=None):
if klass is None:
klass = self.get_class()
@@ -90,9 +84,6 @@
#print self.name,rv
return rv
- def rewrite(self, algebra):
- raise NotImplementedError(self)
-
class Term(Child):
implements(ITerm)
identifier = None
@@ -105,7 +96,6 @@
self.setProp('identifier', identifier)
self.setProp('expression', expression)
-
class Expression(Term, QueryObject):
implements(IExpression)
@@ -128,7 +118,6 @@
self.setProp('klass', klass)
self.setProp('conditional', conditional)
-
class Identifier(Expression):
implements(IIdentifier)
name = None
@@ -145,9 +134,6 @@
str(self.name),
)
- def rewrite(self, algebra):
- return algebra.Identifier(self.name)
-
class Constant(Expression):
implements(IConstant)
#this shall be abstract?
@@ -163,9 +149,6 @@
return "%s(%s)" % (
self.__class__.__name__, self.value)
- def rewrite(self, algebra):
- return algebra.Constant(self.value)
-
class StringConstant(Constant):
pass
@@ -205,67 +188,6 @@
def get_collection_type(self, klass=None):
return self.collection_type
- def rewrite(self, algebra):
- self.symbols.addlevel()
- rv=None
-
- if len(self.terms):
- for t in self.terms:
- t.addSymbol()
-
- firstTerm = self.terms[0]
- if isinstance(firstTerm, In):
-
- ctype = firstTerm.get_collection_type()
-
- rv = algebra.Iter(
- self.collection_type,
- algebra.Lambda(
- firstTerm.identifier.name,
- Query(
- self.metadata,
- self.symbols,
- self.collection_type,
- self.terms[1:],
- self.target
- ).rewrite(algebra)
- ), algebra.Make(
- self.collection_type,
- ctype,
- firstTerm.expression.rewrite(algebra)
- ) # FIXME: ?set? must be determined by type(firstTerm.expression)
- )
- elif isinstance(firstTerm, Alias):
- rv = Query(
- self.metadata,
- self.symbols,
- self.collection_type,
- [In(
- self.metadata,
- self.symbols,
- firstTerm.identifier,
- firstTerm.expression
- )]+self.terms[1:],
- self.target).rewrite(algebra)
- else:
- rv = algebra.If(
- firstTerm.rewrite(algebra),
- Query(
- self.metadata,
- self.symbols,
- self.collection_type,
- self.terms[1:],
- self.target).rewrite(algebra),
- algebra.Empty(self.collection_type, None)
- )
- else:
- rv = algebra.Single(
- self.collection_type,
- self.target.rewrite(algebra))
-
- self.symbols.dellevel()
- return rv
-
class In(Term):
implements(IIn)
def __repr__(self):
@@ -327,44 +249,21 @@
str(self.left), str(self.right)
)
- def rewrite(self, algebra):
- return algebra.Binary(
- self.left.rewrite(algebra),
- self.get_operator(algebra),
- self.right.rewrite(algebra))
-
# Sets and properties
class Union(Binary):
implements(IUnion)
- def rewrite(self, algebra):
- return algebra.Union(
- self.left.get_collection_type(),
- self.left.rewrite(algebra),
- self.right.rewrite(algebra))
class Differ(Binary):
implements(IDiffer)
- def rewrite(self, algebra):
- return algebra.Differ(
- self.left.get_collection_type(),
- self.left.rewrite(algebra),
- self.right.rewrite(algebra))
class And(Binary):
implements(IAnd)
- def get_operator(self, algebra):
- return algebra.Operator('and')
class Or(Binary):
implements(IOr)
- def get_operator(self, algebra):
- return algebra.Operator('or')
class Property(Binary):
implements(IProperty)
- def rewrite(self, algebra): # FIXME: Ezt gondold at...
- return algebra.Identifier(
- '.'.join([self.left.name, self.right.name]))
def get_class(self):
t = self.left.get_class()
@@ -386,30 +285,21 @@
#NotImplementedError
implements(IIndex)
-
# Arithmetic operators
class Arithmetic(Binary):
implements(IArithmetic)
class Add(Arithmetic):
implements(IAdd)
- def get_operator(self, algebra):
- return algebra.Operator('+')
class Mul(Arithmetic):
implements(IMul)
- def get_operator(self, algebra):
- return algebra.Operator('*')
class Sub(Arithmetic):
implements(ISub)
- def get_operator(self, algebra):
- return algebra.Operator('-')
class Div(Arithmetic):
implements(IDiv)
- def get_operator(self, algebra):
- return algebra.Operator('/')
#
# Unary operators
@@ -432,24 +322,12 @@
class Not(Unary):
implements(INot)
- def rewrite(self, algebra):
- return algebra.Not(self.expression.rewrite(algebra))
class Aggregate(Unary):
implements(IAggregate)
-
class Count(Aggregate):
implements(ICount)
- def rewrite(self, algebra):
- return algebra.Reduce(
- bag, # FIXME milyen bag
- 0,
- algebra.Lambda('i', algebra.Constant(1)),
- algebra.Operator('+'),
- make(bag, set, self.expression.rewrite(algebra))
- # FIXME ?set? must be determined by type(self.expression)
- )
class Sum(Aggregate):
#NotImplementedError
@@ -471,9 +349,6 @@
self.__class__.__name__
)
- def rewrite(self, algebra, expression, quanter, operator):
- raise NotImplementedError()
-
class Quanted(Child):
implements(IQuanted)
quantor = None
@@ -486,82 +361,24 @@
self.setProp('quantor', quantor)
self.setProp('expression', expression)
- def rewrite(self, algebra, expression, operator):
- return self.quantor.rewrite(algebra, expression, self.expression, operator)
-
# Quantors
class Every(Quantor):
implements(IEvery)
- def rewrite(self, algebra, expression, quanted, operator):
- ctype = quanted.get_collection_type()
- return algebra.Reduce(
- ctype, # FIXME ?set? but which type() to take? quanted.expression?
- algebra.Identifier('True'),
- algebra.Lambda('i',
- operator.__class__(
- self.metadata,
- self.symbols,
- Identifier(
- self.metadata,
- self.symbols,
- 'i'),
- expression
- ).rewrite(algebra)
- ),
- algebra.Operator('and'),
- quanted.rewrite(algebra)
- )
-
class Some(Quantor):
implements(ISome)
- def rewrite(self, algebra, expression, quanted, operator):
- ctype = quanted.get_collection_type()
- return algebra.Reduce(
- ctype, # FIXME ?set? but which type() to take? quanted.expression?
- algebra.Identifier('False'),
- algebra.Lambda('i',
- operator.__class__(
- self.metadata,
- self.symbols,
- Identifier(self.metadata, self.symbols,'i'),
- expression
- ).rewrite(algebra)
- ),
- algebra.Operator('or'),
- quanted.rewrite(algebra)
- )
class Atmost(Quantor):
implements(IAtmost)
- #expr = None
- #def __init__(self, metadata, symbols, expr):
- # raise NotImplementedError(self)
- # self.metadata = metadata
- # self.symbols = symbols
- # self.expr = expr
-
class Atleast(Quantor):
implements(IAtleast)
#expr = None
- #def __init__(self, metadata, symbols, expr):
- # raise NotImplementedError(self)
- # self.metadata = metadata
- # self.symbols = symbols
- # self.expr = expr
-
class Just(Quantor):
implements(IJust)
#expr = None
- #def __init__(self, metadata, symbols, expr):
- # raise NotImplementedError(self)
- # self.metadata = metadata
- # self.symbols = symbols
- # self.expr = expr
-
# Logical operators
class Condition(Expression):
implements(ICondition)
@@ -575,49 +392,23 @@
self.setProp('left', left)
self.setProp('right', right)
- def rewrite(self, algebra):
- if isinstance(self.left, Quanted):
- return self.left.rewrite(
- algebra,
- self.right,
- self)
- if isinstance(self.right, Quanted):
- return self.right.rewrite(
- algebra,
- self.left,
- self)
- else:
- return algebra.Binary(self.left.rewrite(algebra), self.get_operator(algebra), self.right.rewrite(algebra))
-
class Eq(Condition):
implements(IEq)
- def get_operator(self, algebra):
- return algebra.Operator('==')
class Ne(Condition):
implements(INe)
- def get_operator(self, algebra):
- return algebra.Operator('!=')
class Lt(Condition):
implements(ILt)
- def get_operator(self, algebra):
- return algebra.Operator('<')
class Gt(Condition):
implements(IGt)
- def get_operator(self, algebra):
- return algebra.Operator('>')
class Le(Condition):
implements(ILe)
- def get_operator(self, algebra):
- return algebra.Operator('<=')
class Ge(Condition):
implements(IGe)
- def get_operator(self, algebra):
- return algebra.Operator('>=')
# TODO: missing:
#xi{Es}
@@ -625,4 +416,4 @@
#I(Es)
#K
#==,
- #~==
+ #~==
\ No newline at end of file
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/rewriter.py
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/rewriter.py 2008-07-24 17:44:53 UTC (rev 88796)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/rewriter.py 2008-07-24 18:17:20 UTC (rev 88797)
@@ -13,12 +13,13 @@
from zope.interface import implements
from zope.location import locate
from zope.component import provideAdapter
+
from ocql.interfaces import IRewriter
from ocql.interfaces import IOptimizedObjectQuery
-from ocql.rewriter.algebra import Head
+from ocql.rewriter.algebra import *
from ocql.queryobject.interfaces import *
-
from ocql.rewriter import algebra as target_algebra
+import ocql.queryobject.queryobject
class Rewriter(object):
implements(IRewriter)
@@ -29,94 +30,313 @@
def __call__(self):
query = self.context.tree
-# adapter = IRewriter(query)
-# alg = adapter()
- alg = query.rewrite(target_algebra)
+ adapter = IRewriter(query)
+ alg = adapter()
return Head(alg)
-
class ChildRewriter(object):
def __init__(self, context):
self.context = context
-
class IdentifierRewriter(ChildRewriter):
implements(IRewriter)
adapts(IIdentifier)
def __call__(self):
- return IRewriter(self.context.name)()
-
+ return Identifier(self.context.name)
class ConstantRewriter(ChildRewriter):
implements(IRewriter)
adapts(IConstant)
def __call__(self):
- return IRewriter(self.context.value)()
+ return Constant(self.context.value)
-
class QueryRewriter(ChildRewriter):
implements(IRewriter)
adapts(IQuery)
def __call__(self):
- return IRewriter(
- self.context.symbols.addlevel()
- )
+ self.context.symbols.addlevel()
+ rv=None
+ if len(self.context.terms):
+ for t in self.context.terms:
+ t.addSymbol()
+
+ firstTerm = self.context.terms[0]
+ if isinstance(firstTerm, ocql.queryobject.queryobject.In):
+
+ ctype = firstTerm.get_collection_type()
+
+ rv = Iter(
+ self.context.collection_type,
+ Lambda(
+ firstTerm.identifier.name,
+ IRewriter(ocql.queryobject.queryobject.Query(
+ self.context.metadata,
+ self.context.symbols,
+ self.context.collection_type,
+ self.context.terms[1:],
+ self.context.target
+ ))()
+ ), Make(
+ self.context.collection_type,
+ ctype,
+ IRewriter(firstTerm.expression)()
+ ) # FIXME: ?set? must be determined by type(firstTerm.expression)
+ )
+ elif isinstance(firstTerm, ocql.queryobject.queryobject.Alias):
+ rv = IRewriter(ocql.queryobject.queryobject.Query(
+ self.context.metadata,
+ self.context.symbols,
+ self.context.collection_type,
+ [ocql.queryobject.queryobject.In(
+ self.context.metadata,
+ self.context.symbols,
+ firstTerm.identifier,
+ firstTerm.expression
+ )]+self.context.terms[1:],
+ self.context.target))()
+ else:
+ rv = If(
+ IRewriter(firstTerm)(),
+ IRewriter(ocql.queryobject.queryobject.Query(
+ self.context.metadata,
+ self.context.symbols,
+ self.context.collection_type,
+ self.context.terms[1:],
+ self.context.target))(),
+ Empty(self.context.collection_type, None)
+ )
+ else:
+ rv = Single(
+ self.context.collection_type,
+ IRewriter(self.context.target)())
+
+ self.context.symbols.dellevel()
+ return rv
+
class BinaryRewriter(ChildRewriter):
implements(IRewriter)
adapts(IBinary)
def __call__(self):
- return IRewriter(self.context.left)
+ return Binary(IRewriter(self.context.left)(),
+ IRewriter(self.context).get_operator(),
+ IRewriter(self.context.right)())
-class UnionRewriter(ChildRewriter):
+class UnionRewriter(BinaryRewriter):
implements(IRewriter)
adapts(IUnion)
+ def __call__(self):
+ return Union(
+ self.context.left.get_collection_type(),
+ IRewriter(self.context.left)(),
+ IRewriter(self.context.right)())
-class DifferRewriter(ChildRewriter):
+class DifferRewriter(BinaryRewriter):
implements(IRewriter)
adapts(IDiffer)
+ def __call__(self):
+ return Differ(
+ self.context.left.get_collection_type(),
+ IRewriter(self.context.left)(),
+ IRewriter(self.context.right)())
-class PropertyRewriter(ChildRewriter):
+class AndRewriter(BinaryRewriter):
implements(IRewriter)
+ adapts(IAnd)
+
+ def get_operator(self):
+ return Operator('and')
+
+class OrRewriter(BinaryRewriter):
+ implements(IRewriter)
+ adapts(IOr)
+
+ def get_operator(self):
+ return Operator('or')
+
+class PropertyRewriter(BinaryRewriter):
+ implements(IRewriter)
adapts(IProperty)
+ def __call__(self):
+ return Identifier(
+ '.'.join([self.context.left.name, self.context.right.name]))
-class NotRewriter(ChildRewriter):
+class AddRewriter(BinaryRewriter):
implements(IRewriter)
+ adapts(IAdd)
+
+ def get_operator(self):
+ return Operator('+')
+
+class MulRewriter(BinaryRewriter):
+ implements(IRewriter)
+ adapts(IMul)
+
+ def get_operator(self):
+ return Operator('*')
+
+class SubRewriter(BinaryRewriter):
+ implements(IRewriter)
+ adapts(ISub)
+
+ def get_operator(self):
+ return Operator('-')
+
+class DivRewriter(BinaryRewriter):
+ implements(IRewriter)
+ adapts(IDiv)
+
+ def get_operator(self):
+ return Operator('/')
+
+class NotRewriter(BinaryRewriter):
+ implements(IRewriter)
adapts(INot)
+ def __call__(self):
+ return Not(IRewriter(self.context.expression)())
class CountRewriter(ChildRewriter):
implements(IRewriter)
adapts(ICount)
+ def __call__(self):
+ return Reduce(
+ bag, # FIXME milyen bag
+ 0,
+ Lambda('i', Constant(1)),
+ Operator('+'),
+ make(bag, set, IRewriter(self.context.expression)())
+ # FIXME ?set? must be determined by type(self.expression)
+ )
+class QuantorRewriter(ChildRewriter):
+ implements(IRewriter)
+ adapts(IQuantor)
+
+ def __call__(self, expression, quanter, operator):
+ return NotImplementedError()
+
class QuentedRewriter(ChildRewriter):
implements(IRewriter)
adapts(IQuanted)
+ def __call__(self, expression, operator):
+ return IRewriter(self.context.quantor)(expression, self.context.expression, operator)
class EveryRewriter(ChildRewriter):
implements(IRewriter)
adapts(IEvery)
+ def __call__(self, expression, quanted, operator):
+ ctype = quanted.get_collection_type()
+ return Reduce(
+ ctype, # FIXME ?set? but which type() to take? quanted.expression?
+ Identifier('True'),
+ Lambda('i',
+ IRewriter(operator.__class__(
+ self.context.metadata,
+ self.context.symbols,
+ ocql.queryobject.queryobject.Identifier(
+ self.context.metadata,
+ self.context.symbols,
+ 'i'),
+ expression
+ ))()
+ ),
+ Operator('and'),
+ IRewriter(quanted)()
+ )
+
class SomeRewriter(ChildRewriter):
implements(IRewriter)
adapts(ISome)
+ def __call__(self, expression, quanted, operator):
+ ctype = quanted.get_collection_type()
+ return Reduce(
+ ctype, # FIXME ?set? but which type() to take? quanted.expression?
+ Identifier('False'),
+ Lambda('i',
+ IRewriter(operator.__class__(
+ self.context.metadata,
+ self.context.symbols,
+ ocql.queryobject.queryobject.Identifier(
+ self.context.metadata,
+ self.context.symbols,'i'),
+ expression
+ ))()
+ ),
+ Operator('or'),
+ IRewriter(quanted)()
+ )
-class Condition(ChildRewriter):
+class ConditionRewriter(ChildRewriter):
implements(IRewriter)
adapts(ICondition)
+ def __call__(self):
+ if isinstance(self.context.left, ocql.queryobject.queryobject.Quanted):
+ return IRewriter(self.context.left)(self.context.right, self.context)
+ if isinstance(self.context.right, ocql.queryobject.queryobject.Quanted):
+ return IRewriter(self.context.right)(self.context.left, self.context)
+ else:
+ return Binary(
+ IRewriter(self.context.left)(),
+ IRewriter(self.context).get_operator(),
+ IRewriter(self.context.right)())
+class EqRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(IEq)
+
+ def get_operator(self):
+ return Operator('==')
+
+class NeRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(INe)
+
+ def get_operator(self):
+ return Operator('!=')
+
+class LtRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(ILt)
+
+ def get_operator(self):
+ return Operator('<')
+
+class GtRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(IGt)
+
+ def get_operator(self):
+ return Operator('>')
+
+class LeRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(ILe)
+
+ def get_operator(self):
+ return Operator('<=')
+
+class GeRewriter(ConditionRewriter):
+ implements(IRewriter)
+ adapts(IGe)
+
+ def get_operator(self):
+ return Operator('>=')
+
+
def registerAdapters():
provideAdapter(IdentifierRewriter)
provideAdapter(ConstantRewriter)
@@ -124,10 +344,22 @@
provideAdapter(BinaryRewriter)
provideAdapter(UnionRewriter)
provideAdapter(DifferRewriter)
+ provideAdapter(AndRewriter)
+ provideAdapter(OrRewriter)
provideAdapter(PropertyRewriter)
+ provideAdapter(AddRewriter)
+ provideAdapter(MulRewriter)
+ provideAdapter(SubRewriter)
+ provideAdapter(DivRewriter)
provideAdapter(NotRewriter)
provideAdapter(CountRewriter)
provideAdapter(QuentedRewriter)
provideAdapter(EveryRewriter)
provideAdapter(SomeRewriter)
- provideAdapter(ConstantRewriter)
+ provideAdapter(ConditionRewriter)
+ provideAdapter(EqRewriter)
+ provideAdapter(NeRewriter)
+ provideAdapter(LtRewriter)
+ provideAdapter(GtRewriter)
+ provideAdapter(LeRewriter)
+ provideAdapter(GeRewriter)
More information about the Checkins
mailing list