[Checkins] SVN: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/
add basic test class to validate interfaces are properly implemented
Charith Paranaliyanage
paranaliyanage at gmail.com
Tue Jul 29 14:14:29 EDT 2008
Log message for revision 88975:
add basic test class to validate interfaces are properly implemented
Changed:
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/newqueryparser.py
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt
U Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt
-=-
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/newqueryparser.py
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/newqueryparser.py 2008-07-29 18:06:53 UTC (rev 88974)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/newqueryparser.py 2008-07-29 18:14:28 UTC (rev 88975)
@@ -84,16 +84,6 @@
print "Illegal character '%s'" % t.value[0]
t.lexer.skip(1)
- # Tokens
- def t_COMMA(self, t):
- r','
- return t
-
-#this may be != sign
- def t_NOT_EQUAL(self, t):
- r'~=='
- return t
-
def t_UNION(self, t):
r'union'
return t
@@ -102,30 +92,50 @@
r'differ'
return t
-# def t_MINUS(self, t):
-# r'-'
-# return t
-
- def t_AS(self, t):
- r'as'
+ def t_SET(self, t):
+ r'set'
return t
def t_LIST(self, t):
r'list'
return t
-
- def t_SET(self, t):
- r'set'
+
+ def t_BAG(self, t):
+ r'bag'
return t
+ def t_FOR(self, t):
+ r'for'
+ return t
+
def t_LEN(self, t):
r'len'
return t
- def t_BAG(self, t):
- r'bag'
+ def t_AS(self, t):
+ r'as'
+ return t
+
+ def t_IN(self, t):
+ r'in'
return t
+ def t_OR(self, t):
+ r'or'
+ return t
+
+ def t_AND(self, t):
+ r'and'
+ return t
+
+ def t_NOT(self, t):
+ r'not'
+ return t
+
+ def t_ISINSTANCE(self, t):
+ r'isinstance'
+ return t
+
def t_EVERY(self, t):
r'every'
return t
@@ -134,34 +144,47 @@
r'atmost'
return t
- def t_LT(self, t):
- r'<'
+ def t_ATLEAST(self, t):
+ r'atleast'
return t
- def t_GT(self, t):
- r'>'
+ def t_SOME(self, t):
+ r'some'
return t
- def t_ELLIPSIS(self, t):
- r'\.\.\.'
+ def t_JUST(self, t):
+ r'just'
return t
- def t_BRACKET_R(self, t):
- r'\)'
+ def t_CONSTANT(self, t):
+ r'(\'(\\.|[^\'])*\'|"(\\.|[^"])*"|[0-9]+)'
return t
- def t_OR(self, t):
- r'or'
+ def t_IDENTIFIER(self, t):
+ r'[a-zA-Z][0-9a-zA-Z_]*'
return t
- def t_NOT(self, t):
- r'not'
+ def t_COMMA(self, t):
+ r','
return t
- def t_ATLEAST(self, t):
- r'atleast'
+#this may be != sign
+ def t_NOT_EQUAL(self, t):
+ r'~=='
return t
+ def t_LT(self, t):
+ r'<'
+ return t
+
+ def t_GT(self, t):
+ r'>'
+ return t
+
+ def t_ELLIPSIS(self, t):
+ r'\.\.\.'
+ return t
+
def t_PIPE(self, t):
r'\|'
return t
@@ -170,32 +193,16 @@
r'\.'
return t
- def t_IN(self, t):
- r'in'
- return t
-
- def t_LTE(self, t):
- r'<='
- return t
-
def t_MUL(self, t):
r'\*'
return t
- def t_SOME(self, t):
- r'some'
- return t
-
- def t_AND(self, t):
- r'and'
- return t
-
def t_CBRACKET_L(self, t):
r'{'
return t
- def t_CONSTANT(self, t):
- r'(\'(\\.|[^\'])*\'|"(\\.|[^"])*"|[0-9]+)'
+ def t_CBRACKET_R(self, t):
+ r'}'
return t
def t_EQUAL(self, t):
@@ -206,8 +213,8 @@
r'>='
return t
- def t_ISINSTANCE(self, t):
- r'isinstance'
+ def t_LTE(self, t):
+ r'<='
return t
def t_SEMI_COLON(self, t):
@@ -218,6 +225,10 @@
r'\('
return t
+ def t_BRACKET_R(self, t):
+ r'\)'
+ return t
+
def t_ASSIGN(self, t):
r'='
return t
@@ -226,30 +237,18 @@
r'~='
return t
- def t_FOR(self, t):
- r'for'
- return t
-
# def t_DIV(self, t):
# r'/'
# return t
- def t_CBRACKET_R(self, t):
- r'}'
- return t
-
# def t_PLUS(self, t):
# r'\+'
# return t
- def t_JUST(self, t):
- r'just'
- return t
+# def t_MINUS(self, t):
+# r'-'
+# return t
- def t_IDENTIFIER(self, t):
- r'[a-zA-Z][0-9a-zA-Z_]*'
- return t
-
def t_SBRACKET_L(self, t):
r'\['
return t
@@ -312,14 +311,14 @@
t[0] = t[1]
if DEBUG: print 'reducing "literal" to "expression"', t[0]
- def p_expr_call(self, t):
- r'''expression : call
+ def p_expr_path(self, t):
+ r'''expression : path
'''
t[0] = t[1]
if DEBUG: print 'reducing "path" to "expression"', t[0]
- def p_expr_path(self, t):
- r'''expression : path
+ def p_expr_call(self, t):
+ r'''expression : call
'''
t[0] = t[1]
if DEBUG: print 'reducing "path" to "expression"', t[0]
@@ -396,12 +395,6 @@
t[3])
if DEBUG: print 'reducing "IDENTIFIER IN expression" to "generator"', t[0]
- def p_definition_as(self, t):
- r'''definition : IDENTIFIER AS expression
- '''
- #t[0]=''
- if DEBUG: print 'reducing "IDENTIFIER AS expression" to "definition"', t[0]
-
def p_filter_and(self, t):
r'''filter : filter AND filter
'''
@@ -479,7 +472,8 @@
'''
t[0] = Ne(self.metadata, self.symbols, t[1], t[3])
if DEBUG: print 'reducing "quantified operator quantified" to "condition"', t[0]
-
+
+ #need to extend this for collection of types
def p_condition_isinstance(self, t):
r'''condition : ISINSTANCE BRACKET_L expression COMMA IDENTIFIER BRACKET_R
'''
@@ -522,6 +516,12 @@
t[0] = Atmost(self.metadata, self.symbols, t[2])
if DEBUG: print 'reducing "quantification expression" to "quantified"', t[0]
+ def p_definition_as(self, t):
+ r'''definition : IDENTIFIER AS expression
+ '''
+ #t[0]=''
+ if DEBUG: print 'reducing "IDENTIFIER AS expression" to "definition"', t[0]
+
def p_literal_constant(self, t):
r'''literal : CONSTANT
'''
@@ -546,11 +546,12 @@
t[0] = t[1]
if DEBUG: print 'reducing "expression" to "element"', t[0]
- def p_element_comma(self, t):
- r'''element : element COMMA element
- '''
- #check
- if DEBUG: print 'reducing "element COMMA element" to "element"', t[0]
+# Why this raise a shift/reduce conflict
+# def p_element_comma(self, t):
+# r'''element : element COMMA element
+# '''
+# raise NotImplementedError('element list')
+# if DEBUG: print 'reducing "element COMMA element" to "element"', t[0]
def p_element_ellipsis(self, t):
r'''element : expression ELLIPSIS expression
@@ -641,7 +642,7 @@
implements(IQueryParser)
adapts(basestring)
registerAdapters()
-
+# import pydevd;pydevd.settrace()
def __init__(self, context):
self.context = context
#self.db = db
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-29 18:06:53 UTC (rev 88974)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/parser/queryparser.py 2008-07-29 18:14:28 UTC (rev 88975)
@@ -1,558 +1,558 @@
-# -*- coding: UTF-8 -*-
-
-"""Parse a string to Query Object
-
-$Id$
-"""
-
-#TODOs:
-#add metadata into the picture!!!
-#remove shift/reduce conflicts, when possible
-#look after raise "Help"
-#revise according to new grammar
-
-from ply import lex, yacc
-from collections import deque
-from threading import local
-
-from zope.component import adapts
-from zope.component import provideAdapter
-from zope.interface import implements
-
-from ocql.queryobject.queryobject import *
-from ocql.interfaces import IQueryParser
-from ocql.rewriter.rewriter import registerAdapters
-
-DEBUG = 0
-
-class SymbolContainer:
- def __init__(self):
- self.stack = deque()
- self.stack.append(dict())
-
- def addlevel(self):
- top = self.current()
- new = dict(top)
- self.stack.append(new)
-
- def dellevel(self):
- self.stack.pop()
-
- def current(self):
- return self.stack[-1]
-
-#further expand COND_OP, MODIFIER, QUANTOR
-tokens = ('TYPE', 'UNION', 'DIFFER', 'AND', 'OR', 'NOT', 'ELLIPSIS', 'IN',
- 'AS', 'SIZE', 'EQ','NE','LT','GT','LE','GE', 'ATLEAST','ATMOST','JUST','EVERY','SOME', 'CONSTANT',
- 'IDENTIFIER', 'PLUS', 'MINUS', 'MUL', 'DIV', 'BRACEL', 'BRACER',
- 'SQUAREL', 'SQUARER', 'CURLYL', 'CURLYR',
- 'PIPE', 'DOT', 'SEMICOL', 'COMMA'
- )
-
-precedence = (
- ('left', 'UNION'),
- ('left', 'DIFFER'),
-# ('token', 'SQUAREL'),
-# ('token', 'PIPE'),
-# ('token', 'SQUARER'),
- ('left', 'AND'),
- ('left', 'OR'),
- ('right', 'NOT'),
- ('left', 'EQ'),
- ('left', 'NE'),
- ('left', 'LT'),
- ('left', 'GT'),
- ('left', 'LE'),
- ('left', 'GE'),
- ('left', 'PLUS', 'MINUS'),
- ('left', 'MUL', 'DIV'),
-# ('token', 'IDENTIFIER'),
-# ('token', 'BRACEL'),
-# ('token', 'BRACER'),
-# ('token', 'CONSTANT'),
-# ('token', 'TYPE'),
-# ('token', 'CURLYL'),
-# ('token', 'CURLYR'),
-# ('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|list)'
- 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_LT(self, t):
- r'<'
- return t
-
- def t_GT(self, t):
- r'>'
- return t
-
- def t_LE(self, t):
- r'<='
- return t
-
- def t_GE(self, t):
- r'>='
- return t
-
- def t_EQ(self, t):
- r'=='
- return t
-
- def t_NE(self, t):
- r'!='
- return t
-
- #def t_MODIFIER(self, t):
- # r'(atleast|atmost|just)'
- # return t
-
- def t_ATLEAST(self, t):
- r'atleast'
- return t
-
- def t_ATMOST(self, t):
- r'atmost'
- return t
-
- def t_JUST(self, t):
- r'just'
- return t
-
- #def t_QUANTOR(self, t):
- # r'(every|some)'
- # return t
-
- def t_EVERY(self, t):
- r'every'
- return t
-
- def t_SOME(self, t):
- r'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_]*'
- if DEBUG: 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_BRACEL(self, t):
- r'\('
- return t
-
- def t_BRACER(self, t):
- r'\)'
- return t
-
- def t_SQUAREL(self, t):
- r'\['
- return t
-
- def t_SQUARER(self, t):
- r'\]'
- return t
-
- def t_CURLYL(self, t):
- r'{'
- return t
-
- def t_CURLYR(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
-
-class Parser(object):
- tokens = tokens
- precedence = precedence
- metadata = None
- symbols = None
- types = { 'set' : set, 'list': list }
- start = 'expr'
-
- def __init__(self, metadata):
- self.metadata = metadata
- self.symbols = SymbolContainer()
-
- def p_error(self, t):
- print "Syntax error at '%s' (%s)" % (t.value, t.lexpos)
-
- #expr COND_OP modifier nexpr seems to be wrong logically
- #def p_expr_cond(self, t):
- # r'''expr : modifier nexpr COND_OP modifier nexpr
- # | modifier expr COND_OP modifier nexpr'''
- # raise "Help"
-
- def p_expr_atleast(self, t):
- r'''expr : ATLEAST expr
- '''
- t[0] = Atleast(self.metadata, self.symbols, t[2])
-
- def p_expr_atmost(self, t):
- r'''expr : ATMOST expr
- '''
- t[0] = Atmost(self.metadata, self.symbols, t[2])
-
- def p_expr_just(self, t):
- r'''expr : JUST expr
- '''
- t[0] = Just(self.metadata, self.symbols, t[2])
-
- def p_expr_every(self, t):
- r'''expr : EVERY expr
- '''
- t[0] = Every(self.metadata, self.symbols, t[2])
-
- def p_expr_some(self, t):
- r'''quented : expr
- | SOME expr
- '''
- if len(t)==2:
- t[0] = t[1]
- else:
- t[0] = Some(self.metadata, self.symbols, t[2])
-
- def p_expr_eq(self, t):
- r'''expr : quented EQ expr
- '''
- t[0] = Eq(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_ne(self, t):
- r'''expr : expr NE expr
- '''
- t[0] = Ne(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_lt(self, t):
- r'''expr : expr LT expr
- '''
- t[0] = Lt(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_gt(self, t):
- r'''expr : expr GT expr
- '''
- t[0] = Gt(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_le(self, t):
- r'''expr : expr LE expr
- '''
- t[0] = Le(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_ge(self, t):
- r'''expr : expr GE expr
- '''
- t[0] = Ge(self.metadata, self.symbols, t[1], t[3])
-
- def p_expr_union(self, t):
- r'''expr : expr UNION expr
- '''
- t[0] = Union(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_differ(self, t):
- r'''expr : expr DIFFER expr
- '''
- t[0] = Differ(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_equery(self, t):
- r'''expr : TYPE SQUAREL xprs SQUARER
- '''
- #I also change the expected query in parser.txt
- t[0] = Query(self.metadata, self.symbols, self.types[t[1]],t[3],None)
-
- def p_expr_query(self, t):
- r'''expr : TYPE SQUAREL xprs PIPE expr SQUARER
- '''
- t[0] = Query(self.metadata, self.symbols, self.types[t[1]], t[3], t[5])
- if DEBUG: print "p_expr_query", t[0]
-
- def p_expr_and(self, t):
- r'''expr : expr AND expr
- '''
- t[0] = And(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_or(self, t):
- r'''expr : expr OR expr
- '''
- t[0] = Or(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_plus(self, t):
- r'''expr : expr PLUS expr
- '''
- t[0] = Add(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_minus(self, t):
- r'''expr : expr MINUS expr
- '''
- t[0] = Sub(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_mul(self, t):
- r'''expr : expr MUL expr
- '''
- t[0] = Mul(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_div(self, t):
- r'''expr : expr DIV expr
- '''
- t[0] = Div(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_not(self, t):
- r'''expr : NOT expr
- '''
- t[0] = Not(self.metadata, self.symbols, t[2])
- if DEBUG: print t[0]
-
- def p_expr_dot(self, t):
- r'''expr : expr DOT expr
- '''
- t[0] = Property(self.metadata, self.symbols, t[1], t[3])
- if DEBUG: print t[0]
-
- def p_expr_id(self, t):
- r'''expr : IDENTIFIER
- '''
- t[0] = Identifier(self.metadata, self.symbols, t[1])
- if DEBUG: print "p_expr_id", t[0]
-
-
- def p_expr_call(self, t):
- r'''expr : IDENTIFIER BRACEL exprs BRACER
- '''
- raise NotImplementedError("Function call")
-
- def p_expr_const(self, t):
- r'''expr : CONSTANT
- '''
- t[0] = Constant(self.metadata, self.symbols, t[1])
- if DEBUG: print t[0]
-
- def p_expr_array(self, t):
- r'''expr : TYPE '{' exprs '}'
- '''
- raise NotImplementedError("array")
-
- def p_expr_range(self, t):
- r'''expr : TYPE CURLYL expr ELLIPSIS expr CURLYR
- '''
- raise NotImplementedError("range")
-
-
- def p_expr_index(self, t):
- r'''expr : expr DOT SQUAREL expr SQUARER
- '''
- t[0] = Index(self.metadata, self.symbols, t[1], t[4])
- if DEBUG: print t[0]
-
- def p_expr_size(self, t):
- r'''expr : SIZE expr
- '''
- t[0] = Count(self.metadata, self.symbols, t[2])
- if DEBUG: print t[0]
-
- def p_expr_bracket(self, t):
- r'''expr : BRACEL expr BRACER
- '''
- t[0] = t[2]
- if DEBUG: print t[0]
-
- #def p_omodifier(self, t):
- # r'''omodifier : QUANTOR
- # | MODIFIER
- # '''
- # if DEBUG: print t[0]
-
- #def p_modifier(self, t):
- # r'''modifier : QUANTOR
- # | MODIFIER
- # '''
- # if DEBUG: print t[0]
-
- def p_exprs(self, t):
- r'''exprs : expr
- | expr COMMA exprs
- '''
- if DEBUG: print t[0]
-
- def p_in_expr(self, t):
- r'''in_expr : IDENTIFIER IN expr'''
- t[0] = In(self.metadata,
- self.symbols,
- Identifier(self.metadata,
- self.symbols,
- t[1]),
- t[3])
- if DEBUG: print "p_in_expr", t[0]
- if DEBUG: print t[1], t[3]
-
- def p_as_expr(self, t):
- r'''as_expr : IDENTIFIER AS expr'''
- if DEBUG: 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(0,t[1])
- t[0] = t[3]
- if DEBUG: print "p_xprs", t[0]
-
- def p_xpr(self, t):
- r'''xpr : as_expr
- | in_expr
- | expr
- '''
- t[0] = t[1]
- if DEBUG: print "p_xpr", t[0]
-
-#these are here, to keep lexer and parser instantiation to a minimum possible
-#level because they are quite expensive operations
-#parsers must be thread safe on the other hand!
-LEXER = lex.lex(object=Lexer(), debug=0)
-#PARSERS = local()
-
-def parse(str, metadata):
- lexer = LEXER.clone()
-
- #global PARSERS
- #try:
- # parser = PARSERS.parser
- #
- # try:
- # parser.restart()
- # except AttributeError:
- # pass
- #
- #except AttributeError:
- # parser = yacc.yacc(module = Parser(metadata))
- # PARSERS.parser = parser
-
- try:
- parser = yacc.yacc(module = Parser(metadata))
-
- retval = parser.parse(str, lexer = lexer)
- except Exception, e:
- if DEBUG: print e
- raise
- return retval
-
-class QueryParser(object):
- implements(IQueryParser)
- adapts(basestring)
- registerAdapters()
-
- def __init__(self, context):
- self.context = context
- #self.db = db
-
- def __call__(self, metadata):
- strg = self.context
- tree = parse(strg, metadata)
- return Head(tree)
- #return parse(strg, None)
+## -*- coding: UTF-8 -*-
+#
+#"""Parse a string to Query Object
+#
+#$Id$
+#"""
+#
+##TODOs:
+##add metadata into the picture!!!
+##remove shift/reduce conflicts, when possible
+##look after raise "Help"
+##revise according to new grammar
+#
+#from ply import lex, yacc
+#from collections import deque
+#from threading import local
+#
+#from zope.component import adapts
+#from zope.component import provideAdapter
+#from zope.interface import implements
+#
+#from ocql.queryobject.queryobject import *
+#from ocql.interfaces import IQueryParser
+#from ocql.rewriter.rewriter import registerAdapters
+#
+#DEBUG = 0
+#
+#class SymbolContainer:
+# def __init__(self):
+# self.stack = deque()
+# self.stack.append(dict())
+#
+# def addlevel(self):
+# top = self.current()
+# new = dict(top)
+# self.stack.append(new)
+#
+# def dellevel(self):
+# self.stack.pop()
+#
+# def current(self):
+# return self.stack[-1]
+#
+##further expand COND_OP, MODIFIER, QUANTOR
+#tokens = ('TYPE', 'UNION', 'DIFFER', 'AND', 'OR', 'NOT', 'ELLIPSIS', 'IN',
+# 'AS', 'SIZE', 'EQ','NE','LT','GT','LE','GE', 'ATLEAST','ATMOST','JUST','EVERY','SOME', 'CONSTANT',
+# 'IDENTIFIER', 'PLUS', 'MINUS', 'MUL', 'DIV', 'BRACEL', 'BRACER',
+# 'SQUAREL', 'SQUARER', 'CURLYL', 'CURLYR',
+# 'PIPE', 'DOT', 'SEMICOL', 'COMMA'
+# )
+#
+#precedence = (
+# ('left', 'UNION'),
+# ('left', 'DIFFER'),
+## ('token', 'SQUAREL'),
+## ('token', 'PIPE'),
+## ('token', 'SQUARER'),
+# ('left', 'AND'),
+# ('left', 'OR'),
+# ('right', 'NOT'),
+# ('left', 'EQ'),
+# ('left', 'NE'),
+# ('left', 'LT'),
+# ('left', 'GT'),
+# ('left', 'LE'),
+# ('left', 'GE'),
+# ('left', 'PLUS', 'MINUS'),
+# ('left', 'MUL', 'DIV'),
+## ('token', 'IDENTIFIER'),
+## ('token', 'BRACEL'),
+## ('token', 'BRACER'),
+## ('token', 'CONSTANT'),
+## ('token', 'TYPE'),
+## ('token', 'CURLYL'),
+## ('token', 'CURLYR'),
+## ('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|list)'
+# 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_LT(self, t):
+# r'<'
+# return t
+#
+# def t_GT(self, t):
+# r'>'
+# return t
+#
+# def t_LE(self, t):
+# r'<='
+# return t
+#
+# def t_GE(self, t):
+# r'>='
+# return t
+#
+# def t_EQ(self, t):
+# r'=='
+# return t
+#
+# def t_NE(self, t):
+# r'!='
+# return t
+#
+# #def t_MODIFIER(self, t):
+# # r'(atleast|atmost|just)'
+# # return t
+#
+# def t_ATLEAST(self, t):
+# r'atleast'
+# return t
+#
+# def t_ATMOST(self, t):
+# r'atmost'
+# return t
+#
+# def t_JUST(self, t):
+# r'just'
+# return t
+#
+# #def t_QUANTOR(self, t):
+# # r'(every|some)'
+# # return t
+#
+# def t_EVERY(self, t):
+# r'every'
+# return t
+#
+# def t_SOME(self, t):
+# r'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_]*'
+# if DEBUG: 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_BRACEL(self, t):
+# r'\('
+# return t
+#
+# def t_BRACER(self, t):
+# r'\)'
+# return t
+#
+# def t_SQUAREL(self, t):
+# r'\['
+# return t
+#
+# def t_SQUARER(self, t):
+# r'\]'
+# return t
+#
+# def t_CURLYL(self, t):
+# r'{'
+# return t
+#
+# def t_CURLYR(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
+#
+#class Parser(object):
+# tokens = tokens
+# precedence = precedence
+# metadata = None
+# symbols = None
+# types = { 'set' : set, 'list': list }
+# start = 'expr'
+#
+# def __init__(self, metadata):
+# self.metadata = metadata
+# self.symbols = SymbolContainer()
+#
+# def p_error(self, t):
+# print "Syntax error at '%s' (%s)" % (t.value, t.lexpos)
+#
+# #expr COND_OP modifier nexpr seems to be wrong logically
+# #def p_expr_cond(self, t):
+# # r'''expr : modifier nexpr COND_OP modifier nexpr
+# # | modifier expr COND_OP modifier nexpr'''
+# # raise "Help"
+#
+# def p_expr_atleast(self, t):
+# r'''expr : ATLEAST expr
+# '''
+# t[0] = Atleast(self.metadata, self.symbols, t[2])
+#
+# def p_expr_atmost(self, t):
+# r'''expr : ATMOST expr
+# '''
+# t[0] = Atmost(self.metadata, self.symbols, t[2])
+#
+# def p_expr_just(self, t):
+# r'''expr : JUST expr
+# '''
+# t[0] = Just(self.metadata, self.symbols, t[2])
+#
+# def p_expr_every(self, t):
+# r'''expr : EVERY expr
+# '''
+# t[0] = Every(self.metadata, self.symbols, t[2])
+#
+# def p_expr_some(self, t):
+# r'''quented : expr
+# | SOME expr
+# '''
+# if len(t)==2:
+# t[0] = t[1]
+# else:
+# t[0] = Some(self.metadata, self.symbols, t[2])
+#
+# def p_expr_eq(self, t):
+# r'''expr : quented EQ expr
+# '''
+# t[0] = Eq(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_ne(self, t):
+# r'''expr : expr NE expr
+# '''
+# t[0] = Ne(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_lt(self, t):
+# r'''expr : expr LT expr
+# '''
+# t[0] = Lt(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_gt(self, t):
+# r'''expr : expr GT expr
+# '''
+# t[0] = Gt(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_le(self, t):
+# r'''expr : expr LE expr
+# '''
+# t[0] = Le(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_ge(self, t):
+# r'''expr : expr GE expr
+# '''
+# t[0] = Ge(self.metadata, self.symbols, t[1], t[3])
+#
+# def p_expr_union(self, t):
+# r'''expr : expr UNION expr
+# '''
+# t[0] = Union(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_differ(self, t):
+# r'''expr : expr DIFFER expr
+# '''
+# t[0] = Differ(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_equery(self, t):
+# r'''expr : TYPE SQUAREL xprs SQUARER
+# '''
+# #I also change the expected query in parser.txt
+# t[0] = Query(self.metadata, self.symbols, self.types[t[1]],t[3],None)
+#
+# def p_expr_query(self, t):
+# r'''expr : TYPE SQUAREL xprs PIPE expr SQUARER
+# '''
+# t[0] = Query(self.metadata, self.symbols, self.types[t[1]], t[3], t[5])
+# if DEBUG: print "p_expr_query", t[0]
+#
+# def p_expr_and(self, t):
+# r'''expr : expr AND expr
+# '''
+# t[0] = And(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_or(self, t):
+# r'''expr : expr OR expr
+# '''
+# t[0] = Or(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_plus(self, t):
+# r'''expr : expr PLUS expr
+# '''
+# t[0] = Add(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_minus(self, t):
+# r'''expr : expr MINUS expr
+# '''
+# t[0] = Sub(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_mul(self, t):
+# r'''expr : expr MUL expr
+# '''
+# t[0] = Mul(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_div(self, t):
+# r'''expr : expr DIV expr
+# '''
+# t[0] = Div(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_not(self, t):
+# r'''expr : NOT expr
+# '''
+# t[0] = Not(self.metadata, self.symbols, t[2])
+# if DEBUG: print t[0]
+#
+# def p_expr_dot(self, t):
+# r'''expr : expr DOT expr
+# '''
+# t[0] = Property(self.metadata, self.symbols, t[1], t[3])
+# if DEBUG: print t[0]
+#
+# def p_expr_id(self, t):
+# r'''expr : IDENTIFIER
+# '''
+# t[0] = Identifier(self.metadata, self.symbols, t[1])
+# if DEBUG: print "p_expr_id", t[0]
+#
+#
+# def p_expr_call(self, t):
+# r'''expr : IDENTIFIER BRACEL exprs BRACER
+# '''
+# raise NotImplementedError("Function call")
+#
+# def p_expr_const(self, t):
+# r'''expr : CONSTANT
+# '''
+# t[0] = Constant(self.metadata, self.symbols, t[1])
+# if DEBUG: print t[0]
+#
+# def p_expr_array(self, t):
+# r'''expr : TYPE '{' exprs '}'
+# '''
+# raise NotImplementedError("array")
+#
+# def p_expr_range(self, t):
+# r'''expr : TYPE CURLYL expr ELLIPSIS expr CURLYR
+# '''
+# raise NotImplementedError("range")
+#
+#
+# def p_expr_index(self, t):
+# r'''expr : expr DOT SQUAREL expr SQUARER
+# '''
+# t[0] = Index(self.metadata, self.symbols, t[1], t[4])
+# if DEBUG: print t[0]
+#
+# def p_expr_size(self, t):
+# r'''expr : SIZE expr
+# '''
+# t[0] = Count(self.metadata, self.symbols, t[2])
+# if DEBUG: print t[0]
+#
+# def p_expr_bracket(self, t):
+# r'''expr : BRACEL expr BRACER
+# '''
+# t[0] = t[2]
+# if DEBUG: print t[0]
+#
+# #def p_omodifier(self, t):
+# # r'''omodifier : QUANTOR
+# # | MODIFIER
+# # '''
+# # if DEBUG: print t[0]
+#
+# #def p_modifier(self, t):
+# # r'''modifier : QUANTOR
+# # | MODIFIER
+# # '''
+# # if DEBUG: print t[0]
+#
+# def p_exprs(self, t):
+# r'''exprs : expr
+# | expr COMMA exprs
+# '''
+# if DEBUG: print t[0]
+#
+# def p_in_expr(self, t):
+# r'''in_expr : IDENTIFIER IN expr'''
+# t[0] = In(self.metadata,
+# self.symbols,
+# Identifier(self.metadata,
+# self.symbols,
+# t[1]),
+# t[3])
+# if DEBUG: print "p_in_expr", t[0]
+# if DEBUG: print t[1], t[3]
+#
+# def p_as_expr(self, t):
+# r'''as_expr : IDENTIFIER AS expr'''
+# if DEBUG: 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(0,t[1])
+# t[0] = t[3]
+# if DEBUG: print "p_xprs", t[0]
+#
+# def p_xpr(self, t):
+# r'''xpr : as_expr
+# | in_expr
+# | expr
+# '''
+# t[0] = t[1]
+# if DEBUG: print "p_xpr", t[0]
+#
+##these are here, to keep lexer and parser instantiation to a minimum possible
+##level because they are quite expensive operations
+##parsers must be thread safe on the other hand!
+#LEXER = lex.lex(object=Lexer(), debug=0)
+##PARSERS = local()
+#
+#def parse(str, metadata):
+# lexer = LEXER.clone()
+#
+# #global PARSERS
+# #try:
+# # parser = PARSERS.parser
+# #
+# # try:
+# # parser.restart()
+# # except AttributeError:
+# # pass
+# #
+# #except AttributeError:
+# # parser = yacc.yacc(module = Parser(metadata))
+# # PARSERS.parser = parser
+#
+# try:
+# parser = yacc.yacc(module = Parser(metadata))
+#
+# retval = parser.parse(str, lexer = lexer)
+# except Exception, e:
+# if DEBUG: print e
+# raise
+# return retval
+#
+#class QueryParser(object):
+# implements(IQueryParser)
+# adapts(basestring)
+# registerAdapters()
+#
+# def __init__(self, context):
+# self.context = context
+# #self.db = db
+#
+# def __call__(self, metadata):
+# strg = self.context
+# tree = parse(strg, metadata)
+# return Head(tree)
+# #return parse(strg, None)
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt 2008-07-29 18:06:53 UTC (rev 88974)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt 2008-07-29 18:14:28 UTC (rev 88975)
@@ -14,5 +14,122 @@
>>> verifyClass(IObjectQueryHead, Head)
True
+ >>> verifyClass(IObjectQueryChild, Child)
+ True
+
>>> verifyClass(IObjectQuery, QueryObject)
True
+
+ >>> verifyClass(ITerm, Term)
+ True
+
+ >>> verifyClass(IExpression, Expression)
+ True
+
+ >>> verifyClass(IhasClassWith, hasClassWith)
+ True
+
+ >>> verifyClass(IIdentifier, Identifier)
+ True
+
+ >>> verifyClass(IConstant, Constant)
+ True
+
+ >>> verifyClass(IQuery, Query)
+ True
+
+ >>> verifyClass(IAlias, Alias)
+ True
+
+ >>> verifyClass(IBinary, Binary)
+ True
+
+ >>> verifyClass(IUnion, Union)
+ True
+
+ >>> verifyClass(IDiffer, Differ)
+ True
+
+ >>> verifyClass(IAnd, And)
+ True
+
+ >>> verifyClass(IOr, Or)
+ True
+
+ >>> verifyClass(IProperty, Property)
+ True
+
+ >>> verifyClass(IIndex, Index)
+ True
+
+ >>> verifyClass(IArithmetic, Arithmetic)
+ True
+
+ >>> verifyClass(IAdd, Add)
+ True
+
+ >>> verifyClass(IMul, Mul)
+ True
+
+ >>> verifyClass(ISub, Sub)
+ True
+
+ >>> verifyClass(IDiv, Div)
+ True
+
+ >>> verifyClass(IUnary, Unary)
+ True
+
+ >>> verifyClass(INot, Not)
+ True
+
+ >>> verifyClass(IAggregate, Aggregate)
+ True
+
+ >>> verifyClass(ICount, Count)
+ True
+
+ >>> verifyClass(ISum, Sum)
+ True
+
+ >>> verifyClass(IQuantor, Quantor)
+ True
+
+ >>> verifyClass(IQuanted, Quanted)
+ True
+
+ >>> verifyClass(IEvery, Every)
+ True
+
+ >>> verifyClass(ISome, Some)
+ True
+
+ >>> verifyClass(IAtmost, Atmost)
+ True
+
+ >>> verifyClass(IAtleast, Atleast)
+ True
+
+ >>> verifyClass(IJust, Just)
+ True
+
+ >>> verifyClass(ICondition, Condition)
+ True
+
+ >>> verifyClass(IEq, Eq)
+ True
+
+ >>> verifyClass(INe, Ne)
+ True
+
+ >>> verifyClass(ILt, Lt)
+ True
+
+ >>> verifyClass(IGt, Gt)
+ True
+
+ >>> verifyClass(ILe, Le)
+ True
+
+ >>> verifyClass(IGe, Ge)
+ True
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt 2008-07-29 18:06:53 UTC (rev 88974)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt 2008-07-29 18:14:28 UTC (rev 88975)
@@ -16,3 +16,46 @@
>>> verifyClass(IAlgebraObject, BaseAlgebra)
True
+
+ >>> verifyClass(IEmpty, Empty)
+ True
+
+ >>> verifyClass(ISingle, Single)
+ True
+
+ >>> verifyClass(IUnion, Union)
+ True
+
+ >>> verifyClass(IIter, Iter)
+ True
+
+ >>> verifyClass(IReduce, Reduce)
+ True
+
+ >>> verifyClass(IRange, Range)
+ True
+
+ >>> verifyClass(IMake, Make)
+ True
+
+ #Uncomment this after merge other branch modifications
+ #>>> verifyClass(IMakeFromIndex, MakeFromIndex)
+ #True
+
+ >>> verifyClass(IIf, If)
+ True
+
+ >>> verifyClass(ILambda, Lambda)
+ True
+
+ >>> verifyClass(IConstant, Constant)
+ True
+
+ >>> verifyClass(IIdentifier, Identifier)
+ True
+
+ >>> verifyClass(IBinary, Binary)
+ True
+
+ >>> verifyClass(IOperator, Operator)
+ True
More information about the Checkins
mailing list