Remove unused code: time travelling

Author: Sergey Vasilyev

data_diff/abcs/mixins.py

@@ -141,29 +141,6 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         """
 
 
-@attrs.define(frozen=False)
-class AbstractMixin_TimeTravel(AbstractMixin):
-    @abstractmethod
-    def time_travel(
-        self,
-        table: Compilable,
-        before: bool = False,
-        timestamp: Compilable = None,
-        offset: Compilable = None,
-        statement: Compilable = None,
-    ) -> Compilable:
-        """Selects historical data from a table
-
-        Parameters:
-            table - The name of the table whose history we're querying
-            timestamp - A constant timestamp
-            offset - the time 'offset' seconds before now
-            statement - identifier for statement, e.g. query ID
-
-        Must specify exactly one of `timestamp`, `offset` or `statement`.
-        """
-
-
 @attrs.define(frozen=False)
 class AbstractMixin_OptimizerHints(AbstractMixin):
     @abstractmethod

data_diff/databases/base.py

@@ -48,7 +48,6 @@
     TableAlias,
     TableOp,
     TablePath,
-    TimeTravel,
     TruncateTable,
     UnaryOp,
     WhenThen,
@@ -74,7 +73,7 @@
     Boolean,
     JSON,
 )
-from data_diff.abcs.mixins import AbstractMixin_TimeTravel, Compilable
+from data_diff.abcs.mixins import Compilable
 from data_diff.abcs.mixins import (
     AbstractMixin_Schema,
     AbstractMixin_NormalizeValue,
@@ -327,8 +326,6 @@ def render_compilable(self, c: Compiler, elem: Compilable) -> str:
             return self.render_explain(c, elem)
         elif isinstance(elem, CurrentTimestamp):
             return self.render_currenttimestamp(c, elem)
-        elif isinstance(elem, TimeTravel):
-            return self.render_timetravel(c, elem)
         elif isinstance(elem, CreateTable):
             return self.render_createtable(c, elem)
         elif isinstance(elem, DropTable):
@@ -605,16 +602,6 @@ def render_explain(self, c: Compiler, elem: Explain) -> str:
     def render_currenttimestamp(self, c: Compiler, elem: CurrentTimestamp) -> str:
         return self.current_timestamp()
 
-    def render_timetravel(self, c: Compiler, elem: TimeTravel) -> str:
-        assert isinstance(c, AbstractMixin_TimeTravel)
-        return self.compile(
-            c,
-            # TODO: why is it c.? why not self? time-trvelling is the dialect's thing, isnt't it?
-            c.time_travel(
-                elem.table, before=elem.before, timestamp=elem.timestamp, offset=elem.offset, statement=elem.statement
-            ),
-        )
-
     def render_createtable(self, c: Compiler, elem: CreateTable) -> str:
         ne = "IF NOT EXISTS " if elem.if_not_exists else ""
         if elem.source_table:

data_diff/databases/bigquery.py

@@ -24,7 +24,6 @@
     AbstractMixin_MD5,
     AbstractMixin_NormalizeValue,
     AbstractMixin_Schema,
-    AbstractMixin_TimeTravel,
 )
 from data_diff.abcs.compiler import Compilable
 from data_diff.queries.api import this, table, SKIP, code
@@ -63,9 +62,7 @@ def import_bigquery_service_account_impersonation():
 
 
 @attrs.define(frozen=False)
-class Dialect(
-    BaseDialect, AbstractMixin_Schema, AbstractMixin_MD5, AbstractMixin_NormalizeValue, AbstractMixin_TimeTravel
-):
+class Dialect(BaseDialect, AbstractMixin_Schema, AbstractMixin_MD5, AbstractMixin_NormalizeValue):
     name = "BigQuery"
     ROUNDS_ON_PREC_LOSS = False  # Technically BigQuery doesn't allow implicit rounding or truncation
     TYPE_CLASSES = {
@@ -197,31 +194,6 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
             .select(this.table_name)
         )
 
-    def time_travel(
-        self,
-        table: Compilable,
-        before: bool = False,
-        timestamp: Compilable = None,
-        offset: Compilable = None,
-        statement: Compilable = None,
-    ) -> Compilable:
-        if before:
-            raise NotImplementedError("before=True not supported for BigQuery time-travel")
-
-        if statement is not None:
-            raise NotImplementedError("BigQuery time-travel doesn't support querying by statement id")
-
-        if timestamp is not None:
-            assert offset is None
-            return code("{table} FOR SYSTEM_TIME AS OF {timestamp}", table=table, timestamp=timestamp)
-
-        assert offset is not None
-        return code(
-            "{table} FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL {offset} HOUR);",
-            table=table,
-            offset=offset,
-        )
-
 
 @attrs.define(frozen=False, init=False, kw_only=True)
 class BigQuery(Database):

data_diff/databases/snowflake.py

@@ -19,7 +19,6 @@
     AbstractMixin_MD5,
     AbstractMixin_NormalizeValue,
     AbstractMixin_Schema,
-    AbstractMixin_TimeTravel,
 )
 from data_diff.abcs.compiler import Compilable
 from data_diff.queries.api import table, this, SKIP, code
@@ -43,9 +42,7 @@ def import_snowflake():
     return snowflake, serialization, default_backend
 
 
-class Dialect(
-    BaseDialect, AbstractMixin_Schema, AbstractMixin_MD5, AbstractMixin_NormalizeValue, AbstractMixin_TimeTravel
-):
+class Dialect(BaseDialect, AbstractMixin_Schema, AbstractMixin_MD5, AbstractMixin_NormalizeValue):
     name = "Snowflake"
     ROUNDS_ON_PREC_LOSS = False
     TYPE_CLASSES = {
@@ -117,30 +114,6 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
             .select(table_name=this.TABLE_NAME)
         )
 
-    def time_travel(
-        self,
-        table: Compilable,
-        before: bool = False,
-        timestamp: Compilable = None,
-        offset: Compilable = None,
-        statement: Compilable = None,
-    ) -> Compilable:
-        at_or_before = "AT" if before else "BEFORE"
-        if timestamp is not None:
-            assert offset is None and statement is None
-            key = "timestamp"
-            value = timestamp
-        elif offset is not None:
-            assert statement is None
-            key = "offset"
-            value = offset
-        else:
-            assert statement is not None
-            key = "statement"
-            value = statement
-
-        return code(f"{{table}} {at_or_before}({key} => {{value}})", table=table, value=value)
-
 
 @attrs.define(frozen=False, init=False, kw_only=True)
 class Snowflake(Database):

data_diff/queries/ast_classes.py

@@ -457,26 +457,6 @@ def insert_expr(self, expr: Expr):
             expr = expr.select()
         return InsertToTable(self, expr)
 
-    def time_travel(
-        self, *, before: bool = False, timestamp: datetime = None, offset: int = None, statement: str = None
-    ) -> Compilable:
-        """Selects historical data from the table
-
-        Parameters:
-            before: If false, inclusive of the specified point in time.
-                     If True, only return the time before it. (at/before)
-            timestamp: A constant timestamp
-            offset: the time 'offset' seconds before now
-            statement: identifier for statement, e.g. query ID
-
-        Must specify exactly one of `timestamp`, `offset` or `statement`.
-        """
-        if sum(int(i is not None) for i in (timestamp, offset, statement)) != 1:
-            raise ValueError("Must specify exactly one of `timestamp`, `offset` or `statement`.")
-
-        if timestamp is not None:
-            assert offset is None and statement is None
-
 
 @attrs.define(frozen=True, eq=False)
 class TableAlias(ExprNode, ITable):
@@ -752,15 +732,6 @@ def type(self) -> Optional[type]:
         return datetime
 
 
-@attrs.define(frozen=True, eq=False)
-class TimeTravel(ITable):  # TODO: Unused?
-    table: TablePath
-    before: bool = False
-    timestamp: Optional[datetime] = None
-    offset: Optional[int] = None
-    statement: Optional[str] = None
-
-
 # DDL