sqlspec 0.70.1__py3-none-any.whl → 0.71.0__py3-none-any.whl

sqlspec/adapters/oracledb/driver.py

@@ -1251,10 +1251,15 @@ class OracleSyncDriver(OraclePipelineMixin, SyncDriverAdapterBase):
                 batch_table = coerce_oracle_df_to_arrow_table(oracle_df, import_pyarrow())
                 column_names = normalize_column_names(batch_table.column_names, self.driver_features)
                 if column_names != batch_table.column_names:
-                    batch_table = batch_table.rename_columns(column_names)
+                    batch_table = batch_table.rename_columns(column_names).replace_schema_metadata(
+                        batch_table.schema.metadata
+                    )
                 if arrow_schema is not None:
                     batch_table = batch_table.cast(arrow_schema)
-                yield from batch_table.to_batches()
+                if batch_table.num_rows:
+                    yield from batch_table.to_batches()
+                else:
+                    yield import_pyarrow().RecordBatch.from_pylist([], schema=batch_table.schema)
         except OracleError as exc:
             raise create_mapped_exception(exc) from exc
 
@@ -1760,7 +1765,7 @@ class OracleAsyncDriver(OraclePipelineMixin, AsyncDriverAdapterBase):
                 rows_affected = sum(batch.num_rows for batch in record_batches)
                 pa = import_pyarrow()
                 if batch_schema is None:
-                    batch_schema = pa.schema([])
+                    batch_schema = arrow_schema if arrow_schema is not None else pa.schema([])
                 arrow_data: object
                 if return_format == "reader":
                     arrow_data = pa.RecordBatchReader.from_batches(batch_schema, record_batches)

sqlspec/adapters/sybase/adk/store.py

@@ -370,15 +370,15 @@ class SybaseADKStore(BaseSyncADKStore["SybaseConfig"]):
 
     def _drop_app_states_table_sql(self) -> str:
         ref = escape_sql_literal(_table_ref(self._app_state_table))
-        return f"IF OBJECT_ID('{ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
+        return f"IF OBJECT_ID('{ref}') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
 
     def _drop_user_states_table_sql(self) -> str:
         ref = escape_sql_literal(_table_ref(self._user_state_table))
-        return f"IF OBJECT_ID('{ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
+        return f"IF OBJECT_ID('{ref}') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
 
     def _drop_metadata_table_sql(self) -> str:
         ref = escape_sql_literal(_table_ref(self._metadata_table))
-        return f"IF OBJECT_ID('{ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
+        return f"IF OBJECT_ID('{ref}') IS NOT NULL EXECUTE('DROP TABLE {ref}')"
 
     def _drop_tables_sql(self) -> "list[str]":
         events_ref = escape_sql_literal(_table_ref(self._events_table))
@@ -387,8 +387,8 @@ class SybaseADKStore(BaseSyncADKStore["SybaseConfig"]):
             self._drop_metadata_table_sql(),
             self._drop_user_states_table_sql(),
             self._drop_app_states_table_sql(),
-            f"IF OBJECT_ID('{events_ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {events_ref}')",
-            f"IF OBJECT_ID('{sessions_ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {sessions_ref}')",
+            f"IF OBJECT_ID('{events_ref}') IS NOT NULL EXECUTE('DROP TABLE {events_ref}')",
+            f"IF OBJECT_ID('{sessions_ref}') IS NOT NULL EXECUTE('DROP TABLE {sessions_ref}')",
         ]
 
     def _upsert_app_state_sql(self) -> str:
@@ -540,15 +540,14 @@ class SybaseADKMemoryStore(BaseSyncADKMemoryStore["SybaseConfig"]):
         where_scope, scope_params = _build_sybase_scope_where(app_name, user_id, scope_filter)
         escaped_query = _escape_like_pattern(query)
         sql = f"""
-        SELECT
+        SELECT TOP %s
             id, session_id, app_name, user_id, scope, event_id, author, timestamp,
             content_json, content_text, metadata_json, inserted_at
         FROM {_table_ref(self._memory_table)}
         WHERE {where_scope} AND content_text LIKE %s ESCAPE '\\'
         ORDER BY timestamp DESC
-        ROWS LIMIT %s
         """
-        rows = self._execute_fetchall(sql, (*scope_params, f"%{escaped_query}%", limit_value))
+        rows = self._execute_fetchall(sql, (limit_value, *scope_params, f"%{escaped_query}%"))
         return [_memory_record_from_row(row) for row in rows]
 
     def delete_entries_by_session(self, session_id: str) -> int:
@@ -594,7 +593,7 @@ class SybaseADKMemoryStore(BaseSyncADKMemoryStore["SybaseConfig"]):
             f"CONSTRAINT {_constraint_ref('uq', self._memory_table, 'event_id')} UNIQUE (event_id)"
             ")"
         )
-        return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+        return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
     def _memory_index_specs(self) -> "list[tuple[str, str, str]]":
         """Return ``(index_name, table, columns)`` specs for memory-table indexes."""
@@ -608,7 +607,7 @@ class SybaseADKMemoryStore(BaseSyncADKMemoryStore["SybaseConfig"]):
 
     def _drop_memory_table_sql(self) -> "list[str]":
         ref = escape_sql_literal(_table_ref(self._memory_table))
-        return [f"IF OBJECT_ID('{ref}', 'U') IS NOT NULL EXECUTE('DROP TABLE {ref}')"]
+        return [f"IF OBJECT_ID('{ref}') IS NOT NULL EXECUTE('DROP TABLE {ref}')"]
 
     def _execute_fetchall(self, sql: str, params: "tuple[Any, ...]" = ()) -> "list[Any]":
         with self._config.provide_connection() as conn, SybaseCursor(conn, as_dict=False) as cursor:
@@ -656,7 +655,7 @@ def _sessions_table_ddl(table: str, json_column_type: str, owner_id_column_ddl:
         f"CONSTRAINT {_constraint_ref('pk', table, 'id')} PRIMARY KEY (id)"
         ")"
     )
-    return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+    return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
 
 def _sessions_index_specs(table: str) -> "list[tuple[str, str, str]]":
@@ -684,7 +683,7 @@ def _events_table_ddl(table: str, session_table: str, json_column_type: str) ->
         f"CONSTRAINT {_constraint_ref('fk', table, 'session')} FOREIGN KEY (session_id) REFERENCES {session_ref}(id)"
         ")"
     )
-    return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+    return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
 
 def _events_index_specs(table: str) -> "list[tuple[str, str, str]]":
@@ -709,7 +708,7 @@ def _app_states_table_ddl(table: str, json_column_type: str) -> str:
         f"CONSTRAINT {_constraint_ref('pk', table, 'app_name')} PRIMARY KEY (app_name)"
         ")"
     )
-    return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+    return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
 
 def _user_states_table_ddl(table: str, json_column_type: str) -> str:
@@ -724,7 +723,7 @@ def _user_states_table_ddl(table: str, json_column_type: str) -> str:
         f"CONSTRAINT {_constraint_ref('pk', table, 'app_user')} PRIMARY KEY (app_name, user_id)"
         ")"
     )
-    return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+    return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
 
 def _metadata_table_ddl(table: str) -> str:
@@ -737,7 +736,7 @@ def _metadata_table_ddl(table: str) -> str:
         f"CONSTRAINT {_constraint_ref('pk', table, 'key')} PRIMARY KEY ([key])"
         ")"
     )
-    return f"IF OBJECT_ID('{escaped_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+    return f"IF OBJECT_ID('{escaped_ref}') IS NULL EXECUTE('{create_sql}');"
 
 
 def _create_index_sql(table: str, index_name: str, columns: str) -> str:
@@ -794,15 +793,15 @@ def _events_query(
     if after_timestamp is not None:
         after_clause = " AND timestamp > %s"
         params.append(after_timestamp)
-    limit_clause = ""
+    top_clause = ""
     if limit is not None:
-        limit_clause = "\n    ROWS LIMIT %s"
-        params.append(limit)
+        top_clause = "TOP %s "
+        params.insert(0, limit)
     sql = f"""
-    SELECT id, app_name, user_id, session_id, invocation_id, timestamp, event_data
+    SELECT {top_clause}id, app_name, user_id, session_id, invocation_id, timestamp, event_data
     FROM {_table_ref(table)}
     WHERE app_name = %s AND user_id = %s AND session_id = %s{after_clause}
-    ORDER BY timestamp ASC{limit_clause}
+    ORDER BY timestamp ASC
     """
     return sql, tuple(params)
 
@@ -947,13 +946,17 @@ def _session_list_query(
         params.append(user_id)
         where_clause = f"{where_clause} AND user_id = %s"
 
+    top_clause = ""
     page_clause = ""
-    if limit is not None:
+    if limit is not None and offset == 0:
+        top_clause = "TOP %s "
+        params.insert(0, limit)
+    elif limit is not None:
         params.extend((limit, offset))
         page_clause = "\n    ROWS LIMIT %s OFFSET %s"
 
     sql = f"""
-    SELECT id, app_name, user_id, state, create_time, update_time
+    SELECT {top_clause}id, app_name, user_id, state, create_time, update_time
     FROM {_table_ref(session_table)}
     WHERE {where_clause}
     ORDER BY {column} {direction}, id {direction}{page_clause}

sqlspec/adapters/sybase/config.py

@@ -38,9 +38,11 @@ class SybaseConnectionParams(TypedDict):
     host: NotRequired[str]
     """Alias for ``server``."""
     freetds_server: NotRequired[str]
-    """FreeTDS server configuration section name."""
+    """FreeTDS server configuration section name; requires an explicit port."""
     server_alias: NotRequired[str]
-    """Alias for ``server``."""
+    """FreeTDS server configuration section name; requires an explicit port."""
+    is_server_alias: NotRequired[bool]
+    """Treat ``server`` as a FreeTDS configuration section name; requires an explicit port."""
     user: NotRequired[str]
     """Login user name."""
     username: NotRequired[str]
@@ -52,7 +54,7 @@ class SybaseConnectionParams(TypedDict):
     db: NotRequired[str]
     """Alias for ``database``."""
     port: NotRequired[int | str]
-    """TCP port number of the Sybase ASE server."""
+    """TCP port number; required for section aliases, otherwise defaults to 5000."""
     timeout: NotRequired[SybaseTimeout]
     """Query execution timeout in seconds."""
     login_timeout: NotRequired[SybaseTimeout]
@@ -64,7 +66,7 @@ class SybaseConnectionParams(TypedDict):
     appname: NotRequired[str]
     """Application name sent to the server for connection identification."""
     conn_properties: NotRequired[str]
-    """Additional connection properties string."""
+    """Session initialization SQL; replaces the default connection properties when supplied."""
     autocommit: NotRequired[bool]
     """Enable autocommit mode for transactions."""
     tds_version: NotRequired[str]
@@ -76,11 +78,11 @@ class SybaseConnectionParams(TypedDict):
     conv: NotRequired[Mapping[int | type[Any], Callable[..., Any]]]
     """Custom datatype conversion dictionary mapping TDS types to python types."""
     read_only: NotRequired[bool]
-    """Enforce read-only transactions on connections."""
+    """Native pymssql login intent; does not enforce ASE read-only permissions."""
     pool_recycle_seconds: NotRequired[int]
     """Maximum age in seconds before a pooled connection is recycled."""
     health_check_interval: NotRequired[float]
-    """Interval in seconds between background health checks."""
+    """Idle duration in seconds before a connection is checked on checkout."""
     extra: NotRequired["dict[str, Any]"]
     """Additional driver connection arguments."""
 

sqlspec/adapters/sybase/core.py

@@ -58,7 +58,9 @@ __all__ = (
     "split_schema_and_table",
 )
 
-DEFAULT_SYBASE_CONN_PROPERTIES: Final[str] = "SET QUOTED_IDENTIFIER ON; SET ANSINULL ON; SET TEXTSIZE 2147483647;"
+DEFAULT_SYBASE_CONN_PROPERTIES: Final[str] = (
+    "SET CHAINED OFF; SET QUOTED_IDENTIFIER ON; SET ANSINULL ON; SET TEXTSIZE 2147483647;"
+)
 DEFAULT_SYBASE_TDS_VERSION: Final[str] = "5.0"
 
 _ERROR_NUMBER_PATTERN: Final[re.Pattern[str]] = re.compile(r"(?:\(([-]?\d+)(?:,|\))|\bMsg\s+([-]?\d+)\b)")
@@ -342,11 +344,10 @@ def extract_error_number(exc: BaseException | None) -> int | None:
 def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str, Any]":
     """Build a normalized Sybase ASE connection configuration dictionary.
 
-    Injects ``DEFAULT_SYBASE_CONN_PROPERTIES``, ``autocommit=True``, ``port=5000``,
-    and ``charset='UTF-8'`` by default, and strips ``tds_version`` into
-    ``_sybase_tds_version`` so ``SybaseConnectionPool`` can negotiate TDS 5.0
-    via ``os.environ['TDSVER']`` without triggering ``pymssql._mssql``'s Cython
-    ``tds_version`` validator.
+    Host connections default to port 5000. FreeTDS section aliases retain an
+    explicit port and a private marker for pool validation. Session properties,
+    autocommit and charset receive ASE defaults unless supplied by the caller.
+    The pool validates protocol configuration without modifying ``TDSVER``.
 
     Args:
         connection_config: Raw connection configuration mapping.
@@ -360,8 +361,19 @@ def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str
         for extra_key, extra_value in extra.items():
             if extra_value is not None:
                 config.setdefault(str(extra_key), extra_value)
+    freetds_server = config.pop("freetds_server", None)
+    server_alias = config.pop("server_alias", None)
+    alias_flag = config.pop("is_server_alias", False)
+    is_server_alias = bool(config.pop("_sybase_server_alias", False) or alias_flag)
+    alias = freetds_server or server_alias
+    if alias:
+        config["server"] = alias
+        is_server_alias = True
     config.setdefault("server", config.pop("host", "localhost"))
-    config.setdefault("port", 5000)
+    if is_server_alias:
+        config["_sybase_server_alias"] = True
+    else:
+        config.setdefault("port", 5000)
     config.setdefault("charset", "UTF-8")
     config.setdefault("autocommit", True)
     config.setdefault("conn_properties", DEFAULT_SYBASE_CONN_PROPERTIES)

sqlspec/adapters/sybase/data_dictionary.py

@@ -11,7 +11,11 @@ from sqlspec.data_dictionary import (
     IndexMetadata,
     MetadataCapabilityProfile,
     MetadataResult,
+    MetadataSource,
+    ObjectIdentity,
     TableMetadata,
+    dependency_edges_from_foreign_keys,
+    sort_dependencies,
 )
 from sqlspec.data_dictionary.dialects.sybase import (
     SYBASE_CONFIG,
@@ -65,28 +69,56 @@ def build_column_metadata(rows: "Iterable[dict[str, Any]]") -> "list[ColumnMetad
             table_name=str(r.get("table_name", "")),
             column_name=str(r.get("column_name", "")),
             data_type=str(r.get("data_type", "")),
-            is_nullable=bool(r.get("is_nullable", True)),
+            is_nullable=_catalog_flag(r.get("is_nullable", True)),
             column_default=str(r["column_default"]) if r.get("column_default") is not None else None,
             ordinal_position=int(r.get("ordinal_position", 1)),
             max_length=int(r.get("max_length", 0)) if r.get("max_length") is not None else 0,
             numeric_precision=int(r.get("numeric_precision", 0)) if r.get("numeric_precision") is not None else 0,
             numeric_scale=int(r.get("numeric_scale", 0)) if r.get("numeric_scale") is not None else 0,
-            is_primary=bool(r.get("is_primary")),
-            is_unique=bool(r.get("is_unique")),
-            is_identity=bool(r.get("is_identity")),
+            is_primary=_catalog_flag(r.get("is_primary")),
+            is_unique=_catalog_flag(r.get("is_unique")),
+            is_identity=_catalog_flag(r.get("is_identity")),
             identity_generation=str(r["identity_generation"])
             if r.get("identity_generation")
-            else ("ALWAYS" if r.get("is_identity") else None),
-            is_generated=bool(r.get("is_generated")),
+            else ("ALWAYS" if _catalog_flag(r.get("is_identity")) else None),
+            is_generated=_catalog_flag(r.get("is_generated")),
             generation_expression=str(r["generation_expression"])
             if r.get("generation_expression") is not None
             else None,
-            is_hidden=bool(r.get("is_hidden")),
+            is_hidden=_catalog_flag(r.get("is_hidden")),
+        )
+        for r in _merge_definition_rows(
+            rows, ("schema_name", "table_name", "column_name"), ("column_default", "generation_expression")
         )
-        for r in rows
     ]
 
 
+def _catalog_flag(value: object) -> bool:
+    if isinstance(value, str):
+        return value.strip().upper() in {"YES", "Y", "TRUE", "1"}
+    return bool(value)
+
+
+def _merge_definition_rows(
+    rows: "Iterable[dict[str, Any]]", identity_fields: "tuple[str, ...]", text_fields: "tuple[str, ...]"
+) -> "list[dict[str, Any]]":
+    """Assemble catalog definition chunks without changing their whitespace or multiplicity."""
+    chunk_fields = ("_definition_id", "_definition_number", "_definition_colid2", "_definition_colid")
+    grouped: dict[tuple[Any, ...], list[dict[str, Any]]] = {}
+    for row in rows:
+        key = tuple(row.get(field) for field in identity_fields)
+        grouped.setdefault(key, []).append(row)
+    result: list[dict[str, Any]] = []
+    for chunks in grouped.values():
+        ordered = sorted(chunks, key=lambda row: tuple(int(row.get(field) or 0) for field in chunk_fields))
+        merged = {field: value for field, value in ordered[0].items() if field not in chunk_fields}
+        for field in text_fields:
+            parts = [str(row[field]) for row in ordered if row.get(field) is not None]
+            merged[field] = "".join(parts) if parts else None
+        result.append(merged)
+    return result
+
+
 def build_index_metadata(rows: "Iterable[dict[str, Any]]") -> "list[IndexMetadata]":
     """Group per-column Sybase sysindexes rows into index metadata."""
     indexes_map: dict[tuple[str, str, str], dict[str, Any]] = {}
@@ -198,7 +230,43 @@ class SybaseSyncDataDictionary(SyncDataDictionaryBase):
                 schema_type=TableMetadata,
             ),
         )
-        return merge_sybase_table_lists(ordered_rows, all_rows)
+        rows = merge_sybase_table_lists(ordered_rows, all_rows)
+        table_rows = {
+            ObjectIdentity(
+                row["table_name"],
+                "table",
+                schema=row.get("schema_name"),
+                dialect="sybase",
+                source=MetadataSource.CATALOG,
+            ): row
+            for row in rows
+            if row.get("table_name") and row.get("table_type", "TABLE").upper() != "VIEW"
+        }
+        if not table_rows:
+            return rows
+        identities = sorted(table_rows, key=lambda node: (node.schema or "", node.name))
+        edges = tuple(
+            edge
+            for edge in dependency_edges_from_foreign_keys(
+                self.get_foreign_keys(driver, schema=schema_name), dialect="sybase"
+            )
+            if edge.from_object in table_rows and edge.to_object in table_rows
+        )
+        dependencies: dict[ObjectIdentity, set[ObjectIdentity]] = {node: set() for node in identities}
+        for edge in edges:
+            dependencies[edge.from_object].add(edge.to_object)
+        ordered = sort_dependencies(identities, edges).ordered
+        levels: dict[ObjectIdentity, int] = {}
+        result: list[TableMetadata] = []
+        for node in ordered:
+            level = max((levels[parent] + 1 for parent in dependencies[node]), default=0)
+            levels[node] = level
+            result.append({**table_rows[node], "dependency_level": level, "level": level})
+        result.extend(
+            {**table_rows[node], "dependency_level": 0, "level": 0} for node in identities if node not in levels
+        )
+        result.extend(row for row in rows if row.get("table_type", "TABLE").upper() == "VIEW")
+        return result
 
     def get_columns(
         self, driver: "SybaseDriver", table: str | None = None, schema: str | None = None
@@ -255,14 +323,23 @@ class SybaseSyncDataDictionary(SyncDataDictionaryBase):
         table_name = self.resolve_identifier(table) if table is not None else None
         query = self.get_query("constraints", "by_table" if table_name else "by_schema")
         rows = driver.select(query, schema_name=schema_name, table_name=table_name)
-        return MetadataResult("constraints", items=tuple(rows))
+        return MetadataResult(
+            "constraints",
+            items=tuple(
+                _merge_definition_rows(
+                    rows, ("schema_name", "table_name", "constraint_name", "constraint_type"), ("check_clause",)
+                )
+            ),
+        )
 
     def get_views(self, driver: "SybaseDriver", schema: str | None = None) -> MetadataResult:
         """Get Sybase ASE view metadata."""
         schema_name = self.resolve_schema(schema)
         query = self.get_query("views", "by_schema")
         rows = driver.select(query, schema_name=schema_name, view_name=None)
-        return MetadataResult("views", items=tuple(rows))
+        return MetadataResult(
+            "views", items=tuple(_merge_definition_rows(rows, ("schema_name", "view_name"), ("definition",)))
+        )
 
     def get_objects(self, driver: "SybaseDriver", schema: "str | None" = None) -> MetadataResult:
         """Get tables, views, and procedures from the Sybase ASE catalog."""

sqlspec/adapters/sybase/events/store.py

@@ -1,7 +1,7 @@
 """Sybase ASE event queue store with ASE-compatible DDL."""
 
 from sqlspec.adapters.sybase.config import SybaseConfig
-from sqlspec.adapters.sybase.core import escape_sql_literal, quote_bracket_identifier, split_schema_and_table
+from sqlspec.adapters.sybase.core import escape_sql_literal, format_identifier
 from sqlspec.extensions.events import BaseEventQueueStore
 
 __all__ = ("SybaseEventQueueStore",)
@@ -57,10 +57,10 @@ class SybaseEventQueueStore(BaseEventQueueStore[SybaseConfig]):
         )
 
     def _wrap_create_statement(self, statement: str, object_type: str) -> str:
-        object_name = escape_sql_literal(_object_name(self.table_name))
+        object_name = escape_sql_literal(format_identifier(self.table_name))
         escaped_statement = escape_sql_literal(statement.rstrip().rstrip(";"))
         if object_type == "table":
-            return f"IF OBJECT_ID('{object_name}', 'U') IS NULL EXECUTE('{escaped_statement}')"
+            return f"IF OBJECT_ID('{object_name}') IS NULL EXECUTE('{escaped_statement}')"
         if object_type == "index":
             index_name = escape_sql_literal(self._index_name())
             return (
@@ -70,11 +70,6 @@ class SybaseEventQueueStore(BaseEventQueueStore[SybaseConfig]):
         return statement
 
     def _wrap_drop_statement(self, statement: str) -> str:
-        object_name = escape_sql_literal(_object_name(self.table_name))
+        object_name = escape_sql_literal(format_identifier(self.table_name))
         escaped_statement = escape_sql_literal(statement.rstrip().rstrip(";"))
-        return f"IF OBJECT_ID('{object_name}', 'U') IS NOT NULL EXECUTE('{escaped_statement}');"
-
-
-def _object_name(table_name: str) -> str:
-    schema_name, bare_table_name = split_schema_and_table(table_name)
-    return f"{quote_bracket_identifier(schema_name)}.{quote_bracket_identifier(bare_table_name)}"
+        return f"IF OBJECT_ID('{object_name}') IS NOT NULL EXECUTE('{escaped_statement}');"

sqlspec/adapters/sybase/litestar/store.py

@@ -83,7 +83,7 @@ class SybaseStore(BaseSQLSpecStore["SybaseConfig"]):
         )
         create_index_sql = escape_sql_literal(f"CREATE INDEX {index_name} ON {table_ref}(expires_at)")
         return (
-            f"IF OBJECT_ID('{escaped_table_ref}', 'U') IS NULL EXECUTE('{create_table_sql}');\n"
+            f"IF OBJECT_ID('{escaped_table_ref}') IS NULL EXECUTE('{create_table_sql}');\n"
             f"IF NOT EXISTS (SELECT 1 FROM dbo.sysindexes WHERE name = '{escaped_index_bare}' "
             f"AND id = OBJECT_ID('{escaped_table_ref}')) EXECUTE('{create_index_sql}');"
         )
@@ -92,7 +92,7 @@ class SybaseStore(BaseSQLSpecStore["SybaseConfig"]):
         """Get Sybase ASE DROP TABLE statements."""
         table_ref = _table_ref(self._table_name)
         escaped = escape_sql_literal(table_ref)
-        return [f"IF OBJECT_ID('{escaped}', 'U') IS NOT NULL EXECUTE('DROP TABLE {escaped}');"]
+        return [f"IF OBJECT_ID('{escaped}') IS NOT NULL EXECUTE('DROP TABLE {escaped}');"]
 
     def _create_table(self) -> None:
         with self._config.provide_session() as driver:

sqlspec/adapters/sybase/migrations.py

@@ -55,7 +55,7 @@ class SybaseMigrationTrackerMixin:
         """Wrap CREATE TABLE in a Sybase ASE OBJECT_ID existence probe with dynamic EXECUTE."""
         table_ref = escape_sql_literal(format_identifier(self.version_table))
         create_sql = escape_sql_literal(self._tracking_table_ddl_text().rstrip().rstrip(";"))
-        return f"IF OBJECT_ID('{table_ref}', 'U') IS NULL EXECUTE('{create_sql}');"
+        return f"IF OBJECT_ID('{table_ref}') IS NULL EXECUTE('{create_sql}');"
 
     def _tracking_table_ddl_text(self) -> str:
         """Render CREATE TABLE text with Sybase ASE native column types."""

sqlspec/adapters/sybase/pool.py

@@ -1,4 +1,4 @@
-"""Sybase ASE connection pool with thread-locked TDSVER='5.0' negotiation."""
+"""Sybase ASE thread-local connection pool with TDS 5.0 configuration validation."""
 
 import contextlib
 import logging
@@ -9,7 +9,7 @@ from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any, cast
 
 from sqlspec.adapters.sybase._typing import PYMSSQL_MODULE, SybaseConnection
-from sqlspec.adapters.sybase.core import DEFAULT_SYBASE_CONN_PROPERTIES, DEFAULT_SYBASE_TDS_VERSION
+from sqlspec.adapters.sybase.core import DEFAULT_SYBASE_TDS_VERSION, build_connection_config
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.utils.logging import POOL_LOGGER_NAME, get_logger, log_with_context
 from sqlspec.utils.uuids import uuid4
@@ -51,15 +51,19 @@ class SybaseConnectionPool:
         """Initialize the thread-local Sybase ASE connection manager.
 
         Args:
-            connection_parameters: Normalized Sybase connection parameters.
+            connection_parameters: Raw or normalized Sybase connection parameters.
             recycle_seconds: Connection recycle time in seconds (default 24h).
             health_check_interval: Seconds of idle time before running health check.
             on_connection_create: Callback executed when a connection is created.
         """
-        params = dict(connection_parameters)
-        freetds_alias = params.get("freetds_server") or params.get("server_alias") or params.get("is_server_alias")
-        if freetds_alias and isinstance(freetds_alias, str):
-            params["server"] = freetds_alias
+        params = build_connection_config(connection_parameters)
+        freetds_alias = params.pop("_sybase_server_alias", False)
+        if freetds_alias and params.get("port") in (None, "", 0, "0"):
+            msg = (
+                "FreeTDS server aliases require an explicit nonzero port: "
+                "pymssql overrides the port configured in freetds.conf."
+            )
+            raise ImproperConfigurationError(msg)
         tdsver = os.environ.get("TDSVER")
         if not freetds_alias and tdsver != "5.0":
             msg = (
@@ -71,8 +75,6 @@ class SybaseConnectionPool:
         self._tds_version = str(
             params.pop("_sybase_tds_version", params.pop("tds_version", DEFAULT_SYBASE_TDS_VERSION))
         )
-        params.setdefault("conn_properties", DEFAULT_SYBASE_CONN_PROPERTIES)
-        params.setdefault("autocommit", True)
         self._connection_parameters = params
         self._thread_local = threading.local()
         self._connection_registry: set[SybaseConnection] = set()
@@ -110,14 +112,18 @@ class SybaseConnectionPool:
         Yields:
             A thread-local database connection.
         """
+        depth = getattr(self._thread_local, "depth", 0)
         connection = self.acquire()
+        self._thread_local.depth = depth + 1
         try:
             yield connection
         except Exception:
-            with contextlib.suppress(Exception):
-                self._close_thread_connection()
+            if getattr(self._thread_local, "depth", 1) <= 1:
+                with contextlib.suppress(Exception):
+                    self._close_thread_connection()
             raise
         finally:
+            self._thread_local.depth = max(0, getattr(self._thread_local, "depth", 1) - 1)
             self.release(connection)
 
     def close(self) -> None:

sqlspec/core/result/_base.py

@@ -994,7 +994,10 @@ class ArrowResult(StatementResult):
             raise ValueError(msg)
         active_pipeline = pipeline or SyncStoragePipeline()
         if hasattr(self.data, "to_batches") or hasattr(self.data, "iter_batches") or hasattr(self.data, "__iter__"):
-            _cols, batch_iter = coerce_arrow_batches(self.data)
+            if hasattr(self.data, "__arrow_c_stream__"):
+                batch_iter = self.data
+            else:
+                _cols, batch_iter = coerce_arrow_batches(self.data)
             return active_pipeline.write_arrow_batches(
                 destination,
                 batch_iter,
@@ -1021,7 +1024,10 @@ class ArrowResult(StatementResult):
             raise ValueError(msg)
         active_pipeline = pipeline or AsyncStoragePipeline()
         if hasattr(self.data, "to_batches") or hasattr(self.data, "iter_batches") or hasattr(self.data, "__iter__"):
-            _cols, batch_iter = coerce_arrow_batches(self.data)
+            if hasattr(self.data, "__arrow_c_stream__"):
+                batch_iter = self.data
+            else:
+                _cols, batch_iter = coerce_arrow_batches(self.data)
             return await active_pipeline.write_arrow_batches_async(
                 destination,
                 batch_iter,