[Checkins] SVN: Sandbox/ocql-foliage/trunk/ a parser for ocql
Attila Gobi
attila.gobi at gmail.com
Tue Apr 22 06:18:28 EDT 2008
Log message for revision 85586:
a parser for ocql
Changed:
_U Sandbox/ocql-foliage/trunk/
_U Sandbox/ocql-foliage/trunk/src/
U Sandbox/ocql-foliage/trunk/src/ocql/engine/algebracompiler.py
U Sandbox/ocql-foliage/trunk/src/ocql/engine/algebraoptimizer.py
A Sandbox/ocql-foliage/trunk/src/ocql/engine/parse_ocql.py
U Sandbox/ocql-foliage/trunk/src/ocql/engine/queryobject.py
U Sandbox/ocql-foliage/trunk/src/ocql/engine/queryparser.py
U Sandbox/ocql-foliage/trunk/src/ocql/engine/rewriter.py
A Sandbox/ocql-foliage/trunk/src/test_parser.py
U Sandbox/ocql-foliage/trunk/src/testalgebra.py
-=-
Property changes on: Sandbox/ocql-foliage/trunk
___________________________________________________________________
Name: svn:ignore
+ .project
.pydevproject
Property changes on: Sandbox/ocql-foliage/trunk/src
___________________________________________________________________
Name: svn:ignore
+ ply
parser.out
parsetab.py
Modified: Sandbox/ocql-foliage/trunk/src/ocql/engine/algebracompiler.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/algebracompiler.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/algebracompiler.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -1,8 +1,8 @@
class AlgebraCompiler:
"""
- Actual compilation of the Algebra to Python is done
+ Actual compilation of the Algebra to Python is done
in each Algebra class/object at the moment
- """
+ """
def __init__(self, engine):
self.engine = engine
@@ -10,8 +10,9 @@
pass
def compile(self, alg):
- #print alg
- #print
+ #print '-> algcode begin'
+ #print alg.__class__, alg
code = alg.compile()
#print code
- return compile(code,'<string>','eval')
\ No newline at end of file
+ #print '-> algcode end'
+ return compile(code, '<string>', 'eval')
Modified: Sandbox/ocql-foliage/trunk/src/ocql/engine/algebraoptimizer.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/algebraoptimizer.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/algebraoptimizer.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -9,7 +9,7 @@
self.algebra = algebra
def applicable(self, alg):
- return isinstance(alg,self.algebra.Make) and \
+ return isinstance(alg, self.algebra.Make) and \
alg.coll1==alg.coll2
def __call__(self, alg):
Added: Sandbox/ocql-foliage/trunk/src/ocql/engine/parse_ocql.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/parse_ocql.py (rev 0)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/parse_ocql.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -0,0 +1,379 @@
+tokens = ('TYPE', 'UNION', 'DIFFER', 'AND', 'OR', 'NOT', 'ELLIPSIS', 'IN',
+ 'AS', 'SIZE', 'COND_OP', 'MODIFIER', 'QUANTOR', 'CONSTANT',
+ 'IDENTIFIER', 'PLUS', 'MINUS', 'MUL', 'DIV', 'BRAL', 'BRAR',
+ 'SQL', 'SQR', 'CURL', 'CURR', 'PIPE', 'DOT', 'SEMICOL', 'COMMA'
+ )
+
+precedence = (
+ ('left', 'UNION'),
+ ('left', 'DIFFER'),
+# ('token', 'SQL'),
+# ('token', 'PIPE'),
+# ('token', 'SQR'),
+ ('left', 'AND'),
+ ('left', 'OR'),
+ ('right', 'NOT'),
+ ('left', 'COND_OP'),
+ ('left', 'PLUS', 'MINUS'),
+ ('left', 'MUL' 'DIV'),
+# ('token', 'IDENTIFIER'),
+# ('token', 'BRAL'),
+# ('token', 'BRAR'),
+# ('token', 'CONSTANT'),
+# ('token', 'TYPE'),
+# ('token', 'CURL'),
+# ('token', 'CURR'),
+# ('token', 'ELLIPSIS'),
+ ('left', 'DOT'),
+# ('token', 'COMMA'),
+ ('left', 'SEMICOL'),
+
+ ('left', 'IN'),
+ ('left', 'AS'),
+
+# ('token', 'MODIFIER'),
+# ('token', 'QUANTOR'),
+
+ ('left', 'SIZE'),
+)
+
+class Lexer(object):
+ tokens = tokens
+ t_ignore = ' \t\n\r'
+
+ def t_error(self, t):
+ print "Illegal character '%s'" % t.value[0]
+ t.lexer.skip(1)
+
+ # Tokens
+ def t_TYPE(self, t):
+ r'(set|bag|map)'
+ return t
+
+ def t_UNION(self, t):
+ r'union'
+ return t
+
+ def t_DIFFER(self, t):
+ r'differ'
+ return t
+
+ def t_AND(self, t):
+ r'and'
+ return t
+
+ def t_OR(self, t):
+ r'or'
+ return t
+
+ def t_NOT(self, t):
+ r'not'
+ return t
+
+ def t_ELLIPSIS(self, t):
+ r'\.\.\.'
+ return t
+
+ def t_IN(self, t):
+ r'in'
+ return t
+
+ def t_AS(self, t):
+ r'as'
+ return t
+
+ def t_SIZE(self, t):
+ r'size'
+ return t
+
+ def t_COND_OP(self, t):
+ r'(<|>|<=|>=|==|!=)'
+ return t
+
+ def t_MODIFIER(self, t):
+ r'(atleast|atmost|just)'
+ return t
+
+ def t_QUANTOR(self, t):
+ r'(every|some)'
+ return t
+
+ def t_CONSTANT(self, t):
+ r'(\'(\\.|[^\'])*\'|"(\\.|[^"])*"|[0-9]+)'
+ return t
+
+ def t_IDENTIFIER(self, t):
+ r'[a-zA-Z][0-9a-zA-Z_]*'
+ print "IDEN", t
+ return t
+
+ def t_PLUS(self, t):
+ r'\+'
+ return t
+
+ def t_MINUS(self, t):
+ r'-'
+ return t
+
+ def t_MUL(self, t):
+ r'\*'
+ return t
+
+ def t_DIV(self, t):
+ r'/'
+ return t
+
+ def t_BRAL(self, t):
+ r'\('
+ return t
+
+ def t_BRAR(self, t):
+ r'\)'
+ return t
+
+ def t_SQL(self, t):
+ r'\['
+ return t
+
+ def t_SQR(self, t):
+ r'\]'
+ return t
+
+ def t_CURL(self, t):
+ r'{'
+ return t
+
+ def t_CURR(self, t):
+ r'}'
+ return t
+
+ def t_PIPE(self, t):
+ r'\|'
+ return t
+
+ def t_DOT(self, t):
+ r'\.'
+ return t
+
+ def t_SEMICOL(self, t):
+ r';'
+ return t
+
+ def t_COMMA(self, t):
+ r','
+ return t
+
+from ocql.engine.queryobject import *
+
+class Parser(object):
+ tokens = tokens
+ precedence = precedence
+ metadata = None
+ types = { 'set' : set, 'list': list }
+ start = 'expr'
+
+ def __init__(self, metadata):
+ self.metadata = metadata
+
+ def p_error(self, t):
+ print "Syntax error at '%s'" % t.value
+
+ def p_expr_cond(self, t):
+ r'''expr : modifier nexpr COND_OP omodifier nexpr
+ | expr COND_OP omodifier nexpr'''
+ raise "Help"
+
+ def p_expr_union(self, t):
+ r'''expr : expr UNION expr
+ nexpr : nexpr UNION nexpr
+ '''
+ t[0] = Union(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_differ(self, t):
+ r'''expr : expr DIFFER expr
+ nexpr : nexpr DIFFER nexpr
+ '''
+ t[0] = Differ(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_query(self, t):
+ r'''expr : TYPE SQL xprs PIPE expr SQR
+ nexpr : TYPE SQL xprs PIPE expr SQR
+ '''
+ t[0] = Query(self.metadata, self.types[t[1]], t[3], t[5])
+ print "p_expr_query", t[0]
+
+ def p_expr_and(self, t):
+ r'''expr : expr AND expr
+ nexpr : nexpr AND nexpr
+ '''
+ t[0] = And(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_or(self, t):
+ r'''expr : expr OR expr
+ nexpr : nexpr OR nexpr
+ '''
+ t[0] = Or(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_plus(self, t):
+ r'''expr : expr PLUS expr
+ nexpr : nexpr PLUS nexpr
+ '''
+ t[0] = Add(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_minus(self, t):
+ r'''expr : expr MINUS expr
+ nexpr : nexpr MINUS nexpr
+ '''
+ t[0] = Sub(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_mul(self, t):
+ r'''expr : expr MUL expr
+ nexpr : nexpr MUL nexpr
+ '''
+ t[0] = Mul(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_div(self, t):
+ r'''expr : expr DIV expr
+ nexpr : nexpr DIV nexpr
+ '''
+ t[0] = Div(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_not(self, t):
+ r'''expr : NOT expr
+ nexpr : NOT nexpr
+ '''
+ t[0] = Not(self.metadata, t[2])
+ print t[0]
+
+ def p_expr_dot(self, t):
+ r'''expr : expr DOT expr
+ nexpr : nexpr DOT expr
+ '''
+ t[0] = Property(self.metadata, t[1], t[3])
+ print t[0]
+
+ def p_expr_id(self, t):
+ r'''expr : IDENTIFIER
+ nexpr : IDENTIFIER
+ '''
+ t[0] = Identifier(self.metadata, t[1])
+ print "p_expr_id", t[0]
+
+
+ def p_expr_call(self, t):
+ r'''expr : IDENTIFIER BRAL exprs BRAR
+ nexpr : IDENTIFIER BRAL exprs BRAR
+ '''
+ raise "Not implemented: function call"
+
+ def p_expr_const(self, t):
+ r'''expr : CONSTANT
+ nexpr : CONSTANT
+ '''
+ t[0] = Constant(self.metadata, t[1])
+ print t[0]
+
+ def p_expr_array(self, t):
+ r'''expr : TYPE '{' exprs '}'
+ nexpr : TYPE '{' exprs '}'
+ '''
+ raise "Not implemented: array"
+
+ def p_expr_range(self, t):
+ r'''expr : TYPE CURL expr ELLIPSIS expr CURR
+ nexpr : TYPE CURL expr ELLIPSIS expr CURR
+ '''
+ raise "Not implemented: range"
+
+
+ def p_expr_index(self, t):
+ r'''expr : expr DOT SQL expr SQR
+ nexpr : nexpr DOT SQL expr SQR
+ '''
+ t[0] = Index(self.metadata, t[1], t[4])
+ print t[0]
+
+ def p_expr_size(self, t):
+ r'''expr : SIZE expr
+ nexpr : SIZE expr
+ '''
+ t[0] = Count(self.metadata, t[2])
+ print t[0]
+
+ def p_expr_bracket(self, t):
+ r'''expr : BRAL expr BRAR
+ nexpr : BRAL expr BRAL
+ '''
+ t[0] = t[2]
+ print t[0]
+
+ def p_omodifier(self, t):
+ r'''omodifier : QUANTOR
+ | MODIFIER
+ '''
+ print t[0]
+
+ def p_modifier(self, t):
+ r'''modifier : QUANTOR
+ | MODIFIER
+ '''
+ print t[0]
+
+ def p_exprs(self, t):
+ r'''exprs : expr
+ | expr COMMA exprs
+ '''
+ print t[0]
+
+ def p_in_expr(self, t):
+ r'''in_expr : IDENTIFIER IN expr'''
+ t[0] = In(self.metadata, Identifier(self.metadata, t[1]), t[3])
+ print "p_in_expr", t[0]
+ print t[1], t[3]
+
+ def p_as_expr(self, t):
+ r'''as_expr : IDENTIFIER AS expr'''
+ print "p_as_expr", t[0]
+
+ def p_xprs(self, t):
+ r'''xprs :
+ | xpr SEMICOL xprs
+ | xpr
+ '''
+ if len(t)==1:
+ t[0] = []
+ elif len(t)==2:
+ t[0] = [ t[1] ]
+ else:
+ t[3].insert(t[0], 0)
+ t[0] = t[3]
+ print "p_xprs", t[0]
+
+ def p_xpr(self, t):
+ r'''xpr : as_expr
+ | in_expr
+ | expr
+ '''
+ t[0] = t[1]
+ print "p_xpr", t[0]
+
+def parse(str, metadata):
+ from ply import lex, yacc
+ lexer = lex.lex(object=Lexer(), debug=0)
+ parser = yacc.yacc(module = Parser(metadata))
+
+ print str
+ try:
+ x= parser.parse(str, lexer = lexer)
+ print x
+ except Exception, e:
+ print e
+ return x
Modified: Sandbox/ocql-foliage/trunk/src/ocql/engine/queryobject.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/queryobject.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/queryobject.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -55,7 +55,7 @@
def __init__(self, metadata, expr, klass, conditional):
self.metadata = metadata
- self.expression = expression
+ self.expression = expr
self.klass = klass
self.conditional = conditional
@@ -137,7 +137,7 @@
firstTerm.expression.rewrite(algebra)
) # FIXME: ?set? must be determined by type(firstTerm.expression)
)
- elif isinstance(firstTerm,Alias):
+ elif isinstance(firstTerm, Alias):
rv = Query(
self.metadata,
self.collection_type,
@@ -145,7 +145,7 @@
self.metadata,
firstTerm.identifier,
firstTerm.expression
- )]+self.terms[1:],
+ )]+self.terms[1:],
self.target).rewrite(algebra)
else:
rv = algebra.If(
@@ -226,15 +226,17 @@
# Sets and properties
class Union(Binary):
def rewrite(self, algebra):
- algebra.Union(
- left.rewrite(algebra),
- right.rewrite(algebra))
+ return algebra.Union(
+ self.left.get_collection_type(),
+ self.left.rewrite(algebra),
+ self.right.rewrite(algebra))
class Differ(Binary):
def rewrite(self, algebra):
- algebra.Differ(
- left.rewrite(algebra),
- right.rewrite(algebra))
+ return algebra.Differ(
+ self.left.get_collection_type(),
+ self.left.rewrite(algebra),
+ self.right.rewrite(algebra))
class And(Binary):
def get_operator(self, algebra):
@@ -275,19 +277,19 @@
pass
class Add(Arithmetic):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('+')
class Mul(Arithmetic):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('*')
class Sub(Arithmetic):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('-')
class Div(Arithmetic):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('/')
#
@@ -312,9 +314,9 @@
return algebra.Reduce(
bag, # FIXME milyen bag
0,
- algebra.Lambda('i',algebra.Constant(1)),
- algebra.Operator('+'),
- make(bag,set,self.expression.rewrite(algebra))
+ algebra.Lambda('i', algebra.Constant(1)),
+ algebra.Operator('+'),
+ make(bag, set, self.expression.rewrite(algebra))
# FIXME ?set? must be determined by type(self.expression)
)
@@ -414,41 +416,41 @@
self.right = right
def rewrite(self, algebra):
- if isinstance(self.left,Quanted):
+ if isinstance(self.left, Quanted):
return self.left.rewrite(
algebra,
self.right,
self)
- if isinstance(self.right,Quanted):
+ 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))
+ return algebra.Binary(self.left.rewrite(algebra), self.get_operator(algebra), self.right.rewrite(algebra))
class Eq(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('==')
class Ne(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('!=')
class Lt(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('<')
class Gt(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('>')
class Le(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('<=')
class Ge(Condition):
- def get_operator(self,algebra):
+ def get_operator(self, algebra):
return algebra.Operator('>=')
# TODO: missing:
Modified: Sandbox/ocql-foliage/trunk/src/ocql/engine/queryparser.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/queryparser.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/queryparser.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -7,7 +7,7 @@
import copy
from collections import deque
-from ocql.engine.queryobject import *
+from queryobject import *
#this is the wired query:
"""
@@ -60,56 +60,59 @@
metadata = self.metadata
#TODO: f-ing wrong place for this
metadata.symbols = SymbolContainer()
+
+ from parse_ocql import parse
+ x = parse(query, metadata)
- WIRED = Query(
- metadata,
- set,
- [
- In(
- metadata,
- Identifier(metadata,'c'),
- Identifier(metadata,'ICurses')
- ),
- In(
- metadata,
- Identifier(metadata,'d'),
- Identifier(metadata,'IDepartments')
- ),
- Eq(
- metadata,
- Property(metadata,
- Identifier(metadata,'d'),
- Identifier(metadata,'name')),
- StringConstant(metadata,'"Computing Science"')
- ),
- Eq(
- metadata,
- Identifier(metadata,'d'),
- Quanted(
- metadata,
- Some(metadata),
- Property(metadata,
- Identifier(metadata, 'c'),
- Identifier(metadata, 'runBy'))
- )
- ),
- Le(
- metadata,
- NumericConstant(metadata, '1'),
- Property(metadata,
- Identifier(metadata, 'c'),
- Identifier(metadata, 'credits'))
- ),
- Le(
- metadata,
- Property(metadata,
- Identifier(metadata, 'c'),
- Identifier(metadata, 'credits')),
- NumericConstant(metadata, '3')
- ),
- ],
- Identifier(metadata, 'c')
- )
- x = WIRED
- #x.setMetadata(self.metadata)
- return x
\ No newline at end of file
+# WIRED = Query(
+# metadata,
+# set,
+# [
+# In(
+# metadata,
+# Identifier(metadata,'c'),
+# Identifier(metadata,'ICurses')
+# ),
+# In(
+# metadata,
+# Identifier(metadata,'d'),
+# Identifier(metadata,'IDepartments')
+# ),
+# Eq(
+# metadata,
+# Property(metadata,
+# Identifier(metadata,'d'),
+# Identifier(metadata,'name')),
+# StringConstant(metadata,'"Computing Science"')
+# ),
+# Eq(
+# metadata,
+# Identifier(metadata,'d'),
+# Quanted(
+# metadata,
+# Some(metadata),
+# Property(metadata,
+# Identifier(metadata, 'c'),
+# Identifier(metadata, 'runBy'))
+# )
+# ),
+# Le(
+# metadata,
+# NumericConstant(metadata, '1'),
+# Property(metadata,
+# Identifier(metadata, 'c'),
+# Identifier(metadata, 'credits'))
+# ),
+# Le(
+# metadata,
+# Property(metadata,
+# Identifier(metadata, 'c'),
+# Identifier(metadata, 'credits')),
+# NumericConstant(metadata, '3')
+# ),
+# ],
+# Identifier(metadata, 'c')
+# )
+# x = WIRED
+# #x.setMetadata(self.metadata)
+ return x
Modified: Sandbox/ocql-foliage/trunk/src/ocql/engine/rewriter.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/ocql/engine/rewriter.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/ocql/engine/rewriter.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -11,4 +11,4 @@
self.engine = engine
def rewrite(self, query):
- return query.rewrite(self.engine.algebra)
\ No newline at end of file
+ return query.rewrite(self.engine.algebra)
Added: Sandbox/ocql-foliage/trunk/src/test_parser.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/test_parser.py (rev 0)
+++ Sandbox/ocql-foliage/trunk/src/test_parser.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -0,0 +1,52 @@
+import unittest
+
+from ocql.ocqlengine import OCQLEngine
+
+class ElementTest(unittest.TestCase):
+ engine = OCQLEngine()
+
+ def generic_test(self, query, result):
+ print "Running query: `%s'"%query
+ q = self.engine.compile(query)
+ self.assertEqual(q.execute(), result)
+
+ def generic_testl(self, query, result):
+ print "Running query: `%s'"%query
+ q = self.engine.compile(query)
+ self.assertEqual(len(q.execute()), result)
+
+ def test_set(self):
+ self.generic_test("set [ | 1 ]", set([1]))
+
+# def test_bag(self):
+# self.generic_test("bag [ | 1 ]", bag([1]))
+
+# def test_list(self):
+# self.generic_test("list [ | 1 ]", [1])
+
+ def test_union(self):
+ self.generic_test("set [ | 1 ] union set [|2]", set([1, 2]))
+
+ def test_differ(self):
+ self.generic_test("set [ | 1 ] differ set [|2]", set([]))
+
+ def test_in(self):
+ self.generic_testl("set [ i in ICurses | i ]", 3)
+
+ def test_count(self):
+ self.generic_test("size set [ i in ICurses | i ]", 3)
+
+def test_suite():
+ tests=[]
+
+ tests.append(unittest.makeSuite(ElementTest))
+
+ return unittest.TestSuite(tests)
+
+if __name__=='__main__':
+ unittest.main(defaultTest='test_suite')
+ #engine = OCQLEngine()
+ #query="set [|1]"
+ #q = engine.compile(query)
+ #print q.execute()
+
Modified: Sandbox/ocql-foliage/trunk/src/testalgebra.py
===================================================================
--- Sandbox/ocql-foliage/trunk/src/testalgebra.py 2008-04-22 06:15:27 UTC (rev 85585)
+++ Sandbox/ocql-foliage/trunk/src/testalgebra.py 2008-04-22 10:18:28 UTC (rev 85586)
@@ -51,7 +51,7 @@
return '['+self.expr.compile()+']'
def __repr__(self):
- return 'Single(%s,%s)'%(self.klass,self.expr)
+ return 'Single(%s,%s)'%(self.klass, self.expr)
def walk(self):
yield self
@@ -81,7 +81,7 @@
self.coll2.compile())
def __repr__(self):
- return 'Union(%s,%s,%s)'%(self.klass,self.coll1,self.coll2)
+ return 'Union(%s,%s,%s)'%(self.klass, self.coll1, self.coll2)
def walk(self):
yield self
@@ -90,6 +90,19 @@
for t in self.coll2.walk():
yield t
+#class Differ:
+# def __init__(self, klass, start, enf):
+# self.klass = klass
+# self.start = start
+# self.end = end
+#
+# def compile(self):
+# if self.klass == set:
+# return 'set(range(%s,%s))' % (self.start.compile(),self.end.compile())
+# if self.klass == list:
+# return 'range(%s,%s)' % (self.start.compile(),self.end.compile())
+
+
class Iter(BaseAlgebra):
def __init__(self, klass, func, coll):
self.klass = klass
@@ -104,20 +117,20 @@
# You can place here some specialized code...
if self.klass == set:
return 'reduce(set.union, map(%s,%s) , set())' % \
- (self.func.compile(),self.coll.compile())
+ (self.func.compile(), self.coll.compile())
if self.klass == list:
return 'reduce(operator.add, map(%s,%s) , [])' % \
- (self.func.compile(),self.coll.compile())
+ (self.func.compile(), self.coll.compile())
else:
if self.klass == set:
return 'reduce(set.union, map(%s,%s) , set())' % \
- (self.func.compile(),self.coll.compile())
+ (self.func.compile(), self.coll.compile())
if self.klass == list:
return 'reduce(operator.add, map(%s,%s) , [])' % \
- (self.func.compile(),self.coll.compile())
+ (self.func.compile(), self.coll.compile())
def __repr__(self):
- return "Iter(%s,%s,%s)"%(self.klass,self.func,self.coll)
+ return "Iter(%s,%s,%s)"%(self.klass, self.func, self.coll)
def walk(self):
yield self
@@ -143,7 +156,7 @@
self.coll.compile())
def __repr__(self):
- return "Select(%s,%s,%s)"%(self.klass,self.func,self.coll)
+ return "Select(%s,%s,%s)"%(self.klass, self.func, self.coll)
def walk(self):
yield self
@@ -175,7 +188,7 @@
self.expr.compile())
def __repr__(self):
- return "Reduce(%s,%s,%s,%s,%s)"%(self.klass,self.expr,self.func,self.aggreg,self.coll)
+ return "Reduce(%s,%s,%s,%s,%s)"%(self.klass, self.expr, self.func, self.aggreg, self.coll)
def walk(self):
yield self
@@ -200,18 +213,6 @@
# if self.klass == list:
# return 'filter(%s,%s)' % (self.coll1.compile(),self.coll2.compile())
#
-#class Differ:
-# def __init__(self, klass, start, enf):
-# self.klass = klass
-# self.start = start
-# self.end = end
-#
-# def compile(self):
-# if self.klass == set:
-# return 'set(range(%s,%s))' % (self.start.compile(),self.end.compile())
-# if self.klass == list:
-# return 'range(%s,%s)' % (self.start.compile(),self.end.compile())
-
class Range(BaseAlgebra):
def __init__(self, klass, start, enf):
self.klass = klass
@@ -251,7 +252,7 @@
self.expr.compile())
def __repr__(self):
- return "Make(%s,%s,%s)" %(self.coll1,self.coll2,self.expr)
+ return "Make(%s,%s,%s)" %(self.coll1, self.coll2, self.expr)
def walk(self):
yield self
@@ -275,7 +276,7 @@
self.expr2.compile())
def __repr__(self):
- return "If(%s,%s,%s)" % (self.cond,self.expr1,self.expr2)
+ return "If(%s,%s,%s)" % (self.cond, self.expr1, self.expr2)
def walk(self):
yield self
@@ -300,7 +301,7 @@
self.expr.compile())
def __repr__(self):
- return "Lambda %s: %s" %(self.var,self.expr)
+ return "Lambda %s: %s" %(self.var, self.expr)
def walk(self):
yield self
@@ -345,7 +346,7 @@
self.right.compile())
def __repr__(self):
- return "%s%s%s" % (self.left,self.op.op,self.right)
+ return "%s%s%s" % (self.left, self.op.op, self.right)
def walk(self):
yield self
@@ -365,7 +366,7 @@
'<=': 'operator.le', '>=': 'operator.ge',
'==': 'operator.eq', '~=': 'operator.ne',
}
- def __init__(self,op):
+ def __init__(self, op):
self.op = op
def compile(self):
More information about the Checkins
mailing list