Queries: Added LIKE

data_diff/sqeleton/databases/base.py

@@ -287,8 +287,7 @@ def enable_interactive(self):
         self._interactive = True
 
     def select_table_schema(self, path: DbPath) -> str:
-        """Provide SQL for selecting the table schema as (name, type, date_prec, num_prec)
-        """
+        """Provide SQL for selecting the table schema as (name, type, date_prec, num_prec)"""
         schema, table = self._normalize_table_path(path)
 
         return (

data_diff/sqeleton/queries/ast_classes.py

@@ -228,6 +228,9 @@ def __and__(self, other):
     def is_distinct_from(self, other):
         return IsDistinctFrom(self, other)
 
+    def like(self, other):
+        return BinBoolOp("LIKE", [self, other])
+
     def sum(self):
         return Func("SUM", [self])
 
@@ -493,34 +496,33 @@ def compile(self, parent_c: Compiler) -> str:
 
     @classmethod
     def make(cls, table: ITable, distinct: bool = SKIP, **kwargs):
-        assert 'table' not in kwargs
+        assert "table" not in kwargs
 
         if not isinstance(table, cls):  # If not Select
             if distinct is not SKIP:
-                kwargs['distinct'] = distinct
+                kwargs["distinct"] = distinct
             return cls(table, **kwargs)
 
         # We can safely assume isinstance(table, Select)
 
         if distinct is not SKIP:
             if distinct == False and table.distinct:
                 return cls(table, **kwargs)
-            kwargs['distinct'] = distinct
+            kwargs["distinct"] = distinct
 
         if table.limit_expr or table.group_by_exprs:
             return cls(table, **kwargs)
 
         # Fill in missing attributes, instead of creating a new instance.
         for k, v in kwargs.items():
             if getattr(table, k) is not None:
-                if k == 'where_exprs':  # Additive attribute
+                if k == "where_exprs":  # Additive attribute
                     kwargs[k] = getattr(table, k) + v
-                elif k == 'distinct':
+                elif k == "distinct":
                     pass
                 else:
                     raise ValueError(k)
 
-
         return table.replace(**kwargs)
 
 

data_diff/sqeleton/utils.py

@@ -8,6 +8,7 @@
 
 # -- Common --
 
+
 def join_iter(joiner: Any, iterable: Iterable) -> Iterable:
     it = iter(iterable)
     try:
@@ -35,7 +36,6 @@ def is_uuid(u):
     return True
 
 
-
 def match_regexps(regexps: Dict[str, Any], s: str) -> Sequence[tuple]:
     for regexp, v in regexps.items():
         m = re.match(regexp + "$", s)
@@ -47,6 +47,7 @@ def match_regexps(regexps: Dict[str, Any], s: str) -> Sequence[tuple]:
 
 V = TypeVar("V")
 
+
 class CaseAwareMapping(MutableMapping[str, V]):
     @abstractmethod
     def get_key(self, key: str) -> str:

tests/test_query.py

@@ -181,7 +181,7 @@ def test_select_distinct(self):
         assert q == "SELECT DISTINCT b FROM a"
 
         # selects merge
-        q = c.compile(t.where(this.b>10).select(this.b, distinct=True))
+        q = c.compile(t.where(this.b > 10).select(this.b, distinct=True))
         self.assertEqual(q, "SELECT DISTINCT b FROM a WHERE (b > 10)")
 
         # selects stay apart
@@ -198,3 +198,13 @@ def test_union(self):
 
         q = c.compile(a.union(b))
         assert q == "SELECT x FROM a UNION SELECT y FROM b"
+
+    def test_ops(self):
+        c = Compiler(MockDatabase())
+        t = table("a")
+
+        q = c.compile(t.select(this.b + this.c))
+        self.assertEqual(q, "SELECT (b + c) FROM a")
+
+        q = c.compile(t.select(this.b.like(this.c)))
+        self.assertEqual(q, "SELECT (b LIKE c) FROM a")