class Query(object): def __init__(self, provider): error_message = "The provider cannot be None. If you meant to use the CollectionProvider pass in a tuple or list" Guard.against_none(provider, error_message) if isinstance(provider, (list, tuple)): self.provider = CollectionProvider(provider) elif isinstance(provider, (dict,)): self.provider = DictionaryProvider(provider) else: self.provider = provider self.expressions = [] self.order_expressions = [] self.group_expression = None self.parser = ExpressionParser() def where(self, clause): self.expressions.append(self.parser.parse(clause.strip())) return self def group_by(self, *args): for arg in args: self.group_expression = self.parser.parse(arg.strip()) return self def order_by(self, *args): for arg in args: self.order_expressions.append(self.parser.parse(arg.strip())) return self def select(self, *cols): empty_message = "Selecting with no fields is not valid. " \ + "When using From(provider).select method, " \ + "please provide a list of expressions or strings as fields." Guard.against_empty(cols, empty_message) for col in cols: Guard.against_empty(col, empty_message) Guard.accepts_only(cols, [str, Expression], "Selecting with invalid type. " \ + "When using From(provider).select method, " \ + "please provide a list of expressions or strings as fields.") return self.provider.parse(self, action=Actions.Select, cols=cols) def select_many(self): return self.provider.parse(self, action=Actions.SelectMany) def count(self): return self.provider.parse(self, action=Actions.Count) def max(self, column="item"): return self.provider.parse(self, action=Actions.Max, column=column) def min(self, column="item"): return self.provider.parse(self, action=Actions.Min, column=column) def sum(self, column="item"): return self.provider.parse(self, action=Actions.Sum, column=column) def avg(self, column="item"): return self.provider.parse(self, action=Actions.Avg, column=column)
class Query(object): def __init__(self, provider): error_message = "The provider cannot be None. If you meant to use the CollectionProvider pass in a tuple or list" Guard.against_none(provider, error_message) if isinstance(provider, (list, tuple)): self.provider = CollectionProvider(provider) else: self.provider = provider self.expressions = [] self.order_expressions = [] self.group_expression = None self.parser = ExpressionParser() def where(self, clause): self.expressions.append(self.parser.parse(clause.strip())) return self def group_by(self, *args): for arg in args: self.group_expression = self.parser.parse(arg.strip()) return self def order_by(self, *args): for arg in args: self.order_expressions.append(self.parser.parse(arg.strip())) return self def select(self, *cols): empty_message = "Selecting with no fields is not valid. " \ + "When using From(provider).select method, " \ + "please provide a list of expressions or strings as fields." Guard.against_empty(cols, empty_message) for col in cols: Guard.against_empty(col, empty_message) Guard.accepts_only(cols, [str, Expression], "Selecting with invalid type. " \ + "When using From(provider).select method, " \ + "please provide a list of expressions or strings as fields.") return self.provider.parse(self, action=Actions.Select, cols=cols) def select_many(self): return self.provider.parse(self, action=Actions.SelectMany) def count(self): return self.provider.parse(self, action=Actions.Count) def max(self, column="item"): return self.provider.parse(self, action=Actions.Max, column=column) def min(self, column="item"): return self.provider.parse(self, action=Actions.Min, column=column) def sum(self, column="item"): return self.provider.parse(self, action=Actions.Sum, column=column) def avg(self, column="item"): return self.provider.parse(self, action=Actions.Avg, column=column)
def test_advanced_parenthesized_expression(self): expression = "(1 + (2 + 3)) + ((2+3) + 1)" parser = ExpressionParser() tree = parser.parse(expression) expected = "((1 + (2 + 3)) + ((2 + 3) + 1))" assert str(tree) == expected, "The expression was not parsed correctly. Expecting %s, Found %s" % (expected, str(tree))
def test_advanced_parenthesized_expression(self): expression = "(1 + (2 + 3)) + ((2+3) + 1)" parser = ExpressionParser() tree = parser.parse(expression) expected = "((1 + (2 + 3)) + ((2 + 3) + 1))" assert str(tree) == expected, "The expression was not parsed correctly. Expecting %s, Found %s" % ( expected, str(tree), )
def test_basic_parenthesized_expression_returns_constant_expressions_inside_rhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert isinstance(tree.rhs.lhs, ConstantExpression), "The lhs of the rhs should be a ConstantExpression" assert isinstance(tree.rhs.rhs, ConstantExpression), "The rhs of the rhs should be a ConstantExpression"
def test_basic_parenthesized_expression_returns_not_null_expressions_inside_rhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert tree.rhs.lhs is not None, "The lhs of the rhs cannot be null" assert tree.rhs.rhs is not None, "The rhs of the rhs cannot be null"
def test_basic_parenthesized_expression_returns_binary_expression_in_rhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert isinstance(tree.rhs, BinaryExpression), "The rhs should be a BinaryExpression"
def test_basic_parenthesized_expression_returns_proper_value_in_lhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert tree.lhs.value == "1", "The lhs should contain the '1' value"
def test_basic_parenthesized_expression_returns_constant_expression_in_lhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert tree.lhs is not None, "The lhs for the tree cannot be null" assert isinstance(tree.lhs, ConstantExpression), "The lhs should be a constant expression"
def test_basic_parenthesized_expression_returns_binary_expression(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert isinstance(tree, BinaryExpression), "The tree needs to be a binary expression"
def test_basic_parenthesized_expression_returns_proper_values_inside_rhs(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert tree.rhs.lhs.value == "2", "The lhs of the rhs should be 2 but was %s" % tree.rhs.lhs.value assert tree.rhs.rhs.value == "3", "The rhs of the rhs should be 3 but was %s" % tree.rhs.rhs.value
def test_advanced_parenthesized_expression(self): expression = "(1 + 2 + 3) + ((2+3) + 1)" parser = ExpressionParser() tree = parser.parse(expression) assert str(tree) == "(((1 + 2) + 3) + ((2 + 3) + 1))", "The expression was not parsed correctly"
def test_basic_parenthesized_expression_returns_something(self): expression = "1 + (2 + 3)" parser = ExpressionParser() tree = parser.parse(expression) assert tree is not None, "The tree cannot be null after parsing"