Compile all AST elements always via dialects, never directly

The root authority on how to do the SQL syntax properly is the dialect — not the AST element itself. AST tree must only carry the intentions of what we want to execute, but not how it should/could be executed.

This makes the AST truly independent of dialects and databases, allowing us to:
- Focus on the main logic regardless of the SQL capabilities.
- Create custom database connectors without involving AST changes every time.

Before the change, adding a new database connector with unusual syntax would often require changing the AST elements to direct to `compiler.dialect.some_method()` — with only a subset of SQL being described in dialects. The other rather arbitrary part of SQL syntax was hard-coded in AST elements and could not be easily overridden without such changes.

After the change, all the SQL logic is concentrated in one hierarchy of dialects, mostly in one base class.

Author: Sergey Vasilyev

data_diff/abcs/compiler.py

@@ -1,15 +1,9 @@
-from typing import Any, Dict
-from abc import ABC, abstractmethod
+from abc import ABC
 
 
 class AbstractCompiler(ABC):
-    @abstractmethod
-    def compile(self, elem: Any, params: Dict[str, Any] = None) -> str:
-        ...
+    pass
 
 
 class Compilable(ABC):
-    # TODO generic syntax, so we can write Compilable[T] for expressions returning a value of type T
-    @abstractmethod
-    def compile(self, c: AbstractCompiler) -> str:
-        ...
+    pass

data_diff/abcs/database_types.py

@@ -1,11 +1,12 @@
 import decimal
 from abc import ABC, abstractmethod
-from typing import Sequence, Optional, Tuple, Type, Union, Dict, List
+from typing import Sequence, Optional, Tuple, Union, Dict, List
 from datetime import datetime
 
 from runtype import dataclass
 from typing_extensions import Self
 
+from data_diff.abcs.compiler import AbstractCompiler
 from data_diff.utils import ArithAlphanumeric, ArithUUID, Unknown
 
 
@@ -176,6 +177,10 @@ class UnknownColType(ColType):
 class AbstractDialect(ABC):
     """Dialect-dependent query expressions"""
 
+    @abstractmethod
+    def compile(self, compiler: AbstractCompiler, elem, params=None) -> str:
+        raise NotImplementedError
+
     @abstractmethod
     def parse_table_name(self, name: str) -> DbPath:
         "Parse the given table name into a DbPath"

data_diff/bound_exprs.py

@@ -8,7 +8,6 @@
 from typing_extensions import Self
 
 from data_diff.abcs.database_types import AbstractDatabase
-from data_diff.abcs.compiler import AbstractCompiler
 from data_diff.queries.ast_classes import ExprNode, TablePath, Compilable
 from data_diff.queries.api import table
 from data_diff.schema import create_schema
@@ -37,10 +36,6 @@ def query(self, res_type=list):
     def type(self):
         return self.node.type
 
-    def compile(self, c: AbstractCompiler) -> str:
-        assert c.database is self.database
-        return self.node.compile(c)
-
 
 def bind_node(node, database):
     return BoundNode(database, node)