Queries: Ran black

Author: erezsh

data_diff/queries/api.py

@@ -15,10 +15,12 @@ def leftjoin(*tables: ITable):
     "Left-joins each table into a 'struct'"
     return Join(tables, "LEFT")
 
+
 def rightjoin(*tables: ITable):
     "Right-joins each table into a 'struct'"
     return Join(tables, "RIGHT")
 
+
 def outerjoin(*tables: ITable):
     "Outer-joins each table into a 'struct'"
     return Join(tables, "FULL OUTER")

data_diff/queries/ast_classes.py

@@ -10,7 +10,6 @@
 from .base import SKIP, CompileError, DbPath, Schema, args_as_tuple
 
 
-
 class ExprNode(Compilable):
     type: Any = None
 
@@ -129,7 +128,7 @@ def __getitem__(self, column):
     def count(self):
         return Select(self, [Count()])
 
-    def union(self, other: 'ITable'):
+    def union(self, other: "ITable"):
         return Union(self, other)
 
 
@@ -172,11 +171,13 @@ def compile(self, c: Compiler) -> str:
         args = ", ".join(c.compile(e) for e in self.args)
         return f"{self.name}({args})"
 
+
 def _expr_type(e: Expr):
     if isinstance(e, ExprNode):
         return e.type
     return type(e)
 
+
 @dataclass
 class CaseWhen(ExprNode):
     cases: Sequence[Tuple[Expr, Expr]]
@@ -190,12 +191,12 @@ def compile(self, c: Compiler) -> str:
 
     @property
     def type(self):
-        when_types = {_expr_type(w) for _c,w in self.cases }
+        when_types = {_expr_type(w) for _c, w in self.cases}
         if self.else_:
             when_types |= _expr_type(self.else_)
         if len(when_types) > 1:
             raise RuntimeError(f"Non-matching types in when: {when_types}")
-        t ,= when_types
+        (t,) = when_types
         return t
 
 
@@ -252,6 +253,7 @@ def compile(self, c: Compiler) -> str:
         a, b = self.args
         return f"({c.compile(a)} {self.op} {c.compile(b)})"
 
+
 class BinBoolOp(BinOp):
     type = bool
 
@@ -334,8 +336,8 @@ def source_table(self):
 
     @property
     def schema(self):
-        assert self.columns # TODO Implement SELECT *
-        s = self.source_tables[0].schema    # XXX
+        assert self.columns  # TODO Implement SELECT *
+        s = self.source_tables[0].schema  # XXX
         return type(s)({c.name: c.type for c in self.columns})
 
     def on(self, *exprs):
@@ -390,6 +392,7 @@ class GroupBy(ITable):
     def having(self):
         pass
 
+
 @dataclass
 class Union(ExprNode, ITable):
     table1: ITable
@@ -441,7 +444,7 @@ def source_table(self):
         return self
 
     def compile(self, parent_c: Compiler) -> str:
-        c = parent_c.replace(in_select=True) #.add_table_context(self.table)
+        c = parent_c.replace(in_select=True)  # .add_table_context(self.table)
 
         columns = ", ".join(map(c.compile, self.columns)) if self.columns else "*"
         select = f"SELECT {columns}"
@@ -547,7 +550,6 @@ def name(self):
         return self.resolved.name
 
 
-
 class This:
     def __getattr__(self, name):
         return _ResolveColumn(name)
@@ -593,9 +595,11 @@ def compile(self, c: Compiler) -> str:
 
 # DDL
 
+
 class Statement(Compilable):
     type = None
 
+
 def to_sql_type(t):
     if isinstance(t, str):
         return t
@@ -612,18 +616,20 @@ class CreateTable(Statement):
     if_not_exists: bool = False
 
     def compile(self, c: Compiler) -> str:
-        schema = ', '.join(f'{k} {to_sql_type(v)}' for k, v in self.path.schema.items())
-        ne = 'IF NOT EXISTS ' if self.if_not_exists else ''
-        return f'CREATE TABLE {ne}{c.compile(self.path)}({schema})'
+        schema = ", ".join(f"{k} {to_sql_type(v)}" for k, v in self.path.schema.items())
+        ne = "IF NOT EXISTS " if self.if_not_exists else ""
+        return f"CREATE TABLE {ne}{c.compile(self.path)}({schema})"
+
 
 @dataclass
 class DropTable(Statement):
     path: TablePath
     if_exists: bool = False
 
     def compile(self, c: Compiler) -> str:
-        ie = 'IF EXISTS ' if self.if_exists else ''
-        return f'DROP TABLE {ie}{c.compile(self.path)}'
+        ie = "IF EXISTS " if self.if_exists else ""
+        return f"DROP TABLE {ie}{c.compile(self.path)}"
+
 
 @dataclass
 class InsertToTable(Statement):
@@ -632,4 +638,4 @@ class InsertToTable(Statement):
     expr: Expr
 
     def compile(self, c: Compiler) -> str:
-        return f'INSERT INTO {c.compile(self.path)} {c.compile(self.expr)}'
+        return f"INSERT INTO {c.compile(self.path)} {c.compile(self.expr)}"

data_diff/queries/compiler.py

@@ -13,7 +13,7 @@
 class Compiler:
     database: AbstractDialect
     in_select: bool = False  # Compilation runtime flag
-    in_join: bool = False    # Compilation runtime flag
+    in_join: bool = False  # Compilation runtime flag
 
     _table_context: List = []  # List[ITable]
     _subqueries: Dict[str, Any] = {}  # XXX not thread-safe
@@ -32,7 +32,7 @@ def compile(self, elem) -> str:
             return f"WITH {subq}\n{res}"
         return res
 
-    def _compile(self, elem) -> Union[str, 'ThreadLocalInterpreter']:
+    def _compile(self, elem) -> Union[str, "ThreadLocalInterpreter"]:
         if elem is None:
             return "NULL"
         elif isinstance(elem, Compilable):

tests/test_query.py

@@ -93,12 +93,12 @@ def test_schema(self):
         self.assertRaises(KeyError, q.__getitem__, "comment")
 
         # test join
-        s = CaseInsensitiveDict({'x': int, 'y': int})
+        s = CaseInsensitiveDict({"x": int, "y": int})
         a = table("a", schema=s)
         b = table("b", schema=s)
         keys = ["x", "y"]
-        j = outerjoin(a, b).on(a[k] == b[k] for k in keys).select(a['x'], b['y'], xsum=a['x'] + b['x'])
-        j['x'], j['y'], j['xsum']
+        j = outerjoin(a, b).on(a[k] == b[k] for k in keys).select(a["x"], b["y"], xsum=a["x"] + b["x"])
+        j["x"], j["y"], j["xsum"]
         self.assertRaises(KeyError, j.__getitem__, "ysum")
 
     def test_commutable_select(self):
@@ -145,8 +145,8 @@ def test_funcs(self):
 
     def test_union_all(self):
         c = Compiler(MockDialect())
-        a = table("a").select('x')
-        b = table("b").select('y')
+        a = table("a").select("x")
+        b = table("b").select("y")
 
         q = c.compile(a.union(b))
         assert q == "SELECT x FROM a UNION SELECT y FROM b"