expr.py

Python的一个ORM,现在很火

                          "UPDATE func2() SET column1=elem1 WHERE func1()")
        self.assertEquals(parameters, [])

    def test_update_auto_table(self):
        expr = Update({Column(column1, table1): elem1})
        statement, parameters = compile(expr)
        self.assertEquals(statement, "UPDATE table1 SET column1=elem1")
        self.assertEquals(parameters, [])

    def test_update_auto_table_default(self):
        expr = Update({Column(column1): elem1}, default_table=table1)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "UPDATE table1 SET column1=elem1")
        self.assertEquals(parameters, [])

    def test_update_auto_table_unknown(self):
        expr = Update({Column(column1): elem1})
        self.assertRaises(CompileError, compile, expr)

    def test_update_with_strings(self):
        expr = Update({column1: elem1}, "1 = 2", table1)
        statement, parameters = compile(expr)
        self.assertEquals(statement,
                          "UPDATE table1 SET column1=elem1 WHERE 1 = 2")
        self.assertEquals(parameters, [])

    def test_update_contexts(self):
        set_left, set_right, where, table = track_contexts(4)
        expr = Update({set_left: set_right}, where, table)
        compile(expr)
        self.assertEquals(set_left.context, COLUMN_NAME)
        self.assertEquals(set_right.context, COLUMN_NAME)
        self.assertEquals(where.context, EXPR)
        self.assertEquals(table.context, TABLE)

    def test_delete(self):
        expr = Delete(table=Func1())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "DELETE FROM func1()")
        self.assertEquals(parameters, [])

    def test_delete_where(self):
        expr = Delete(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "DELETE FROM func2() WHERE func1()")
        self.assertEquals(parameters, [])

    def test_delete_with_strings(self):
        expr = Delete("1 = 2", table1)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "DELETE FROM table1 WHERE 1 = 2")
        self.assertEquals(parameters, [])

    def test_delete_auto_table(self):
        expr = Delete(Column(column1, table1) == 1)
        statement, parameters = compile(expr)
        self.assertEquals(statement,
                          "DELETE FROM table1 WHERE table1.column1 = ?")
        self.assertEquals(parameters, [Variable(1)])

    def test_delete_auto_table_default(self):
        expr = Delete(Column(column1) == 1, default_table=table1)
        statement, parameters = compile(expr)
        self.assertEquals(statement,
                          "DELETE FROM table1 WHERE column1 = ?")
        self.assertEquals(parameters, [Variable(1)])

    def test_delete_auto_table_unknown(self):
        expr = Delete(Column(column1) == 1)
        self.assertRaises(NoTableError, compile, expr)

    def test_delete_contexts(self):
        where, table = track_contexts(2)
        expr = Delete(where, table)
        compile(expr)
        self.assertEquals(where.context, EXPR)
        self.assertEquals(table.context, TABLE)

    def test_column(self):
        expr = Column(column1)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "column1")
        self.assertEquals(parameters, [])

    def test_column_table(self):
        expr = Select(Column(column1, Func1()))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "SELECT func1().column1 FROM func1()")
        self.assertEquals(parameters, [])

    def test_column_contexts(self):
        table, = track_contexts(1)
        expr = Column(column1, table)
        compile(expr)
        self.assertEquals(table.context, COLUMN_PREFIX)

    def test_variable(self):
        expr = Variable("value")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "?")
        self.assertEquals(parameters, [Variable("value")])

    def test_eq(self):
        expr = Eq(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() = func2()")
        self.assertEquals(parameters, [])

        expr = Func1() == "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() = ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_is_in(self):
        expr = Func1().is_in(["Hello", "World"])
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IN (?, ?)")
        self.assertEquals(parameters, [Variable("Hello"), Variable("World")])

    def test_is_in_empty(self):
        expr = Func1().is_in([])
        statement, parameters = compile(expr)
        self.assertEquals(statement, "NULL")
        self.assertEquals(parameters, [])

    def test_is_in_expr(self):
        expr = Func1().is_in(Select(column1))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IN (SELECT column1)")
        self.assertEquals(parameters, [])

    def test_eq_none(self):
        expr = Func1() == None

        self.assertTrue(expr.expr2 is None)

        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IS NULL")
        self.assertEquals(parameters, [])

    def test_ne(self):
        expr = Ne(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() != func2()")
        self.assertEquals(parameters, [])

        expr = Func1() != "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() != ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_ne_none(self):
        expr = Func1() != None

        self.assertTrue(expr.expr2 is None)

        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IS NOT NULL")
        self.assertEquals(parameters, [])

    def test_gt(self):
        expr = Gt(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() > func2()")
        self.assertEquals(parameters, [])

        expr = Func1() > "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() > ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_ge(self):
        expr = Ge(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() >= func2()")
        self.assertEquals(parameters, [])

        expr = Func1() >= "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() >= ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_lt(self):
        expr = Lt(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() < func2()")
        self.assertEquals(parameters, [])

        expr = Func1() < "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() < ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_le(self):
        expr = Le(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() <= func2()")
        self.assertEquals(parameters, [])

        expr = Func1() <= "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() <= ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_lshift(self):
        expr = LShift(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()<<func2()")
        self.assertEquals(parameters, [])

        expr = Func1() << "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()<<?")
        self.assertEquals(parameters, [Variable("value")])

    def test_rshift(self):
        expr = RShift(Func1(), Func2())
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()>>func2()")
        self.assertEquals(parameters, [])

        expr = Func1() >> "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()>>?")
        self.assertEquals(parameters, [Variable("value")])

    def test_like(self):
        expr = Like(Func1(), "value")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() LIKE ?")
        self.assertEquals(parameters, [CharsVariable("value")])

        expr = Func1().like("Hello")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() LIKE ?")
        self.assertEquals(parameters, [Variable("Hello")])

    def test_like_escape(self):
        expr = Like(Func1(), "value", "!")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() LIKE ? ESCAPE ?")
        self.assertEquals(parameters,
                          [CharsVariable("value"), CharsVariable("!")])

        expr = Func1().like("Hello", "!")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() LIKE ? ESCAPE ?")
        self.assertEquals(parameters, [Variable("Hello"), CharsVariable("!")])

    def test_in(self):
        expr = In(Func1(), "value")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IN (?)")
        self.assertEquals(parameters, [CharsVariable("value")])

        expr = In(Func1(), elem1)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() IN (elem1)")
        self.assertEquals(parameters, [])

    def test_and(self):
        expr = And(elem1, elem2, And(elem3, elem4))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1 AND elem2 AND elem3 AND elem4")
        self.assertEquals(parameters, [])

        expr = Func1() & "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() AND ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_or(self):
        expr = Or(elem1, elem2, Or(elem3, elem4))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1 OR elem2 OR elem3 OR elem4")
        self.assertEquals(parameters, [])

        expr = Func1() | "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1() OR ?")
        self.assertEquals(parameters, [Variable("value")])

    def test_and_with_strings(self):
        expr = And("elem1", "elem2")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1 AND elem2")
        self.assertEquals(parameters, [])

    def test_or_with_strings(self):
        expr = Or("elem1", "elem2")
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1 OR elem2")
        self.assertEquals(parameters, [])

    def test_add(self):
        expr = Add(elem1, elem2, Add(elem3, elem4))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1+elem2+elem3+elem4")
        self.assertEquals(parameters, [])

        expr = Func1() + "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()+?")
        self.assertEquals(parameters, [Variable("value")])

    def test_sub(self):
        expr = Sub(elem1, Sub(elem2, elem3))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1-(elem2-elem3)")
        self.assertEquals(parameters, [])

        expr = Sub(Sub(elem1, elem2), elem3)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1-elem2-elem3")
        self.assertEquals(parameters, [])

        expr = Func1() - "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()-?")
        self.assertEquals(parameters, [Variable("value")])

    def test_mul(self):
        expr = Mul(elem1, elem2, Mul(elem3, elem4))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1*elem2*elem3*elem4")
        self.assertEquals(parameters, [])

        expr = Func1() * "value"
        statement, parameters = compile(expr)
        self.assertEquals(statement, "func1()*?")
        self.assertEquals(parameters, [Variable("value")])

    def test_div(self):
        expr = Div(elem1, Div(elem2, elem3))
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1/(elem2/elem3)")
        self.assertEquals(parameters, [])

        expr = Div(Div(elem1, elem2), elem3)
        statement, parameters = compile(expr)
        self.assertEquals(statement, "elem1/elem2/elem3")