Merge lp:~jamesh/storm/bug-387840 into lp:storm

[James Henstridge]

[James Henstridge (jamesh)]

Add some string manipulation methods to Comparable implemented in terms of the LIKE operator:
 * startswith(): same semantics as unicode.startswith()
 * endswith(): same semantics as unicode.endswith()
 * containsstring(): same semantics as unicode.__contains__()

Each method performs escaping of SQL regexp special characters.

I didn't know whether adding a string-specific __contains__() method to Comparable would be appropriate, which is why the last method has the name containsstring(). I'd be happy to change that if anyone has a suggestion (either a new name, or __contains__ if that is appropriate).

[Jamu Kakar (jkakar)]

Nice branch! I'm not sure about __contains__ either. I like contains_string anyway, because it's obvious. +1!

review: Approve

[John O'Brien (jdobrien)]

This works great and it's something i could really use right now!

review: Approve

[lp:~jamesh/storm/bug-387840]

333. By James Henstridge on 2009-11-02

merge from trunk

334. By James Henstridge on 2009-11-02

Add NEWS file entry.

=== modified file 'NEWS'
--- NEWS	2009-10-23 19:19:16 +0000
+++ NEWS	2009-11-02 11:51:52 +0000
@@ -7,6 +7,10 @@
    if it is of the same type.  The resulting expression tree uses less
    stack when compiling so reduces the chance of hitting Python's
    recursion limit (bug #242813).
+ - Add startswith(), endswith() and contains_string() methods to
+   Comparable.  These methods perform prefix, suffix and substring
+   checks respectively using the LIKE operator, taking care of escaping
+   for you (bug #387840).
 
 Bug fixes
 ---------

=== modified file 'storm/expr.py'
--- storm/expr.py	2009-10-21 09:44:32 +0000
+++ storm/expr.py	2009-11-02 11:51:52 +0000
@@ -395,6 +395,15 @@
     raise CompileError("Can't compile python expressions with %r" % type(expr))
 
 
+# A translation table that can escape a unicode string for use in a
+# Like() expression that uses "!" as the escape character.
+like_escape = {
+    ord(u"!"): u"!!",
+    ord(u"_"): u"!_",
+    ord(u"%"): u"!%"
+    }
+
+
 class Comparable(object):
     __slots__ = ()
 
@@ -498,6 +507,24 @@
     def upper(self):
         return Upper(self)
 
+    def startswith(self, prefix):
+        if not isinstance(prefix, unicode):
+            raise ExprError("Expected unicode argument, got %r" % type(prefix))
+        pattern = prefix.translate(like_escape) + u"%"
+        return Like(self, pattern, u"!")
+
+    def endswith(self, suffix):
+        if not isinstance(suffix, unicode):
+            raise ExprError("Expected unicode argument, got %r" % type(suffix))
+        pattern = u"%" + suffix.translate(like_escape)
+        return Like(self, pattern, u"!")
+
+    def contains_string(self, substring):
+        if not isinstance(substring, unicode):
+            raise ExprError("Expected unicode argument, got %r" % type(substring))
+        pattern = u"%" + substring.translate(like_escape) + u"%"
+        return Like(self, pattern, u"!")
+
 
 class ComparableExpr(Expr, Comparable):
     __slots__ = ()

=== modified file 'tests/databases/base.py'
--- tests/databases/base.py	2009-07-30 06:19:27 +0000
+++ tests/databases/base.py	2009-11-02 11:51:52 +0000
@@ -395,6 +395,33 @@
             "UPDATE test SET title='whatever'")
         self.assertEquals(result.rowcount, 2)
 
+    def test_expr_startswith(self):
+        self.connection.execute("INSERT INTO test VALUES (30, '!!_%blah')")
+        self.connection.execute("INSERT INTO test VALUES (40, '!!blah')")
+        id = Column("id", SQLToken("test"))
+        title = Column("title", SQLToken("test"))
+        expr = Select(id, title.startswith(u"!!_%"))
+        result = list(self.connection.execute(expr))
+        self.assertEquals(result, [(30,)])
+
+    def test_expr_endswith(self):
+        self.connection.execute("INSERT INTO test VALUES (30, 'blah_%!!')")
+        self.connection.execute("INSERT INTO test VALUES (40, 'blah!!')")
+        id = Column("id", SQLToken("test"))
+        title = Column("title", SQLToken("test"))
+        expr = Select(id, title.endswith(u"_%!!"))
+        result = list(self.connection.execute(expr))
+        self.assertEquals(result, [(30,)])
+
+    def test_expr_contains_string(self):
+        self.connection.execute("INSERT INTO test VALUES (30, 'blah_%!!x')")
+        self.connection.execute("INSERT INTO test VALUES (40, 'blah!!x')")
+        id = Column("id", SQLToken("test"))
+        title = Column("title", SQLToken("test"))
+        expr = Select(id, title.contains_string(u"_%!!"))
+        result = list(self.connection.execute(expr))
+        self.assertEquals(result, [(30,)])
+
 
 class UnsupportedDatabaseTest(object):
     

=== modified file 'tests/expr.py'
--- tests/expr.py	2009-10-21 09:44:32 +0000
+++ tests/expr.py	2009-11-02 11:51:52 +0000
@@ -184,6 +184,37 @@
         expr = Like(elem1, elem2, elem3, False)
         self.assertEquals(expr.case_sensitive, False)
 
+    def test_startswith(self):
+        expr = Func1()
+        self.assertRaises(ExprError, expr.startswith, "not a unicode string")
+
+        like_expr = expr.startswith(u"abc!!_%")
+        self.assertTrue(isinstance(like_expr, Like))
+        self.assertTrue(like_expr.expr1 is expr)
+        self.assertEquals(like_expr.expr2, u"abc!!!!!_!%%")
+        self.assertEquals(like_expr.escape, u"!")
+
+    def test_endswith(self):
+        expr = Func1()
+        self.assertRaises(ExprError, expr.startswith, "not a unicode string")
+
+        like_expr = expr.endswith(u"abc!!_%")
+        self.assertTrue(isinstance(like_expr, Like))
+        self.assertTrue(like_expr.expr1 is expr)
+        self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%")
+        self.assertEquals(like_expr.escape, u"!")
+
+    def test_contains_string(self):
+        expr = Func1()
+        self.assertRaises(
+            ExprError, expr.contains_string, "not a unicode string")
+
+        like_expr = expr.contains_string(u"abc!!_%")
+        self.assertTrue(isinstance(like_expr, Like))
+        self.assertTrue(like_expr.expr1 is expr)
+        self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%%")
+        self.assertEquals(like_expr.escape, u"!")
+
     def test_eq(self):
         expr = Eq(elem1, elem2)
         self.assertEquals(expr.expr1, elem1)