def test_orWith(self):
tests = (
(expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"),
(expression.isExpression("A", "1", True),
expression.andExpression((expression.isExpression("B", "2",
True), )),
"(is(A, 1, True) OR is(B, 2, True))"),
(expression.isExpression("A", "1", True),
expression.andExpression((
expression.isExpression("B", "2", True),
expression.isExpression("C", "3", True),
)), "(is(A, 1, True) OR (is(B, 2, True) AND is(C, 3, True)))"),
(expression.isExpression("A", "1", True),
expression.orExpression((expression.isExpression("B", "2",
True), )),
"(is(A, 1, True) OR is(B, 2, True))"),
(expression.isExpression("A", "1", True),
expression.orExpression((
expression.isExpression("B", "2", True),
expression.isExpression("C", "3", True),
)), "(is(A, 1, True) OR is(B, 2, True) OR is(C, 3, True))"),
(expression.andExpression((expression.isExpression("A", "1",
True), )),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"),
(expression.andExpression((
expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
)), expression.isExpression("C", "3", True),
"((is(A, 1, True) AND is(B, 2, True)) OR is(C, 3, True))"),
(expression.orExpression((expression.isExpression("A", "1",
True), )),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"),
(expression.orExpression((
expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
)), expression.isExpression("C", "3", True),
"(is(A, 1, True) OR is(B, 2, True) OR is(C, 3, True))"),
)
for expr1, expr2, result in tests:
self.assertEqual(str(expr1.orWith(expr2)),
result,
msg="Failed on %s" % (result, ))
def compfilterExpression(compfilter, fields):
"""
Create an expression for a single comp-filter element.
@param compfilter: the L{ComponentFilter} element.
@return: a L{baseExpression} for the expression tree.
"""
# Handle is-not-defined case
if not compfilter.defined:
# Test for TYPE != <<component-type name>>
return expression.isnotExpression(fields["TYPE"], compfilter.filter_name, True)
# Determine logical expression grouping
logical = expression.andExpression if compfilter.filter_test == "allof" else expression.orExpression
expressions = []
if isinstance(compfilter.filter_name, str) or isinstance(compfilter.filter_name, unicode):
expressions.append(expression.isExpression(fields["TYPE"], compfilter.filter_name, True))
else:
expressions.append(expression.inExpression(fields["TYPE"], compfilter.filter_name, True))
# Handle time-range
if compfilter.qualifier and isinstance(compfilter.qualifier, TimeRange):
start, end, startfloat, endfloat = getTimerangeArguments(compfilter.qualifier)
expressions.append(expression.timerangeExpression(start, end, startfloat, endfloat))
# Handle properties - we can only do UID right now
props = []
for p in [x for x in compfilter.filters if isinstance(x, PropertyFilter)]:
props.append(propfilterExpression(p, fields))
if len(props) > 1:
propsExpression = logical(props)
elif len(props) == 1:
propsExpression = props[0]
else:
propsExpression = None
# Handle embedded components - we do not right now as our Index does not handle them
comps = []
for _ignore in [x for x in compfilter.filters if isinstance(x, ComponentFilter)]:
raise ValueError
if len(comps) > 1:
compsExpression = logical(comps)
elif len(comps) == 1:
compsExpression = comps[0]
else:
compsExpression = None
# Now build compound expression
if ((propsExpression is not None) and (compsExpression is not None)):
expressions.append(logical([propsExpression, compsExpression]))
elif propsExpression is not None:
expressions.append(propsExpression)
elif compsExpression is not None:
expressions.append(compsExpression)
# Now build return expression
return expression.andExpression(expressions)
def compfilterExpression(compfilter, fields):
"""
Create an expression for a single comp-filter element.
@param compfilter: the L{ComponentFilter} element.
@return: a L{baseExpression} for the expression tree.
"""
# Handle is-not-defined case
if not compfilter.defined:
# Test for TYPE != <<component-type name>>
return expression.isnotExpression(fields["TYPE"], compfilter.filter_name, True)
# Determine logical expression grouping
logical = expression.andExpression if compfilter.filter_test == "allof" else expression.orExpression
expressions = []
if isinstance(compfilter.filter_name, str) or isinstance(compfilter.filter_name, unicode):
expressions.append(expression.isExpression(fields["TYPE"], compfilter.filter_name, True))
else:
expressions.append(expression.inExpression(fields["TYPE"], compfilter.filter_name, True))
# Handle time-range
if compfilter.qualifier and isinstance(compfilter.qualifier, TimeRange):
start, end, startfloat, endfloat = getTimerangeArguments(compfilter.qualifier)
expressions.append(expression.timerangeExpression(start, end, startfloat, endfloat))
# Handle properties - we can only do UID right now
props = []
for p in [x for x in compfilter.filters if isinstance(x, PropertyFilter)]:
props.append(propfilterExpression(p, fields))
if len(props) > 1:
propsExpression = logical(props)
elif len(props) == 1:
propsExpression = props[0]
else:
propsExpression = None
# Handle embedded components - we do not right now as our Index does not handle them
comps = []
for _ignore in [x for x in compfilter.filters if isinstance(x, ComponentFilter)]:
raise ValueError
if len(comps) > 1:
compsExpression = logical(comps)
elif len(comps) == 1:
compsExpression = comps[0]
else:
compsExpression = None
# Now build compound expression
if ((propsExpression is not None) and (compsExpression is not None)):
expressions.append(logical([propsExpression, compsExpression]))
elif propsExpression is not None:
expressions.append(propsExpression)
elif compsExpression is not None:
expressions.append(compsExpression)
# Now build return expression
return expression.andExpression(expressions)
def test_and_query(self):
resource = self.FakeHomeChild()
obj = resource._objectSchema
expr = expression.andExpression((
expression.isExpression(obj.UID, 5678, False),
expression.isnotExpression(obj.RESOURCE_NAME, "foobar.ics", False),
))
select, args = SQLQueryGenerator(expr, resource,
resource.id()).generate()
self.assertEqual(
select.toSQL(),
SQLFragment(
"select distinct RESOURCE_NAME, ICALENDAR_UID from CALENDAR_OBJECT where CALENDAR_RESOURCE_ID = ? and ICALENDAR_UID = ? and RESOURCE_NAME != ?",
[1234, 5678, "foobar.ics"]))
self.assertEqual(args, {})
def test_and_query(self):
resource = self.FakeHomeChild()
obj = resource._objectSchema
expr = expression.andExpression((
expression.isExpression(obj.UID, 5678, False),
expression.isnotExpression(obj.RESOURCE_NAME, "foobar.ics", False),
))
select, args = SQLQueryGenerator(expr, resource, resource.id()).generate()
self.assertEqual(
select.toSQL(),
SQLFragment(
"select distinct RESOURCE_NAME, ICALENDAR_UID from CALENDAR_OBJECT where CALENDAR_RESOURCE_ID = ? and ICALENDAR_UID = ? and RESOURCE_NAME != ?",
[1234, 5678, "foobar.ics"]
)
)
self.assertEqual(args, {})
def propfilterExpression(propfilter, fields):
"""
Create an expression for a single prop-filter element.
@param propfilter: the L{PropertyFilter} element.
@return: a L{baseExpression} for the expression tree.
"""
# Only handle UID right now
if propfilter.filter_name != "UID":
raise ValueError
# Handle is-not-defined case
if not propfilter.defined:
# Test for <<field>> != "*"
return expression.isExpression(fields["UID"], "", True)
# Handle embedded parameters/text-match
params = []
for filter in propfilter.filters:
if isinstance(filter, TextMatch):
if filter.match_type == "equals":
tm = expression.isnotExpression if filter.negate else expression.isExpression
elif filter.match_type == "contains":
tm = expression.notcontainsExpression if filter.negate else expression.containsExpression
elif filter.match_type == "starts-with":
tm = expression.notstartswithExpression if filter.negate else expression.startswithExpression
elif filter.match_type == "ends-with":
tm = expression.notendswithExpression if filter.negate else expression.endswithExpression
params.append(
tm(fields[propfilter.filter_name], str(filter.text), True))
else:
# No embedded parameters - not right now as our Index does not handle them
raise ValueError
# Now build return expression
if len(params) > 1:
if propfilter.propfilter_test == "anyof":
return expression.orExpression(params)
else:
return expression.andExpression(params)
elif len(params) == 1:
return params[0]
else:
return None
def propfilterExpression(propfilter, fields):
"""
Create an expression for a single prop-filter element.
@param propfilter: the L{PropertyFilter} element.
@return: a L{baseExpression} for the expression tree.
"""
# Only handle UID right now
if propfilter.filter_name != "UID":
raise ValueError
# Handle is-not-defined case
if not propfilter.defined:
# Test for <<field>> != "*"
return expression.isExpression(fields["UID"], "", True)
# Handle embedded parameters/text-match
params = []
for filter in propfilter.filters:
if isinstance(filter, TextMatch):
if filter.match_type == "equals":
tm = expression.isnotExpression if filter.negate else expression.isExpression
elif filter.match_type == "contains":
tm = expression.notcontainsExpression if filter.negate else expression.containsExpression
elif filter.match_type == "starts-with":
tm = expression.notstartswithExpression if filter.negate else expression.startswithExpression
elif filter.match_type == "ends-with":
tm = expression.notendswithExpression if filter.negate else expression.endswithExpression
params.append(tm(fields[propfilter.filter_name], str(filter.text), True))
else:
# No embedded parameters - not right now as our Index does not handle them
raise ValueError
# Now build return expression
if len(params) > 1:
if propfilter.propfilter_test == "anyof":
return expression.orExpression(params)
else:
return expression.andExpression(params)
elif len(params) == 1:
return params[0]
else:
return None
def test_orWith(self):
tests = (
(
expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"
),
(
expression.isExpression("A", "1", True),
expression.andExpression((
expression.isExpression("B", "2", True),
)),
"(is(A, 1, True) OR is(B, 2, True))"
),
(
expression.isExpression("A", "1", True),
expression.andExpression((
expression.isExpression("B", "2", True),
expression.isExpression("C", "3", True),
)),
"(is(A, 1, True) OR (is(B, 2, True) AND is(C, 3, True)))"
),
(
expression.isExpression("A", "1", True),
expression.orExpression((
expression.isExpression("B", "2", True),
)),
"(is(A, 1, True) OR is(B, 2, True))"
),
(
expression.isExpression("A", "1", True),
expression.orExpression((
expression.isExpression("B", "2", True),
expression.isExpression("C", "3", True),
)),
"(is(A, 1, True) OR is(B, 2, True) OR is(C, 3, True))"
),
(
expression.andExpression((
expression.isExpression("A", "1", True),
)),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"
),
(
expression.andExpression((
expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
)),
expression.isExpression("C", "3", True),
"((is(A, 1, True) AND is(B, 2, True)) OR is(C, 3, True))"
),
(
expression.orExpression((
expression.isExpression("A", "1", True),
)),
expression.isExpression("B", "2", True),
"(is(A, 1, True) OR is(B, 2, True))"
),
(
expression.orExpression((
expression.isExpression("A", "1", True),
expression.isExpression("B", "2", True),
)),
expression.isExpression("C", "3", True),
"(is(A, 1, True) OR is(B, 2, True) OR is(C, 3, True))"
),
)
for expr1, expr2, result in tests:
self.assertEqual(str(expr1.orWith(expr2)), result, msg="Failed on %s" % (result,))