soda-sqlserver 4.17.1__tar.gz → 4.19.0__tar.gz

{soda_sqlserver-4.17.1 → soda_sqlserver-4.19.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: soda-sqlserver
-Version: 4.17.1
+Version: 4.19.0
 Summary: Soda SQL Server V4
 Author-email: "Soda Data N.V." <info@soda.io>
 License: Proprietary
 Requires-Python: >=3.10
-Requires-Dist: soda-core==4.17.1
+Requires-Dist: soda-core==4.19.0
 Requires-Dist: pyodbc

{soda_sqlserver-4.17.1 → soda_sqlserver-4.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "soda-sqlserver"
-version = "4.17.1"
+version = "4.19.0"
 description = "Soda SQL Server V4"
 requires-python = ">=3.10"
 license = {text = "Proprietary"}
@@ -8,7 +8,7 @@ authors = [
     {name = "Soda Data N.V.", email = "info@soda.io"}
 ]
 dependencies = [
-    "soda-core==4.17.1",
+    "soda-core==4.19.0",
     "pyodbc",
 ]
 

{soda_sqlserver-4.17.1 → soda_sqlserver-4.19.0}/src/soda_sqlserver/common/data_sources/sqlserver_data_source.py

@@ -9,6 +9,7 @@ from soda_core.common.dataset_identifier import DatasetIdentifier
 from soda_core.common.logging_constants import soda_logger
 from soda_core.common.metadata_types import SodaDataTypeName, SqlDataType
 from soda_core.common.sql_ast import (
+    ADD_INTERVAL,
     AND,
     COLUMN,
     COUNT,
@@ -30,16 +31,19 @@ from soda_core.common.sql_ast import (
     LIMIT,
     OFFSET,
     ORDER_BY_ASC,
+    PERCENTILE_WITHIN_GROUP,
     RANDOM,
     REGEX_LIKE,
     SELECT,
     STAR,
     STRING_HASH,
+    TIME_DELTA,
     TUPLE,
     VALUES,
     WHERE,
     WITH,
     SqlExpressionStr,
+    seconds_per_time_bucket,
 )
 from soda_core.common.sql_dialect import SqlDialect
 from soda_sqlserver.common.data_sources.sqlserver_data_source_connection import (
@@ -52,9 +56,19 @@ from soda_sqlserver.common.data_sources.sqlserver_data_source_connection import
 logger: logging.Logger = soda_logger
 
 
+# APPROX_PERCENTILE_DISC needs SQL Server 2022+ on-prem, or Azure SQL Database /
+# Managed Instance (which report a legacy ProductMajorVersion).
+SQLSERVER_2022_MAJOR_VERSION = 16
+AZURE_SQL_DATABASE_ENGINE_EDITION = 5
+AZURE_SQL_MANAGED_INSTANCE_ENGINE_EDITION = 8
+
+
 class SqlServerDataSourceImpl(DataSourceImpl, model_class=SqlServerDataSourceModel):
     def __init__(self, data_source_model: SqlServerDataSourceModel, connection: Optional[DataSourceConnection] = None):
         super().__init__(data_source_model=data_source_model, connection=connection)
+        # A live connection supplied at construction (e.g. a bulk-insert copy)
+        # already carries detected server facts; propagate them right away.
+        self._sync_dialect_server_info()
 
     def _create_sql_dialect(self) -> SqlDialect:
         return SqlServerSqlDialect()
@@ -64,11 +78,72 @@ class SqlServerDataSourceImpl(DataSourceImpl, model_class=SqlServerDataSourceMod
             name=self.data_source_model.name, connection_properties=self.data_source_model.connection_properties
         )
 
+    def open_connection(self) -> None:
+        super().open_connection()
+        self._sync_dialect_server_info()
+
+    def _sync_dialect_server_info(self) -> None:
+        """Copy the connection's detected engine facts onto the dialect, which
+        derives version-dependent capabilities from them (see
+        SqlServerSqlDialect.supports_percentile_within_group).
+
+        Runs at connection-open time only; the dialect must NOT read the connection
+        during SQL generation — in snapshot replay the connection is a lazy wrapper
+        whose attribute access opens a real connection, so touching it while
+        building SQL breaks replay.
+
+        Gate on the concrete connection type rather than duck-typing the attributes:
+        a replay SnapshotDataSourceConnection is NOT a SqlServerDataSourceConnection,
+        so isinstance() is False and we never touch its attributes (which would fire
+        its __getattr__ fallback and open a real connection). Replay then keeps the
+        dialect's None defaults (assume newest engine), which is exactly what
+        recorded snapshots expect.
+        """
+        conn = self.data_source_connection
+        if isinstance(conn, SqlServerDataSourceConnection):
+            # Guaranteed by every _create_sql_dialect in this hierarchy; the assert
+            # only narrows the declared SqlDialect type for the assignments.
+            assert isinstance(self.sql_dialect, SqlServerSqlDialect)
+            self.sql_dialect.server_major_version = conn.server_major_version
+            self.sql_dialect.engine_edition = conn.engine_edition
+
 
 class SqlServerSqlDialect(SqlDialect, sqlglot_dialect="tsql"):
     DEFAULT_QUOTE_CHAR = "["  # Do not use this! Always use quote_default()
     SODA_DATA_TYPE_SYNONYMS = ((SodaDataTypeName.TEXT, SodaDataTypeName.VARCHAR),)
 
+    def __init__(self):
+        super().__init__()
+        # Raw engine facts, synced from the live connection at open by
+        # SqlServerDataSourceImpl._sync_dialect_server_info. None means no live
+        # server facts (pure SQL rendering, unit tests, snapshot replay);
+        # capability checks then assume the newest engine.
+        self.server_major_version: Optional[int] = None
+        self.engine_edition: Optional[int] = None
+
+    def _build_stddev_samp_sql(self, stddev_samp) -> str:
+        # T-SQL names the sample standard deviation aggregate STDEV.
+        return f"STDEV({self.build_expression_sql(stddev_samp.expression)})"
+
+    def _build_var_samp_sql(self, var_samp) -> str:
+        # T-SQL names the sample variance aggregate VAR.
+        return f"VAR({self.build_expression_sql(var_samp.expression)})"
+
+    def supports_percentile_within_group(self) -> bool:
+        # T-SQL exposes percentiles as an aggregate only via APPROX_PERCENTILE_DISC:
+        # SQL Server 2022+ (ProductMajorVersion >= 16), Azure SQL Database, or Azure
+        # SQL Managed Instance (both report a legacy ProductMajorVersion, hence the
+        # edition check). Synapse dedicated pools have no percentile aggregate at
+        # all; the Synapse dialect pins this to False.
+        if self.server_major_version is None and self.engine_edition is None:
+            return True  # no live server facts: assume the newest engine
+        return (
+            self.server_major_version is not None and self.server_major_version >= SQLSERVER_2022_MAJOR_VERSION
+        ) or self.engine_edition in (
+            AZURE_SQL_DATABASE_ENGINE_EDITION,
+            AZURE_SQL_MANAGED_INSTANCE_ENGINE_EDITION,
+        )
+
     def build_select_sql(self, select_elements: list, add_semicolon: bool = True) -> str:
         statement_lines: list[str] = []
         statement_lines.extend(self._build_cte_sql_lines(select_elements))
@@ -120,8 +195,7 @@ class SqlServerSqlDialect(SqlDialect, sqlglot_dialect="tsql"):
 
     def literal_date(self, date: date):
         """Technically dates can be passed directly as strings, but this is more explicit."""
-        date_string = date.strftime("%Y-%m-%d")
-        return f"CAST('{date_string}' AS DATE)"
+        return f"CAST('{date.isoformat()}' AS DATE)"
 
     def literal_datetime(self, datetime: datetime):
         return f"'{datetime.isoformat(timespec='milliseconds')}'"
@@ -177,6 +251,50 @@ class SqlServerSqlDialect(SqlDialect, sqlglot_dialect="tsql"):
     def sql_expr_timestamp_add_day(self, timestamp_literal: str) -> str:
         return f"DATEADD(DAY, 1, {timestamp_literal})"
 
+    def literal_timestamp_typed(self, dt: datetime) -> str:
+        """T-SQL has no TIMESTAMP '...' literal (TIMESTAMP is the deprecated
+        rowversion type), so cast the string form to DATETIME2 to keep the
+        arithmetic operand typed —
+        https://learn.microsoft.com/en-us/sql/t-sql/data-types/datetime2-transact-sql."""
+        return f"CAST('{self._typed_timestamp_str(dt)}' AS DATETIME2)"
+
+    # Singular unit names for DATEADD.
+    _TIME_BUCKET_UNIT_NAMES: dict = {
+        "weeks": "WEEK",
+        "days": "DAY",
+        "hours": "HOUR",
+        "seconds": "SECOND",
+    }
+
+    def _build_time_delta_sql(self, time_delta: TIME_DELTA) -> str:
+        """T-SQL DATEDIFF counts crossed boundaries of the given unit, so
+        compute the difference in SECONDS and divide by the seconds-per-
+        interval. T-SQL int/int division truncates toward zero, which equals
+        the FLOOR of the other dialects only for deltas >= 0 — callers must
+        guarantee non-negative deltas (the MM window filter does).
+
+        DATEDIFF(second, ...) returns int and overflows for spans > ~68
+        years; switch to DATEDIFF_BIG if that ever bites."""
+        start_sql: str = self.build_expression_sql(time_delta.start)
+        end_sql: str = self.build_expression_sql(time_delta.end)
+        multiplier: int = seconds_per_time_bucket(time_delta.unit, time_delta.count)
+        # Parenthesized so the form stays self-contained if a caller embeds
+        # TIME_DELTA in larger arithmetic (every other dialect wraps in FLOOR/cast).
+        return f"(DATEDIFF(second, {start_sql}, {end_sql}) / {multiplier})"
+
+    def _build_add_interval_sql(self, add_interval: ADD_INTERVAL) -> str:
+        timestamp_sql: str = self.build_expression_sql(add_interval.timestamp)
+        count_sql: str = self.build_expression_sql(add_interval.count_expression)
+        unit_name: str = self._TIME_BUCKET_UNIT_NAMES[add_interval.unit]
+        return f"DATEADD({unit_name}, {count_sql}, {timestamp_sql})"
+
+    def _build_percentile_within_group_sql(self, percentile_within_group: PERCENTILE_WITHIN_GROUP) -> str:
+        """T-SQL PERCENTILE_DISC is a window function only; the aggregate form
+        is APPROX_PERCENTILE_DISC (SQL Server 2022+/Azure SQL/Fabric,
+        https://learn.microsoft.com/en-us/sql/t-sql/functions/approx-percentile-disc-transact-sql)."""
+        expression_sql: str = self.build_expression_sql(percentile_within_group.expression)
+        return f"APPROX_PERCENTILE_DISC({percentile_within_group.percentile}) WITHIN GROUP (ORDER BY {expression_sql})"
+
     def _build_tuple_sql(self, tuple: TUPLE) -> str:
         if tuple.check_context(COUNT) and tuple.check_context(DISTINCT):
             return f"CHECKSUM{super()._build_tuple_sql(tuple)}"

{soda_sqlserver-4.17.1 → soda_sqlserver-4.19.0}/src/soda_sqlserver/common/data_sources/sqlserver_data_source_connection.py

@@ -107,6 +107,10 @@ def handle_datetimeoffset(dto_value):
 
 class SqlServerDataSourceConnection(DataSourceConnection):
     def __init__(self, name: str, connection_properties: DataSourceConnectionProperties):
+        # Set before super().__init__(), which auto-opens the connection and
+        # populates these from the live server in _create_connection.
+        self.server_major_version: Optional[int] = None
+        self.engine_edition: Optional[int] = None
         super().__init__(name, connection_properties)
 
     # Normalize pyodbc.Row objects so downstream consumers see plain tuples.
@@ -190,10 +194,43 @@ class SqlServerDataSourceConnection(DataSourceConnection):
 
             self.connection.add_output_converter(-155, handle_datetimeoffset)
             self.connection.add_output_converter(-150, handle_datetime)
+            self._detect_server_info(self.connection)
             return self.connection
         except Exception as e:
             raise DataSourceConnectionException(e) from e
 
+    @staticmethod
+    def _parse_server_major_version(dbms_version: Optional[str]) -> Optional[int]:
+        """Parse the leading integer of an ODBC SQL_DBMS_VER string, e.g. '15.00.4123' -> 15."""
+        if not dbms_version:
+            return None
+        try:
+            return int(str(dbms_version).split(".")[0])
+        except (ValueError, IndexError):
+            return None
+
+    def _detect_server_info(self, connection) -> None:
+        """Detect raw engine facts once per connect; the data source syncs them onto
+        the dialect, which derives version-dependent capabilities from them (e.g.
+        APPROX_PERCENTILE_DISC needs SQL Server 2022+ or Azure SQL DB/MI).
+
+        The product version comes from the driver's login handshake — no extra
+        round-trip; EngineEdition costs one query. Detection is never fatal for an
+        otherwise healthy connect: on failure a warning is logged and the fact stays
+        None, which capability checks treat as "assume the newest engine".
+        """
+        try:
+            self.server_major_version = self._parse_server_major_version(connection.getinfo(pyodbc.SQL_DBMS_VER))
+        except Exception as e:
+            logger.warning(f"Could not determine SQL Server product version: {e}")
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT CAST(SERVERPROPERTY('EngineEdition') AS INT)")
+                row = cursor.fetchone()
+            self.engine_edition = row[0] if row is not None else None
+        except Exception as e:
+            logger.warning(f"Could not determine SQL Server engine edition: {e}")
+
     def _execute_query_get_result_row_column_name(self, column) -> str:
         return column[0]
 

{soda_sqlserver-4.17.1 → soda_sqlserver-4.19.0}/src/soda_sqlserver.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: soda-sqlserver
-Version: 4.17.1
+Version: 4.19.0
 Summary: Soda SQL Server V4
 Author-email: "Soda Data N.V." <info@soda.io>
 License: Proprietary
 Requires-Python: >=3.10
-Requires-Dist: soda-core==4.17.1
+Requires-Dist: soda-core==4.19.0
 Requires-Dist: pyodbc

soda_sqlserver-4.19.0/src/soda_sqlserver.egg-info/requires.txt

@@ -0,0 +1,2 @@
+soda-core==4.19.0
+pyodbc

soda_sqlserver-4.17.1/src/soda_sqlserver.egg-info/requires.txt

@@ -1,2 +0,0 @@
-soda-core==4.17.1
-pyodbc