Support for LIKE operator

customquery/parser.py

@@ -9,6 +9,8 @@ class Parser:
     def __init__(self, model, date_format='%Y-%m-%d'):
         self.model = model
         self.date_format = date_format
+        self.is_startswith = False
+        self.is_endswith = False
 
     def parse(self, query):
         """Parse SQL-like condition statements and return Django Q objects"""
@@ -92,9 +94,10 @@ def _operate(self, a, operator, b):
 
     def _compare(self, subject, operator, predicate):
         # Raise exception if field does not exist
+        value = self._get_value(subject.value, predicate)
         key, cond = self._make_key(operator, subject.value)
         kwargs = {}
-        kwargs[key] = self._get_value(subject.value, predicate)
+        kwargs[key] = value
 
         result = Q(**kwargs)
         if not cond:
@@ -120,11 +123,22 @@ def _get_value(self, key, predicate):
         elif v.startswith('"') and v.endswith('"'):
             v = v[1:-1]
 
+        self.is_startswith = False
+        self.is_endswith = False
+        if v.startswith('%'):
+            self.is_endswith = True
+            v = v[1:]
+        if v.endswith('%'):
+            self.is_startswith = True
+            v = v[:-1]
+
         field = self._get_field(key)
         if isinstance(field, fields.DateField):
             return datetime.strptime(str(v), self.date_format).date()
         if predicate.ttype is t.Token.Literal.Number.Integer:
             return int(v)
+        if predicate.ttype is t.Token.Literal.Number.Float:
+            return float(v)
         if isinstance(predicate, sql.Identifier):
             return predicate.get_name()
         if predicate.ttype is t.Token.Literal.String.Single:
@@ -149,6 +163,22 @@ def _make_key(self, op, key):
             return [key, False]
         if op.value == 'NOT':
             return [key, False]
+        if op.match(comp, 'LIKE'):
+            if self.is_endswith and self.is_startswith:
+                return [key + '__contains', True]
+            if self.is_startswith:
+                return [key + '__startswith', True]
+            if self.is_endswith:
+                return [key + '__endswith', True]
+            return [key + '__contains', True]
+        if op.match(comp, 'NOT LIKE'):
+            if self.is_endswith and self.is_startswith:
+                return [key + '__contains', False]
+            if self.is_startswith:
+                return [key + '__startswith', False]
+            if self.is_endswith:
+                return [key + '__endswith', False]
+            return [key + '__contains', False]
         raise exceptions.UnknownOperator(op.normalized)
 
     def _get_field(self, key):

docs/index.rst

@@ -59,6 +59,10 @@ django-custom-query was created by Luis Fagundes and was sponsored by `Spatial D
 Changelog
 =========
 
+- 0.4.1
+
+  - Support for LIKE operator
+
 - 0.4.0
 
   - Support for IS NULL and IS NOT NULL queries

setup.py

@@ -2,7 +2,7 @@
 import os
 
 setup(name = 'django-custom-query',
-      version = '0.4.0',
+      version = '0.4.1',
       description = 'Custom user query parser for Django ORM',
       long_description = open(os.path.join(os.path.dirname(__file__), "README")).read(),
       author = "Luis Fagundes",

tests/test_parser.py

@@ -17,6 +17,9 @@ class SingleParserTest(BaseTest):
     def test_number(self):
         self.assertEquals(self.parse("numfield=1"), Q(numfield=1))
 
+    def test_number_float(self):
+        self.assertEquals(self.parse("numfield=1.1"), Q(numfield=1.1))
+
     def test_whitespaces_are_ignored(self):
         self.assertEquals(self.parse("numfield = 1"), Q(numfield=1))
         self.assertEquals(self.parse("numfield  = 1"), Q(numfield=1))
@@ -71,6 +74,18 @@ def test_related_field(self):
     def test_related_field_can_be_acessed_with_doc(self):
         self.assertEquals(self.parse('related.name="foo bar"'), Q(related__name="foo bar"))
 
+    def test_like(self):
+        self.assertEquals(self.parse('charfield LIKE "foo"'), Q(charfield__contains="foo"))
+        self.assertEquals(self.parse("charfield LIKE 'foo'"), Q(charfield__contains="foo"))
+        self.assertEquals(self.parse("charfield LIKE '%foo'"), Q(charfield__endswith="foo"))
+        self.assertEquals(self.parse("charfield LIKE 'foo%'"), Q(charfield__startswith="foo"))
+        self.assertEquals(self.parse("charfield LIKE '%foo%'"), Q(charfield__contains="foo"))
+
+        self.assertEquals(self.parse('charfield NOT LIKE "foo"'), ~Q(charfield__contains="foo"))
+        self.assertEquals(self.parse("charfield NOT LIKE 'foo'"), ~Q(charfield__contains="foo"))
+        self.assertEquals(self.parse("charfield NOT LIKE '%foo'"), ~Q(charfield__endswith="foo"))
+        self.assertEquals(self.parse("charfield NOT LIKE 'foo%'"), ~Q(charfield__startswith="foo"))
+        self.assertEquals(self.parse("charfield NOT LIKE '%foo%'"), ~Q(charfield__contains="foo"))
 
 class AnnotationTest(BaseTest):
     def setUp(self):