sqlglot 27.28.1__tar.gz → 27.29.0__tar.gz

{sqlglot-27.28.1 → sqlglot-27.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.28.1
+Version: 27.29.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/__init__.py

@@ -29,6 +29,7 @@ from sqlglot.expressions import (
     condition as condition,
     delete as delete,
     except_ as except_,
+    find_tables as find_tables,
     from_ as from_,
     func as func,
     insert as insert,

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.28.1'
-__version_tuple__ = version_tuple = (27, 28, 1)
+__version__ = version = '27.29.0'
+__version_tuple__ = version_tuple = (27, 29, 0)
 
-__commit_id__ = commit_id = 'g0c5387499'
+__commit_id__ = commit_id = 'g7f550f22d'

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/bigquery.py

@@ -508,6 +508,7 @@ class BigQuery(Dialect):
             exp.FarmFingerprint,
             exp.Grouping,
             exp.LaxInt64,
+            exp.Length,
             exp.Ntile,
             exp.Rank,
             exp.RangeBucket,

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/dialect.py

@@ -44,9 +44,11 @@ DATETIME_DELTA = t.Union[
     exp.DatetimeSub,
     exp.TimeAdd,
     exp.TimeSub,
+    exp.TimestampAdd,
     exp.TimestampSub,
     exp.TsOrDsAdd,
 ]
+DATETIME_ADD = (exp.DateAdd, exp.TimeAdd, exp.DatetimeAdd, exp.TsOrDsAdd, exp.TimestampAdd)
 
 if t.TYPE_CHECKING:
     from sqlglot._typing import B, E, F
@@ -539,6 +541,10 @@ class Dialect(metaclass=_Dialect):
     # STRING type (Snowflake's case) or can be of any type
     TRY_CAST_REQUIRES_STRING: t.Optional[bool] = None
 
+    # Whether the double negation can be applied
+    # Not safe with MySQL and SQLite due to type coercion (may not return boolean)
+    SAFE_TO_ELIMINATE_DOUBLE_NEGATION = True
+
     # --- Autofilled ---
 
     tokenizer_class = Tokenizer
@@ -765,8 +771,12 @@ class Dialect(metaclass=_Dialect):
             exp.TimeAdd,
             exp.TimeSub,
         },
+        exp.DataType.Type.TIMESTAMPLTZ: {
+            exp.TimestampLtzFromParts,
+        },
         exp.DataType.Type.TIMESTAMPTZ: {
             exp.CurrentTimestampLTZ,
+            exp.TimestampTzFromParts,
         },
         exp.DataType.Type.TIMESTAMP: {
             exp.CurrentTimestamp,
@@ -778,10 +788,17 @@ class Dialect(metaclass=_Dialect):
         },
         exp.DataType.Type.TINYINT: {
             exp.Day,
-            exp.Month,
+            exp.DayOfWeek,
+            exp.DayOfWeekIso,
+            exp.DayOfMonth,
+            exp.DayOfYear,
             exp.Week,
-            exp.Year,
+            exp.WeekOfYear,
+            exp.Month,
             exp.Quarter,
+            exp.Year,
+            exp.YearOfWeek,
+            exp.YearOfWeekIso,
         },
         exp.DataType.Type.VARCHAR: {
             exp.ArrayConcat,
@@ -1682,11 +1699,7 @@ def date_delta_to_binary_interval_op(
     def date_delta_to_binary_interval_op_sql(self: Generator, expression: DATETIME_DELTA) -> str:
         this = expression.this
         unit = unit_to_var(expression)
-        op = (
-            "+"
-            if isinstance(expression, (exp.DateAdd, exp.TimeAdd, exp.DatetimeAdd, exp.TsOrDsAdd))
-            else "-"
-        )
+        op = "+" if isinstance(expression, DATETIME_ADD) else "-"
 
         to_type: t.Optional[exp.DATA_TYPE] = None
         if cast:
@@ -1965,6 +1978,15 @@ def sequence_sql(self: Generator, expression: exp.GenerateSeries | exp.GenerateD
     return self.func("SEQUENCE", start, end, step)
 
 
+def build_like(expr_type: t.Type[E]) -> t.Callable[[t.List], E | exp.Escape]:
+    def _builder(args: t.List) -> E | exp.Escape:
+        like_expr = expr_type(this=seq_get(args, 0), expression=seq_get(args, 1))
+        escape = seq_get(args, 2)
+        return exp.Escape(this=like_expr, expression=escape) if escape else like_expr
+
+    return _builder
+
+
 def build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
     def _builder(args: t.List, dialect: Dialect) -> E:
         return expr_type(
@@ -2075,3 +2097,19 @@ def build_replace_with_optional_replacement(args: t.List) -> exp.Replace:
         expression=seq_get(args, 1),
         replacement=seq_get(args, 2) or exp.Literal.string(""),
     )
+
+
+def regexp_replace_global_modifier(expression: exp.RegexpReplace) -> exp.Expression | None:
+    modifiers = expression.args.get("modifiers")
+    single_replace = expression.args.get("single_replace")
+    occurrence = expression.args.get("occurrence")
+
+    if not single_replace and (not occurrence or (occurrence.is_int and occurrence.to_py() == 0)):
+        if not modifiers or modifiers.is_string:
+            # Append 'g' to the modifiers if they are not provided since
+            # the semantics of REGEXP_REPLACE from the input dialect
+            # is to replace all occurrences of the pattern.
+            value = "" if not modifiers else modifiers.name
+            modifiers = exp.Literal.string(value + "g")
+
+    return modifiers

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/duckdb.py

@@ -39,6 +39,7 @@ from sqlglot.dialects.dialect import (
     explode_to_unnest_sql,
     no_make_interval_sql,
     groupconcat_sql,
+    regexp_replace_global_modifier,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -414,6 +415,7 @@ class DuckDB(Dialect):
             "LIST_SORT": exp.SortArray.from_arg_list,
             "LIST_TRANSFORM": exp.Transform.from_arg_list,
             "LIST_VALUE": lambda args: exp.Array(expressions=args),
+            "MAKE_DATE": exp.DateFromParts.from_arg_list,
             "MAKE_TIME": exp.TimeFromParts.from_arg_list,
             "MAKE_TIMESTAMP": _build_make_timestamp,
             "QUANTILE_CONT": exp.PercentileCont.from_arg_list,
@@ -427,6 +429,7 @@ class DuckDB(Dialect):
                 expression=seq_get(args, 1),
                 replacement=seq_get(args, 2),
                 modifiers=seq_get(args, 3),
+                single_replace=True,
             ),
             "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
             "STRFTIME": build_formatted_time(exp.TimeToStr, "duckdb"),
@@ -695,7 +698,6 @@ class DuckDB(Dialect):
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.CommentColumnConstraint: no_comment_column_constraint_sql,
             exp.CosineDistance: rename_func("LIST_COSINE_DISTANCE"),
-            exp.CurrentDate: lambda *_: "CURRENT_DATE",
             exp.CurrentTime: lambda *_: "CURRENT_TIME",
             exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
             exp.DayOfMonth: rename_func("DAYOFMONTH"),
@@ -754,7 +756,7 @@ class DuckDB(Dialect):
                 e.this,
                 e.expression,
                 e.args.get("replacement"),
-                e.args.get("modifiers"),
+                regexp_replace_global_modifier(e),
             ),
             exp.RegexpLike: rename_func("REGEXP_MATCHES"),
             exp.RegexpILike: lambda self, e: self.func(
@@ -779,9 +781,11 @@ class DuckDB(Dialect):
             exp.Time: no_time_sql,
             exp.TimeDiff: _timediff_sql,
             exp.Timestamp: no_timestamp_sql,
+            exp.TimestampAdd: date_delta_to_binary_interval_op(),
             exp.TimestampDiff: lambda self, e: self.func(
                 "DATE_DIFF", exp.Literal.string(e.unit), e.expression, e.this
             ),
+            exp.TimestampSub: date_delta_to_binary_interval_op(),
             exp.TimestampTrunc: timestamptrunc_sql(),
             exp.TimeStrToDate: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.DATE)),
             exp.TimeStrToTime: timestrtotime_sql,
@@ -799,7 +803,7 @@ class DuckDB(Dialect):
                 exp.cast(e.expression, exp.DataType.Type.TIMESTAMP),
                 exp.cast(e.this, exp.DataType.Type.TIMESTAMP),
             ),
-            exp.UnixMicros: rename_func("EPOCH_US"),
+            exp.UnixMicros: lambda self, e: self.func("EPOCH_US", _implicit_datetime_cast(e.this)),
             exp.UnixToStr: lambda self, e: self.func(
                 "STRFTIME", self.func("TO_TIMESTAMP", e.this), self.format_time(e)
             ),
@@ -989,6 +993,16 @@ class DuckDB(Dialect):
                 return f"CAST({self.func('TRY_STRPTIME', expression.this, formatted_time)} AS DATE)"
             return f"CAST({str_to_time_sql(self, expression)} AS DATE)"
 
+        def currentdate_sql(self, expression: exp.CurrentDate) -> str:
+            if not expression.this:
+                return "CURRENT_DATE"
+
+            expr = exp.Cast(
+                this=exp.AtTimeZone(this=exp.CurrentTimestamp(), zone=expression.this),
+                to=exp.DataType(this=exp.DataType.Type.DATE),
+            )
+            return self.sql(expr)
+
         def parsejson_sql(self, expression: exp.ParseJSON) -> str:
             arg = expression.this
             if expression.args.get("safe"):

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/mysql.py

@@ -163,6 +163,7 @@ class MySQL(Dialect):
     SUPPORTS_USER_DEFINED_TYPES = False
     SUPPORTS_SEMI_ANTI_JOIN = False
     SAFE_DIVISION = True
+    SAFE_TO_ELIMINATE_DOUBLE_NEGATION = False
 
     # https://prestodb.io/docs/current/functions/datetime.html#mysql-date-functions
     TIME_MAPPING = {

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/postgres.py

@@ -37,6 +37,7 @@ from sqlglot.dialects.dialect import (
     count_if_to_sum,
     groupconcat_sql,
     Version,
+    regexp_replace_global_modifier,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import is_int, seq_get
@@ -203,6 +204,7 @@ def _build_regexp_replace(args: t.List, dialect: DialectType = None) -> exp.Rege
     # Any one of `start`, `N` and `flags` can be column references, meaning that
     # unless we can statically see that the last argument is a non-integer string
     # (eg. not '0'), then it's not possible to construct the correct AST
+    regexp_replace = None
     if len(args) > 3:
         last = args[-1]
         if not is_int(last.name):
@@ -214,9 +216,10 @@ def _build_regexp_replace(args: t.List, dialect: DialectType = None) -> exp.Rege
             if last.is_type(*exp.DataType.TEXT_TYPES):
                 regexp_replace = exp.RegexpReplace.from_arg_list(args[:-1])
                 regexp_replace.set("modifiers", last)
-                return regexp_replace
 
-    return exp.RegexpReplace.from_arg_list(args)
+    regexp_replace = regexp_replace or exp.RegexpReplace.from_arg_list(args)
+    regexp_replace.set("single_replace", True)
+    return regexp_replace
 
 
 def _unix_to_time_sql(self: Postgres.Generator, expression: exp.UnixToTime) -> str:
@@ -651,6 +654,15 @@ class Postgres(Dialect):
             exp.Rand: rename_func("RANDOM"),
             exp.RegexpLike: lambda self, e: self.binary(e, "~"),
             exp.RegexpILike: lambda self, e: self.binary(e, "~*"),
+            exp.RegexpReplace: lambda self, e: self.func(
+                "REGEXP_REPLACE",
+                e.this,
+                e.expression,
+                e.args.get("replacement"),
+                e.args.get("position"),
+                e.args.get("occurrence"),
+                regexp_replace_global_modifier(e),
+            ),
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_semi_and_anti_joins,

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/snowflake.py

@@ -8,10 +8,10 @@ from sqlglot.dialects.dialect import (
     NormalizationStrategy,
     annotate_with_type_lambda,
     build_timetostr_or_tochar,
+    build_like,
     binary_from_function,
     build_default_decimal_type,
     build_replace_with_optional_replacement,
-    build_timestamp_from_parts,
     date_delta_sql,
     date_trunc_to_time,
     datestrtodate_sql,
@@ -362,15 +362,6 @@ def _build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
     return _builder
 
 
-def _build_like(expr_type: t.Type[E]) -> t.Callable[[t.List], E | exp.Escape]:
-    def _builder(args: t.List) -> E | exp.Escape:
-        like_expr = expr_type(this=args[0], expression=args[1])
-        escape = seq_get(args, 2)
-        return exp.Escape(this=like_expr, expression=escape) if escape else like_expr
-
-    return _builder
-
-
 def _regexpextract_sql(self, expression: exp.RegexpExtract | exp.RegexpExtractAll) -> str:
     # Other dialects don't support all of the following parameters, so we need to
     # generate default values as necessary to ensure the transpilation is correct
@@ -551,6 +542,34 @@ def _annotate_reverse(self: TypeAnnotator, expression: exp.Reverse) -> exp.Rever
     return expression
 
 
+def _annotate_timestamp_from_parts(
+    self: TypeAnnotator, expression: exp.TimestampFromParts
+) -> exp.TimestampFromParts:
+    """Annotate TimestampFromParts with correct type based on arguments.
+    TIMESTAMP_FROM_PARTS with time_zone -> TIMESTAMPTZ
+    TIMESTAMP_FROM_PARTS without time_zone -> TIMESTAMP (defaults to TIMESTAMP_NTZ)
+    """
+    self._annotate_args(expression)
+
+    if expression.args.get("zone"):
+        self._set_type(expression, exp.DataType.Type.TIMESTAMPTZ)
+    else:
+        self._set_type(expression, exp.DataType.Type.TIMESTAMP)
+
+    return expression
+
+
+def _build_timestamp_from_parts(args: t.List) -> exp.Func:
+    """Build TimestampFromParts with support for both syntaxes:
+    1. TIMESTAMP_FROM_PARTS(year, month, day, hour, minute, second [, nanosecond] [, time_zone])
+    2. TIMESTAMP_FROM_PARTS(date_expr, time_expr) - Snowflake specific
+    """
+    if len(args) == 2:
+        return exp.TimestampFromParts(this=seq_get(args, 0), expression=seq_get(args, 1))
+
+    return exp.TimestampFromParts.from_arg_list(args)
+
+
 def _annotate_date_or_time_add(self: TypeAnnotator, expression: E) -> E:
     self._annotate_args(expression)
 
@@ -588,6 +607,8 @@ class Snowflake(Dialect):
             exp.Degrees,
             exp.Exp,
             exp.MonthsBetween,
+            exp.RegrValx,
+            exp.RegrValy,
             exp.Sin,
             exp.Sinh,
             exp.Tan,
@@ -680,6 +701,10 @@ class Snowflake(Dialect):
         exp.DataType.Type.BOOLEAN: {
             *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BOOLEAN],
             exp.Boolnot,
+            exp.Booland,
+            exp.Boolor,
+            exp.EqualNull,
+            exp.IsNullValue,
             exp.Search,
         },
         exp.DataType.Type.DATE: {
@@ -734,8 +759,11 @@ class Snowflake(Dialect):
             else exp.DataType.Type.TIMESTAMPTZ,
         ),
         exp.DateAdd: _annotate_date_or_time_add,
-        exp.Reverse: _annotate_reverse,
         exp.TimeAdd: _annotate_date_or_time_add,
+        exp.GreatestIgnoreNulls: lambda self, e: self._annotate_by_args(e, "expressions"),
+        exp.LeastIgnoreNulls: lambda self, e: self._annotate_by_args(e, "expressions"),
+        exp.Reverse: _annotate_reverse,
+        exp.TimestampFromParts: _annotate_timestamp_from_parts,
     }
 
     TIME_MAPPING = {
@@ -889,10 +917,10 @@ class Snowflake(Dialect):
             "TIMEDIFF": _build_datediff,
             "TIMESTAMPADD": _build_date_time_add(exp.DateAdd),
             "TIMESTAMPDIFF": _build_datediff,
-            "TIMESTAMPFROMPARTS": build_timestamp_from_parts,
-            "TIMESTAMP_FROM_PARTS": build_timestamp_from_parts,
-            "TIMESTAMPNTZFROMPARTS": build_timestamp_from_parts,
-            "TIMESTAMP_NTZ_FROM_PARTS": build_timestamp_from_parts,
+            "TIMESTAMPFROMPARTS": _build_timestamp_from_parts,
+            "TIMESTAMP_FROM_PARTS": _build_timestamp_from_parts,
+            "TIMESTAMPNTZFROMPARTS": _build_timestamp_from_parts,
+            "TIMESTAMP_NTZ_FROM_PARTS": _build_timestamp_from_parts,
             "TRY_PARSE_JSON": lambda args: exp.ParseJSON(this=seq_get(args, 0), safe=True),
             "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DataType.Type.DATE, safe=True),
             "TRY_TO_TIME": _build_datetime("TRY_TO_TIME", exp.DataType.Type.TIME, safe=True),
@@ -916,9 +944,11 @@ class Snowflake(Dialect):
             "TO_JSON": exp.JSONFormat.from_arg_list,
             "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
             "ZEROIFNULL": _build_if_from_zeroifnull,
-            "LIKE": _build_like(exp.Like),
-            "ILIKE": _build_like(exp.ILike),
+            "LIKE": build_like(exp.Like),
+            "ILIKE": build_like(exp.ILike),
             "SEARCH": _build_search,
+            "WEEKISO": exp.WeekOfYear.from_arg_list,
+            "WEEKOFYEAR": exp.Week.from_arg_list,
         }
         FUNCTIONS.pop("PREDICT")
 
@@ -1624,9 +1654,16 @@ class Snowflake(Dialect):
             exp.UnixToTime: rename_func("TO_TIMESTAMP"),
             exp.Uuid: rename_func("UUID_STRING"),
             exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
-            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
+            exp.Booland: rename_func("BOOLAND"),
+            exp.Boolor: rename_func("BOOLOR"),
+            exp.WeekOfYear: rename_func("WEEKISO"),
+            exp.YearOfWeek: rename_func("YEAROFWEEK"),
+            exp.YearOfWeekIso: rename_func("YEAROFWEEKISO"),
             exp.Xor: rename_func("BOOLXOR"),
             exp.ByteLength: rename_func("OCTET_LENGTH"),
+            exp.ArrayConcatAgg: lambda self, e: self.func(
+                "ARRAY_FLATTEN", exp.ArrayAgg(this=e.this)
+            ),
         }
 
         SUPPORTED_JSON_PATH_PARTS = {

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/spark.py

@@ -6,6 +6,7 @@ from sqlglot import exp
 from sqlglot.dialects.dialect import (
     Version,
     rename_func,
+    build_like,
     unit_to_var,
     timestampdiff_sql,
     build_date_delta,
@@ -147,6 +148,8 @@ class Spark(Spark2):
                 offset=1,
                 safe=True,
             ),
+            "LIKE": build_like(exp.Like),
+            "ILIKE": build_like(exp.ILike),
         }
 
         PLACEHOLDER_PARSERS = {

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/dialects/sqlite.py

@@ -89,6 +89,7 @@ class SQLite(Dialect):
     SUPPORTS_SEMI_ANTI_JOIN = False
     TYPED_DIVISION = True
     SAFE_DIVISION = True
+    SAFE_TO_ELIMINATE_DOUBLE_NEGATION = False
 
     class Tokenizer(tokens.Tokenizer):
         IDENTIFIERS = ['"', ("[", "]"), "`"]

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/executor/__init__.py

@@ -31,7 +31,6 @@ if t.TYPE_CHECKING:
 def execute(
     sql: str | Expression,
     schema: t.Optional[t.Dict | Schema] = None,
-    read: DialectType = None,
     dialect: DialectType = None,
     tables: t.Optional[t.Dict] = None,
 ) -> Table:
@@ -45,15 +44,13 @@ def execute(
             1. {table: {col: type}}
             2. {db: {table: {col: type}}}
             3. {catalog: {db: {table: {col: type}}}}
-        read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
-        dialect: the SQL dialect (alias for read).
+        dialect: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
         tables: additional tables to register.
 
     Returns:
         Simple columnar data structure.
     """
-    read = read or dialect
-    tables_ = ensure_tables(tables, dialect=read)
+    tables_ = ensure_tables(tables, dialect=dialect)
 
     if not schema:
         schema = {}
@@ -66,19 +63,17 @@ def execute(
             for column in table.columns:
                 value = table[0][column]
                 column_type = (
-                    annotate_types(exp.convert(value), dialect=read).type or type(value).__name__
+                    annotate_types(exp.convert(value), dialect=dialect).type or type(value).__name__
                 )
                 nested_set(schema, [*keys, column], column_type)
 
-    schema = ensure_schema(schema, dialect=read)
+    schema = ensure_schema(schema, dialect=dialect)
 
     if tables_.supported_table_args and tables_.supported_table_args != schema.supported_table_args:
         raise ExecuteError("Tables must support the same table args as schema")
 
     now = time.time()
-    expression = optimize(
-        sql, schema, leave_tables_isolated=True, infer_csv_schemas=True, dialect=read
-    )
+    expression = optimize(sql, schema, leave_tables_isolated=True, dialect=dialect)
 
     logger.debug("Optimization finished: %f", time.time() - now)
     logger.debug("Optimized SQL: %s", expression.sql(pretty=True))

{sqlglot-27.28.1 → sqlglot-27.29.0}/sqlglot/executor/python.py

@@ -1,4 +1,3 @@
-import ast
 import collections
 import itertools
 import math
@@ -9,7 +8,7 @@ from sqlglot.errors import ExecuteError
 from sqlglot.executor.context import Context
 from sqlglot.executor.env import ENV
 from sqlglot.executor.table import RowReader, Table
-from sqlglot.helper import csv_reader, subclasses
+from sqlglot.helper import subclasses
 
 
 class PythonExecutor:
@@ -97,9 +96,6 @@ class PythonExecutor:
             if not step.projections and not step.condition:
                 return self.context({step.name: context.tables[source]})
             table_iter = context.table_iter(source)
-        elif isinstance(step.source, exp.Table) and isinstance(step.source.this, exp.ReadCSV):
-            table_iter = self.scan_csv(step)
-            context = next(table_iter)
         else:
             context, table_iter = self.scan_table(step)
 
@@ -132,30 +128,6 @@ class PythonExecutor:
         context = self.context({step.source.alias_or_name: table})
         return context, iter(table)
 
-    def scan_csv(self, step):
-        alias = step.source.alias
-        source = step.source.this
-
-        with csv_reader(source) as reader:
-            columns = next(reader)
-            table = Table(columns)
-            context = self.context({alias: table})
-            yield context
-            types = []
-            for row in reader:
-                if not types:
-                    for v in row:
-                        try:
-                            types.append(type(ast.literal_eval(v)))
-                        except (ValueError, SyntaxError):
-                            types.append(str)
-
-                # We can't cast empty values ('') to non-string types, so we convert them to None instead
-                context.set_row(
-                    tuple(None if (t is not str and v == "") else t(v) for t, v in zip(types, row))
-                )
-                yield context.table.reader
-
     def join(self, step, context):
         source = step.source_name