snowflake-snowpark-python 1.48.0__tar.gz → 1.49.0__tar.gz

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Release History
 
+## 1.49.0 (2026-04-13)
+
+### Snowpark Python API Updates
+
+#### New Features
+
+- Allow a user-specified schema when reading Parquet files from a stage.
+
+#### Improvements
+
+- Restored the following query improvements that were reverted in 1.47.0 due to bugs:
+  - Reduced the size of queries generated by certain `DataFrame.join` operations.
+  - Removed redundant aliases in generated queries (for example, `SELECT "A" AS "A"` is now always simplified to `SELECT "A"`).
+- Removed warning that `DataFrameReader.dbapi` feature was in private preview.
+
+#### Bug Fixes
+
+- Fixed a bug where `Session.create_dataframe` raised `TypeError` when a `StringType` column was given a non-string Python value (e.g. `int`, `float`, `bool`, `Decimal`) for a small local relation (below the array bind threshold); `VALUES` SQL generation now coerces these types to string literals, consistent with the large-data bind-parameter path.
+- Fixed a bug where `DataFrame.approxQuantile` did not accept a `Column` for the `col` parameter.
+
+### Snowpark Local Testing Updates
+
+#### Bug Fixes
+
+- Fixed a bug where `concat` produced extra NaN rows and mismatched values after a `filter` operation in local testing.
+- Fixed a bug where `dense_rank()` would fail with `ValueError` on NULL partition values.
+- Fixed a bug where `collect()` raised `KeyError` after `save_as_table(column_order="name")` when the source DataFrame omitted columns with types `VariantType`, `MapType`, or `ArrayType` that were present in the target table schema in local testing.
+
+## 1.48.1 (2026-03-31)
+
+### Snowpark Python API Updates
+
+#### Bug Fixes
+
+- Fixed a bug where chained `DataFrame.filter()` calls with raw SQL text containing `OR` produced incorrect results.
+- Fixed a Snowflake platform compatibility issue where `concat(lit('"'), ...)` could lose the leading quote through chained set-operation plans.
+- Fixed a bug for XML schema inference session resolution in spark compatible mode.
+
 ## 1.48.0 (2026-03-23)
 
 ### Snowpark Python API Updates

{snowflake_snowpark_python-1.48.0/src/snowflake_snowpark_python.egg-info → snowflake_snowpark_python-1.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-snowpark-python
-Version: 1.48.0
+Version: 1.49.0
 Summary: Snowflake Snowpark for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -33,7 +33,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.9, <3.14
+Requires-Python: >=3.9, <3.15
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: setuptools>=40.6.0
@@ -98,13 +98,13 @@ Requires-Dist: tox; extra == "modin-development"
 Requires-Dist: snowflake.core<2,>=1.0.0; extra == "modin-development"
 Requires-Dist: psutil; extra == "modin-development"
 Requires-Dist: lxml; extra == "modin-development"
-Requires-Dist: scipy<=1.16.0; extra == "modin-development"
+Requires-Dist: scipy<=1.16.3; extra == "modin-development"
 Requires-Dist: statsmodels; extra == "modin-development"
 Requires-Dist: scikit-learn; extra == "modin-development"
 Requires-Dist: plotly<6.0.0; extra == "modin-development"
 Requires-Dist: snowflake-ml-python>=1.8.0; python_version < "3.12" and extra == "modin-development"
 Requires-Dist: s3fs; extra == "modin-development"
-Requires-Dist: ray; extra == "modin-development"
+Requires-Dist: ray; python_version < "3.14" and extra == "modin-development"
 Provides-Extra: localtest
 Requires-Dist: pandas; extra == "localtest"
 Requires-Dist: requests; extra == "localtest"

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/setup.py

@@ -32,7 +32,7 @@ INSTALL_REQ_LIST = [
     "python-dateutil",  # Snowpark IR
     "tzlocal",  # Snowpark IR
 ]
-REQUIRED_PYTHON_VERSION = ">=3.9, <3.14"
+REQUIRED_PYTHON_VERSION = ">=3.9, <3.15"
 
 if os.getenv("SNOWFLAKE_IS_PYTHON_RUNTIME_TEST", False):
     REQUIRED_PYTHON_VERSION = ">=3.9"
@@ -71,7 +71,7 @@ MODIN_DEVELOPMENT_REQUIREMENTS = [
     # Snowpark pandas 3rd party library testing. Cap the scipy version because
     # Snowflake cannot find newer versions of scipy for python 3.11+. See
     # SNOW-2452791.
-    "scipy<=1.16.0",
+    "scipy<=1.16.3",
     "statsmodels",  # Snowpark pandas 3rd party library testing
     "scikit-learn",  # Snowpark pandas 3rd party library testing
     # plotly version restricted due to foreseen change in query counts in version 6.0.0+
@@ -80,7 +80,8 @@ MODIN_DEVELOPMENT_REQUIREMENTS = [
     # snowflake-ml-python is available on python 3.12.
     "snowflake-ml-python>=1.8.0; python_version<'3.12'",
     "s3fs",  # Used in tests that read CSV files from s3
-    "ray",  # Used in data movement tests
+    # ray currently has no compatible wheels for Python 3.14.
+    "ray; python_version<'3.14'",  # Used in data movement tests
 ]
 
 # read the version

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/_internal/analyzer/analyzer.py

@@ -763,10 +763,18 @@ class Analyzer:
                     for k, v in df_alias_dict.items():
                         if v == expr.child.name:
                             df_alias_dict[k] = updated_due_to_inheritance  # type: ignore
+            origin = self.analyze(
+                expr.child, df_aliased_col_name_to_real_col_name, parse_local_name
+            )
+            if (
+                isinstance(expr.child, (Attribute, UnresolvedAttribute))
+                and origin == quoted_name
+            ):
+                # If the column name matches the target of the alias (`quoted_name`),
+                # we can directly emit the column name without an AS clause.
+                return origin
             return alias_expression(
-                self.analyze(
-                    expr.child, df_aliased_col_name_to_real_col_name, parse_local_name
-                ),
+                origin,
                 quoted_name,
             )
 
@@ -790,10 +798,13 @@ class Analyzer:
                 expr.is_permissive,
             )
         else:
+            child_sql = self.analyze(
+                child, df_aliased_col_name_to_real_col_name, parse_local_name
+            )
+            if isinstance(child, UnresolvedAttribute) and child.is_sql_text:
+                child_sql = f"({child_sql})"
             return unary_expression(
-                self.analyze(
-                    child, df_aliased_col_name_to_real_col_name, parse_local_name
-                ),
+                child_sql,
                 expr.sql_operator,
                 expr.operator_first,
             )
@@ -822,6 +833,10 @@ class Analyzer:
             right_sql_expr = self.analyze(
                 right, df_aliased_col_name_to_real_col_name, parse_local_name
             )
+        if isinstance(left, UnresolvedAttribute) and left.is_sql_text:
+            left_sql_expr = f"({left_sql_expr})"
+        if isinstance(right, UnresolvedAttribute) and right.is_sql_text:
+            right_sql_expr = f"({right_sql_expr})"
         if isinstance(expr, BinaryArithmeticExpression):
             return binary_arithmetic_expression(
                 expr.sql_operator,

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/_internal/analyzer/expression.py

@@ -2,7 +2,6 @@
 # Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
 #
 
-import copy
 import uuid
 from typing import TYPE_CHECKING, AbstractSet, Any, Dict, List, Optional, Tuple
 
@@ -158,7 +157,9 @@ class NamedExpression:
         return self._expr_id
 
     def __copy__(self):
-        new = copy.copy(super())
+        cls = self.__class__
+        new = cls.__new__(cls)
+        new.__dict__.update(self.__dict__)
         new._expr_id = None  # type: ignore
         return new
 

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/_internal/analyzer/select_statement.py

@@ -2244,11 +2244,18 @@ def derive_column_states_from_subquery(
             else Attribute(quoted_c_name, DataType())
         )
         from_c_state = from_.column_states.get(quoted_c_name)
+        result_name = analyzer.analyze(
+            c, from_.df_aliased_col_name_to_real_col_name, parse_local_name=True
+        ).strip(" ")
         if from_c_state and from_c_state.change_state != ColumnChangeState.DROPPED:
             # review later. should use parse_column_name
-            if c_name != analyzer.analyze(
-                c, from_.df_aliased_col_name_to_real_col_name, parse_local_name=True
-            ).strip(" "):
+            # SNOW-2895675: Always treat Aliases as "changed", even if it is an identity.
+            # The fact this check is needed may be a bug in column state analysis, and we should revisit it later.
+            # The following tests fail without this check:
+            # - tests/integ/test_cte.py::test_sql_simplifier
+            # - tests/integ/scala/test_dataframe_suite.py::test_rename_join_dataframe
+            # - tests/integ/test_dataframe.py::test_dataframe_alias
+            if c_name != result_name or isinstance(c, Alias):
                 column_states[quoted_c_name] = ColumnState(
                     quoted_c_name,
                     ColumnChangeState.CHANGED_EXP,

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py

@@ -7,7 +7,7 @@ import difflib
 from logging import getLogger
 import re
 import sys
-import uuid
+import uuid as uuid_lib
 from collections import defaultdict, deque
 from enum import Enum
 from dataclasses import dataclass
@@ -383,7 +383,7 @@ class SnowflakePlan(LogicalPlan):
                         # and it's a reading XML query.
 
                         def search_read_file_node(
-                            node: Union[SnowflakePlan, Selectable]
+                            node: Union[SnowflakePlan, Selectable],
                         ) -> Optional[ReadFileNode]:
                             source_plan = (
                                 node.source_plan
@@ -435,7 +435,7 @@ class SnowflakePlan(LogicalPlan):
         # during the compilation stage.
         schema_query: Optional[str],
         post_actions: Optional[List["Query"]] = None,
-        expr_to_alias: Optional[Dict[uuid.UUID, str]] = None,
+        expr_to_alias: Optional[Dict[uuid_lib.UUID, str]] = None,
         source_plan: Optional[LogicalPlan] = None,
         is_ddl_on_temp_object: bool = False,
         api_calls: Optional[List[Dict]] = None,
@@ -479,7 +479,9 @@ class SnowflakePlan(LogicalPlan):
                 if self.session._join_alias_fix
                 else defaultdict(dict)
             )
-        self._uuid = from_selectable_uuid if from_selectable_uuid else str(uuid.uuid4())
+        self._uuid = (
+            from_selectable_uuid if from_selectable_uuid else str(uuid_lib.uuid4())
+        )
         # We set the query line intervals for the last query in the queries list
         self.set_last_query_line_intervals()
         # In the placeholder query, subquery (child) is held by the ID of query plan

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/_internal/xml_schema_inference.py

@@ -9,7 +9,6 @@ from typing import Optional, Dict, List
 
 from snowflake.snowpark._internal.xml_reader import (
     DEFAULT_CHUNK_SIZE,
-    get_file_size,
     find_next_opening_tag_pos,
     tag_is_self_closing,
     find_next_closing_tag_pos,
@@ -650,6 +649,7 @@ class XMLSchemaInference:
         null_value: str,
         charset: str,
         ignore_surrounding_whitespace: bool,
+        file_size: int,
     ):
         """
         Infer XML schema for a byte-range partition of the file.
@@ -667,8 +667,8 @@ class XMLSchemaInference:
             null_value: Value to treat as null.
             charset: Character encoding of the XML file.
             ignore_surrounding_whitespace: Whether to strip whitespace from values.
+            file_size: Size of the file in bytes (provided by the client via LS).
         """
-        file_size = get_file_size(filename)
         if not file_size or file_size <= 0:
             yield ("",)
             return

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/dataframe.py

@@ -277,29 +277,69 @@ def _get_unaliased(col_name: str) -> List[str]:
     return unaliased
 
 
+def _get_aliased_column_names(
+    df: "DataFrame",
+    cs: List[str],
+    prefix: Optional[str],
+    suffix: Optional[str],
+    common_col_names: List[str],
+) -> List[str]:
+    aliases = []
+    for c in cs:
+        unquoted_col_name = c.strip('"')
+        if c in common_col_names:
+            if suffix:
+                column_case_insensitive = is_snowflake_quoted_id_case_insensitive(c)
+                suffix_unqouted_case_insensitive = (
+                    is_snowflake_unquoted_suffix_case_insensitive(suffix)
+                )
+                aliases.append(
+                    f'"{unquoted_col_name}{suffix.upper()}"'
+                    if column_case_insensitive and suffix_unqouted_case_insensitive
+                    else f'''"{unquoted_col_name}{escape_quotes(suffix.strip('"'))}"'''
+                )
+            else:
+                aliases.append(f'"{prefix}{unquoted_col_name}"')
+        else:
+            # Removal of redundant aliases (like `"A" AS "A"`) is handled at the analyzer level.
+            aliases.append(f'"{unquoted_col_name}"')
+    return aliases
+
+
+def _apply_aliases(
+    df: "DataFrame",
+    cs: List[str],
+    c_aliases: List[str],
+) -> List[Column]:
+    return [
+        df.col(c, _emit_ast=False).alias(c_alias) for c, c_alias in zip(cs, c_aliases)
+    ]
+
+
 def _alias_if_needed(
     df: "DataFrame",
-    c: str,
+    cs: List[str],
     prefix: Optional[str],
     suffix: Optional[str],
     common_col_names: List[str],
-):
-    col = df.col(c, _emit_ast=False)
-    unquoted_col_name = c.strip('"')
-    if c in common_col_names:
-        if suffix:
-            column_case_insensitive = is_snowflake_quoted_id_case_insensitive(c)
-            suffix_unqouted_case_insensitive = (
-                is_snowflake_unquoted_suffix_case_insensitive(suffix)
-            )
-            return col.alias(
-                f'"{unquoted_col_name}{suffix.upper()}"'
-                if column_case_insensitive and suffix_unqouted_case_insensitive
-                else f'''"{unquoted_col_name}{escape_quotes(suffix.strip('"'))}"'''
-            )
-        return col.alias(f'"{prefix}{unquoted_col_name}"')
-    else:
-        return col.alias(f'"{unquoted_col_name}"')
+) -> List[Column]:
+    return _apply_aliases(
+        df, cs, _get_aliased_column_names(df, cs, prefix, suffix, common_col_names)
+    )
+
+
+def _populate_expr_to_alias(df: "DataFrame") -> None:
+    """
+    Populate expr_to_alias mapping for a DataFrame's output columns.
+    This is needed for column lineage tracking when we skip the select() wrapping
+    optimization in _disambiguate.
+    """
+    for attr in df._output:
+        # Map each attribute's expr_id to its quoted column name
+        # This allows later lookups like df["column_name"] to resolve correctly
+        # Use quote_name() for consistency with analyzer.py Alias handling (line 743, 756)
+        if attr.expr_id not in df._plan.expr_to_alias:
+            df._plan.expr_to_alias[attr.expr_id] = quote_name(attr.name)
 
 
 def _disambiguate(
@@ -328,11 +368,11 @@ def _disambiguate(
         for n in lhs_names
         if n in set(rhs_names) and n not in normalized_using_columns
     ]
+
     all_names = [unquote_if_quoted(n) for n in lhs_names + rhs_names]
 
-    if common_col_names:
-        # We use the session of the LHS DataFrame to report this telemetry
-        lhs._session._conn._telemetry_client.send_alias_in_join_telemetry()
+    # We use the session of the LHS DataFrame to report this telemetry
+    lhs._session._conn._telemetry_client.send_alias_in_join_telemetry()
 
     lsuffix = lsuffix or lhs._alias
     rsuffix = rsuffix or rhs._alias
@@ -344,25 +384,37 @@ def _disambiguate(
         _generate_deterministic_prefix("r", all_names) if not suffix_provided else ""
     )
 
+    lhs_aliases = _get_aliased_column_names(
+        lhs,
+        lhs_names,
+        lhs_prefix,
+        lsuffix,
+        [] if isinstance(join_type, (LeftSemi, LeftAnti)) else common_col_names,
+    )
+    rhs_aliases = _get_aliased_column_names(
+        rhs, rhs_names, rhs_prefix, rsuffix, common_col_names
+    )
+    if all(
+        l_name == l_aliased for l_name, l_aliased in zip(lhs_names, lhs_aliases)
+    ) and all(r_name == r_aliased for r_name, r_aliased in zip(rhs_names, rhs_aliases)):
+        # Optimization: No column name conflicts, so we can skip aliasing and the select() wrapping.
+        # But we still need to populate expr_to_alias for column lineage tracking,
+        # so that df["column_name"] can resolve correctly after the join.
+        # This is identified by the test case
+        # tests/integ/scala/test_dataframe_join_suite.py::test_name_alias_on_multiple_join.
+        # Note that we must also ensure none of the column names have changed due to internal quote stripping:
+        # see tests/integ/compiler/test_query_generator.py::test_disambiguate_skips_quoted_alias for details.
+        _populate_expr_to_alias(lhs)
+        _populate_expr_to_alias(rhs)
+        return lhs, rhs
+
     lhs_remapped = lhs.select(
-        [
-            _alias_if_needed(
-                lhs,
-                name,
-                lhs_prefix,
-                lsuffix,
-                [] if isinstance(join_type, (LeftSemi, LeftAnti)) else common_col_names,
-            )
-            for name in lhs_names
-        ],
+        _apply_aliases(lhs, lhs_names, lhs_aliases),
         _emit_ast=False,
     )
 
     rhs_remapped = rhs.select(
-        [
-            _alias_if_needed(rhs, name, rhs_prefix, rsuffix, common_col_names)
-            for name in rhs_names
-        ],
+        _apply_aliases(rhs, rhs_names, rhs_aliases),
         _emit_ast=False,
     )
     return lhs_remapped, rhs_remapped
@@ -2062,7 +2114,7 @@ class DataFrame:
                 stmt = _ast_stmt
 
         # In snowpark_connect_compatible mode, we need to handle
-        # the filtering for dataframe after aggregation without nesting using HAVING
+        # the filtering for dataframe after aggregation without nesting using HAVING.
         if (
             context._is_snowpark_connect_compatible_mode
             and self._ops_after_agg is not None
@@ -2278,7 +2330,7 @@ class DataFrame:
                     )
 
         # In snowpark_connect_compatible mode, we need to handle
-        # the sorting for dataframe after aggregation without nesting
+        # the sorting for dataframe after aggregation without nesting.
         if (
             context._is_snowpark_connect_compatible_mode
             and self._ops_after_agg is not None
@@ -3005,7 +3057,7 @@ class DataFrame:
             stmt = None
 
         # In snowpark_connect_compatible mode, we need to handle
-        # the limit for dataframe after aggregation without nesting
+        # the limit for dataframe after aggregation without nesting.
         if (
             context._is_snowpark_connect_compatible_mode
             and self._ops_after_agg is not None
@@ -5113,16 +5165,13 @@ class DataFrame:
             )
         prefix = _generate_prefix("a")
         child = self.select(
-            [
-                _alias_if_needed(
-                    self,
-                    attr.name,
-                    prefix,
-                    suffix=None,
-                    common_col_names=common_col_names,
-                )
-                for attr in self._output
-            ],
+            _alias_if_needed(
+                self,
+                [attr.name for attr in self._output],
+                prefix,
+                suffix=None,
+                common_col_names=common_col_names,
+            ),
             _emit_ast=False,
         )
         return DataFrame(

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/dataframe_reader.py

@@ -62,6 +62,7 @@ from snowflake.snowpark._internal.xml_schema_inference import (
 )
 from snowflake.snowpark._internal.utils import (
     SNOWURL_PREFIX,
+    STAGE_PREFIX,
     XML_ROW_TAG_STRING,
     XML_ROW_DATA_COLUMN_NAME,
     XML_READER_FILE_PATH,
@@ -642,10 +643,10 @@ class DataFrameReader:
 
     @publicapi
     def schema(self, schema: StructType, _emit_ast: bool = True) -> "DataFrameReader":
-        """Define the schema for CSV or XML files that you want to read.
+        """Define the schema for CSV, JSON, Parquet, or XML files that you want to read.
 
         Args:
-            schema: Schema configuration for the CSV or XML file to be read.
+            schema: Schema configuration for the file to be read.
 
         Returns:
             a :class:`DataFrameReader` instance with the specified schema configuration for the data to be read.
@@ -1422,15 +1423,23 @@ class DataFrameReader:
         """Register a session-scoped XML UDTF with a deterministic fully-qualified
         name, cached per session and schema"""
         if is_in_stored_procedure():  # pragma: no cover
-            session_stage = self._session.get_session_stage()
+            # Use TEMPORARY instead of SCOPED TEMPORARY session stage
+            import_stage_name = self._session.get_fully_qualified_name_if_possible(
+                "SNOWPARK_TEMP_STAGE_XMLIMPORTS"
+            )
+            self._session._run_query(
+                f"CREATE TEMPORARY STAGE IF NOT EXISTS {import_stage_name}",
+                is_ddl_on_temp_object=True,
+            )
+            import_stage = f"{STAGE_PREFIX}{import_stage_name}"
             self._session._conn.upload_file(
                 local_file_path,
-                session_stage,
+                import_stage,
                 compress_data=False,
                 overwrite=True,
                 skip_upload_on_content_match=True,
             )
-            python_file_path = f"{session_stage}/{os.path.basename(local_file_path)}"
+            python_file_path = f"{import_stage}/{os.path.basename(local_file_path)}"
         else:
             python_file_path = local_file_path
 
@@ -1439,7 +1448,7 @@ class DataFrameReader:
         )
 
         udtf_name = self._session.get_fully_qualified_name_if_possible(
-            f"SNOWPARK_TEMP_XML_{handler_name}"
+            f"SNOWPARK_TEMP_TABLE_FUNCTION_{handler_name.upper()}"
         )
 
         return self._session.udtf.register_from_file(
@@ -1448,7 +1457,7 @@ class DataFrameReader:
             name=udtf_name,
             output_schema=output_schema,
             input_types=input_types,
-            packages=["snowflake-snowpark-python", "lxml<6"],
+            packages=["snowflake-snowpark-python", "lxml<7"],
             if_not_exists=True,
             skip_upload_on_content_match=True,
             _suppress_local_package_warnings=True,
@@ -1506,6 +1515,7 @@ class DataFrameReader:
                 lit(null_value),
                 lit(charset),
                 lit(ignore_surrounding_whitespace),
+                lit(file_size),
             )
         )
 
@@ -1596,7 +1606,7 @@ class DataFrameReader:
                     raise_error=NotImplementedError,
                 )
 
-        if self._user_schema and format.lower() not in ["json", "xml"]:
+        if self._user_schema and format.lower() not in ["json", "xml", "parquet"]:
             raise ValueError(f"Read {format} does not support user schema")
         if (
             self._user_schema
@@ -1624,14 +1634,25 @@ class DataFrameReader:
             use_user_schema = True
 
         elif self._infer_schema:
-            (
-                new_schema,
-                schema_to_cast,
-                read_file_transformations,
-                _,  # we don't check for error in case of infer schema failures. We use $1, Variant type
-            ) = self._infer_schema_for_file_format(path, format)
-            if new_schema:
-                schema = new_schema
+            if not isinstance(self._session._conn, MockServerConnection):
+                (
+                    new_schema,
+                    schema_to_cast,
+                    read_file_transformations,
+                    infer_schema_exception,
+                ) = self._infer_schema_for_file_format(path, format)
+                if new_schema:
+                    schema = new_schema
+                elif infer_schema_exception is not None:
+                    if isinstance(infer_schema_exception, FileNotFoundError):
+                        raise infer_schema_exception
+                    logger.warning(
+                        f"Could not infer schema for {format} file due to exception: "
+                        f"{infer_schema_exception}. "
+                        "\nFalling back to $1 VARIANT schema. "
+                        "Please use DataFrameReader.schema() to specify a user schema for the file."
+                    )
+                    self._cur_options["INFER_SCHEMA"] = False
 
         metadata_project, metadata_schema = self._get_metadata_project_and_schema()
 
@@ -1920,7 +1941,6 @@ class DataFrameReader:
         set_api_call_source(res_df, DATA_SOURCE_JDBC_SIGNATURE)
         return res_df
 
-    @private_preview(version="1.29.0")
     @publicapi
     def dbapi(
         self,

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/dataframe_stat_functions.py

@@ -23,7 +23,7 @@ from snowflake.snowpark._internal.telemetry import (
     adjust_api_subcalls,
 )
 from snowflake.snowpark._internal.type_utils import ColumnOrName, LiteralType
-from snowflake.snowpark._internal.utils import publicapi, warning
+from snowflake.snowpark._internal.utils import column_to_bool, publicapi, warning
 from snowflake.snowpark.functions import (
     _to_col_if_str,
     approx_percentile_accumulate,
@@ -91,7 +91,7 @@ class DataFrameStatFunctions:
              approximate percentile values if ``col`` is a list of column names.
         """
 
-        if not percentile or not col:
+        if not percentile or not column_to_bool(col):
             return []
 
         kwargs = {}
@@ -102,7 +102,7 @@ class DataFrameStatFunctions:
             expr = with_src_position(stmt.expr.dataframe_stat_approx_quantile, stmt)
             self._dataframe._set_ast_ref(expr.df)
 
-            if isinstance(col, Iterable) and not isinstance(col, str):
+            if isinstance(col, Iterable) and not isinstance(col, (str, Column)):
                 expr.cols.variadic = False
                 for c in col:
                     build_expr_from_snowpark_column_or_col_name(expr.cols.args.add(), c)

{snowflake_snowpark_python-1.48.0 → snowflake_snowpark_python-1.49.0}/src/snowflake/snowpark/functions.py

@@ -3712,6 +3712,22 @@ def collation(e: ColumnOrName, _emit_ast: bool = True) -> Column:
     return _call_function("collation", c, _emit_ast=_emit_ast)
 
 
+def _rewrite_concat_arg_if_double_quote_string_literal(
+    c: Column, *, _emit_ast: bool
+) -> Column:
+    # SNOW-3259059: Some Snowflake releases (10.7.1–10.9.2 per JIRA) dropped CONCAT's leading
+    # lit('"') through EXCEPT / chained set-op plans. CHR(34) is the same VARCHAR character in SQL
+    # without that specific single-character literal form.
+    expr = c._expression
+    if (
+        isinstance(expr, Literal)
+        and isinstance(expr.datatype, StringType)
+        and expr.value == '"'
+    ):
+        return _call_function("chr", lit(34, _emit_ast=_emit_ast), _emit_ast=_emit_ast)
+    return c
+
+
 @publicapi
 def concat(*cols: ColumnOrName, _emit_ast: bool = True) -> Column:
     """Concatenates one or more strings, or concatenates one or more binary values. If any of the values is null, the result is also null.
@@ -3726,7 +3742,12 @@ def concat(*cols: ColumnOrName, _emit_ast: bool = True) -> Column:
         --------------------------
         <BLANKLINE>
     """
-    columns = [_to_col_if_str(c, "concat") for c in cols]
+    columns = [
+        _rewrite_concat_arg_if_double_quote_string_literal(
+            _to_col_if_str(c, "concat"), _emit_ast=_emit_ast
+        )
+        for c in cols
+    ]
     return _call_function("concat", *columns, _emit_ast=_emit_ast)