e6data-python-connector 2.3.13rc1__tar.gz → 2.3.14__tar.gz

{e6data_python_connector-2.3.13rc1/e6data_python_connector.egg-info → e6data_python_connector-2.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.13rc1
+Version: 2.3.14
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -39,7 +39,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.13rc1-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.14-blue.svg)
 
 ## Introduction
 
@@ -324,6 +324,48 @@ query_id = '<query_id>'  # query id from execute function response.
 cursor.cancel(query_id)
 ```
 
+To get the status of a running or completed query:
+```python
+query_id = '<query_id>'  # query id from execute function response.
+status_response = cursor.status(query_id)
+
+# Check if query execution is complete
+is_complete = status_response.status  # Returns True when query is done, False if still running
+
+# Get the total row count
+row_count = status_response.rowCount  # Total number of rows in the result set
+
+print(f"Query complete: {is_complete}")
+print(f"Row count: {row_count}")
+```
+
+The `status()` method is useful for:
+- **Monitoring long-running queries**: Poll the status periodically to check if execution is complete
+- **Checking row counts**: Get the total number of rows without fetching all results
+- **Query progress tracking**: Integrate with monitoring systems or progress bars
+- **Conditional fetching**: Decide whether to fetch results based on completion status
+
+Example - Polling for query completion:
+```python
+import time
+
+cursor = conn.cursor(catalog_name=catalog_name)
+query_id = cursor.execute("SELECT * FROM large_table")
+
+# Poll until query is complete
+while True:
+    status_response = cursor.status(query_id)
+    if status_response.status:
+        print(f"Query complete! Total rows: {status_response.rowCount}")
+        break
+    else:
+        print("Query still running...")
+        time.sleep(1)  # Wait 1 second before checking again
+
+# Now fetch the results
+results = cursor.fetchall()
+```
+
 Switch database in an existing connection:
 ```python
 database = '<new_database_name>'  # Replace with the new database.

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.13rc1-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.14-blue.svg)
 
 ## Introduction
 
@@ -285,6 +285,48 @@ query_id = '<query_id>'  # query id from execute function response.
 cursor.cancel(query_id)
 ```
 
+To get the status of a running or completed query:
+```python
+query_id = '<query_id>'  # query id from execute function response.
+status_response = cursor.status(query_id)
+
+# Check if query execution is complete
+is_complete = status_response.status  # Returns True when query is done, False if still running
+
+# Get the total row count
+row_count = status_response.rowCount  # Total number of rows in the result set
+
+print(f"Query complete: {is_complete}")
+print(f"Row count: {row_count}")
+```
+
+The `status()` method is useful for:
+- **Monitoring long-running queries**: Poll the status periodically to check if execution is complete
+- **Checking row counts**: Get the total number of rows without fetching all results
+- **Query progress tracking**: Integrate with monitoring systems or progress bars
+- **Conditional fetching**: Decide whether to fetch results based on completion status
+
+Example - Polling for query completion:
+```python
+import time
+
+cursor = conn.cursor(catalog_name=catalog_name)
+query_id = cursor.execute("SELECT * FROM large_table")
+
+# Poll until query is complete
+while True:
+    status_response = cursor.status(query_id)
+    if status_response.status:
+        print(f"Query complete! Total rows: {status_response.rowCount}")
+        break
+    else:
+        print("Query still running...")
+        time.sleep(1)  # Wait 1 second before checking again
+
+# Now fetch the results
+results = cursor.fetchall()
+```
+
 Switch database in an existing connection:
 ```python
 database = '<new_database_name>'  # Replace with the new database.

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/e6data_python_connector/datainputstream.py

@@ -561,6 +561,10 @@ def get_column_from_chunk(vector: Vector) -> list:
                 value_array.append(vector.data.int64Data.data[
                                        row] if not vector.isConstantVector else vector.data.numericConstantData.data)
         elif d_type == VectorType.DATE:
+            # Use the JDBC-parity formatter so years > 9999 emit "+YYYYY-MM-DD"
+            # instead of raising. Per-row try/except keeps a single bad value
+            # from truncating the column (which previously cascaded to an
+            # IndexError in read_rows_from_chunk).
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
@@ -574,6 +578,9 @@ def get_column_from_chunk(vector: Vector) -> list:
                     _logger.error("Failed to parse DATE row=%s: %s", row, e)
                     value_array.append('Failed to parse.')
         elif d_type == VectorType.DATETIME:
+            # Default formatter knobs reproduce the prior datetime.isoformat
+            # output ("YYYY-MM-DDTHH:MM:SS.sss+HH:MM"). See DATE branch above
+            # for the rationale on per-row try/except.
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
@@ -632,6 +639,8 @@ def get_column_from_chunk(vector: Vector) -> list:
             for row in range(vector.size):
                 value_array.append(None)
         elif d_type == VectorType.TIMESTAMP_TZ:
+            # row_zone is scoped to the row (not the outer `zone`) so a
+            # per-row zone resolution doesn't leak into later iterations.
             for row in range(vector.size):
                 if get_null(vector, row):
                     value_array.append(None)
@@ -687,6 +696,10 @@ def get_column_from_chunk(vector: Vector) -> list:
         else:
             value_array.append(None)
     except Exception as e:
+        # Safety net: if anything escapes the per-row try/excepts above (or
+        # comes from a branch without one), pad value_array to vector.size so
+        # read_rows_from_chunk's columns[colIndex][rowIndex] access can never
+        # IndexError on a short column.
         _logger.error("get_column_from_chunk failed (vectorType=%s, parsed=%s/%s): %s",
                       d_type, len(value_array), vector.size, e)
         while len(value_array) < vector.size:

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/e6data_python_connector/date_time_utils.py

@@ -165,10 +165,20 @@ _SECONDS_PER_DAY = 86400
 
 def _civil_from_days(z):
     """
-    Convert days since 1970-01-01 to proleptic Gregorian (year, month, day).
+    Convert days since 1970-01-01 (UTC) to proleptic Gregorian (year, month, day).
 
-    Howard Hinnant's algorithm. Supports any year representable by a Python int,
-    so it does not overflow like datetime.fromtimestamp (capped at year 9999).
+    Howard Hinnant's algorithm
+    (http://howardhinnant.github.io/date_algorithms.html#civil_from_days).
+    Pure-integer math: works for any year representable by a Python int, so it
+    does not overflow like datetime.fromtimestamp (capped at year 9999). The
+    e6data engine emits dates that decode to years up to ~10^9 (matching Java's
+    LocalDate range); this is the only conversion path that can represent them.
+
+    Args:
+        z (int): Days since 1970-01-01 (negative = before epoch).
+
+    Returns:
+        tuple[int, int, int]: (year, month, day) in the proleptic Gregorian calendar.
     """
     z = z + 719468
     era = (z if z >= 0 else z - 146096) // 146097
@@ -185,7 +195,15 @@ def _civil_from_days(z):
 
 
 def _format_iso_year(year):
-    """Java LocalDate-style year: 0000-9999 unprefixed; outside range gets +/- prefix."""
+    """
+    Render the year component of an ISO-8601 date the way Java's
+    DateTimeFormatter.ISO_LOCAL_DATE does, so connector output matches the
+    e6data JDBC driver byte-for-byte:
+
+      - 0 <= year <= 9999  -> "YYYY"        (zero-padded, no prefix)
+      - year > 9999        -> "+YYYYY..."   (variable width, '+' prefix)
+      - year < 0           -> "-YYYY..."    (zero-padded if 4 digits, '-' prefix)
+    """
     if 0 <= year <= 9999:
         return "{:04d}".format(year)
     if year > 9999:
@@ -194,7 +212,25 @@ def _format_iso_year(year):
 
 
 def _tz_offset_minutes(tz, ref_seconds=0):
-    """Best-effort fixed-offset extraction. Returns 0 if unknown."""
+    """
+    Best-effort extraction of a UTC offset (in whole minutes) from a pytz tzinfo.
+
+    Used by the datetime formatter to apply the zone numerically, instead of
+    constructing a Python datetime (which can't represent years > 9999). Tries
+    tz.utcoffset(None) first — works directly for pytz.UTC and pytz.FixedOffset,
+    which is what timezone_from_offset() actually returns in practice. Falls
+    back to probing tz.utcoffset(<reference datetime>) for named zones, with
+    the probe seconds clamped to [0, year-9999] so it never hits the Python
+    datetime ceiling.
+
+    Args:
+        tz: A tzinfo / pytz timezone object, or None.
+        ref_seconds (int): Epoch seconds used to construct the probe datetime
+            for named zones. Ignored for fixed-offset / UTC.
+
+    Returns:
+        int: Offset minutes east of UTC. 0 when tz is None or cannot be probed.
+    """
     if tz is None:
         return 0
     try:
@@ -217,8 +253,23 @@ def _tz_offset_minutes(tz, ref_seconds=0):
 
 def format_iso_date_from_epoch_micros(epoch_micros):
     """
-    Format epoch microseconds (UTC) as ISO-8601 date with Java LocalDate-style
-    expanded year support (e.g. '+11756-12-31'). Never raises on year overflow.
+    Format epoch microseconds (UTC) as an ISO-8601 date string with Java
+    LocalDate-style expanded-year support.
+
+    Pipeline: micros -> seconds -> days -> (year, month, day) -> string.
+    All steps are pure-int, so this never raises ValueError on year overflow
+    the way datetime.fromtimestamp(...).strftime(...) does for years > 9999.
+
+    Examples:
+        format_iso_date_from_epoch_micros(1770854400000000) -> "2026-02-12"
+        format_iso_date_from_epoch_micros(308847859200000000) -> "+11756-12-31"
+        format_iso_date_from_epoch_micros(0) -> "1970-01-01"
+
+    Args:
+        epoch_micros (int): Microseconds since 1970-01-01T00:00:00Z (may be negative).
+
+    Returns:
+        str: ISO-8601 date. Years 0-9999 unprefixed, others with '+' / '-'.
     """
     epoch_seconds = floor_div(epoch_micros, 1_000_000)
     days = floor_div(epoch_seconds, _SECONDS_PER_DAY)
@@ -229,9 +280,34 @@ def format_iso_date_from_epoch_micros(epoch_micros):
 def format_iso_datetime_from_epoch_micros(epoch_micros, tz=None, separator='T',
                                           include_millis=True, include_offset=True):
     """
-    Format epoch microseconds as ISO-8601 datetime with expanded year support.
-    Mirrors Java's LocalDateTime/OffsetDateTime toString() semantics so out-of-range
-    years are emitted instead of raising.
+    Format epoch microseconds as an ISO-8601 datetime string with Java
+    LocalDateTime / OffsetDateTime-style expanded-year support.
+
+    The zone is applied numerically via _tz_offset_minutes(), so we never need
+    to construct a Python datetime — that's what allows the formatter to handle
+    years outside [1, 9999] without raising.
+
+    Single function with knobs to cover the three format variants the connector
+    historically emitted from datetime.strftime / datetime.isoformat:
+
+      - Row-wise DATETIME (read_values_from_array):
+            separator=' ', include_millis=False, include_offset=False
+            -> "2026-02-12 00:00:00"
+
+      - Chunk-wise DATETIME / TIMESTAMP_TZ (get_column_from_chunk), defaults:
+            separator='T', include_millis=True, include_offset=True
+            -> "2026-02-12T00:00:00.123+00:00"
+            -> "+11756-12-31T00:00:00.000+00:00"  (year-overflow case)
+
+    Args:
+        epoch_micros (int): Microseconds since 1970-01-01T00:00:00Z.
+        tz: pytz timezone (UTC / FixedOffset / named); None means UTC.
+        separator (str): Between date and time (typically 'T' or ' ').
+        include_millis (bool): Append '.sss' from sub-second microseconds.
+        include_offset (bool): Append '+HH:MM' / '-HH:MM' UTC offset suffix.
+
+    Returns:
+        str: ISO-8601 datetime string.
     """
     epoch_seconds_utc = floor_div(epoch_micros, 1_000_000)
     offset_minutes = _tz_offset_minutes(tz, ref_seconds=epoch_seconds_utc)

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/e6data_python_connector/dialect.py

@@ -14,9 +14,15 @@ from decimal import Decimal
 
 from dateutil.parser import parse
 from sqlalchemy import exc
-from sqlalchemy import processors
 from sqlalchemy import types
-from sqlalchemy.databases import mysql
+try:
+    from sqlalchemy import processors
+except ImportError:
+    from sqlalchemy.engine import processors
+try:
+    from sqlalchemy.databases import mysql
+except ImportError:
+    from sqlalchemy.dialects import mysql
 from sqlalchemy.engine import default, Engine, Connection
 from sqlalchemy.sql import compiler
 from sqlalchemy.sql.compiler import SQLCompiler
@@ -27,6 +33,11 @@ from e6data_python_connector.exceptions import *
 
 _logger = logging.getLogger(__name__)
 
+_MYSQL_TINY_INTEGER = (
+    getattr(mysql, "MSTinyInteger", None) or
+    getattr(mysql, "TINYINT", types.SmallInteger)
+)
+
 
 class E6dataStringTypeBase(types.TypeDecorator):
     """Translates strings returned by Thrift into something else"""
@@ -120,7 +131,7 @@ class E6dataIdentifierPreparer(compiler.IdentifierPreparer):
 
 _type_map = {
     'boolean': types.Boolean,
-    'tinyint': mysql.MSTinyInteger,
+    'tinyint': _MYSQL_TINY_INTEGER,
     'smallint': types.SmallInteger,
     'integer': types.Integer,
     'bigint': types.BigInteger,
@@ -316,7 +327,8 @@ class E6dataDialect(default.DefaultDialect):
         for column in columns:
             row = dict()
             row["name"] = column.get('fieldName')
-            row["type"] = lambda: column.get('fieldType')
+            field_type = str(column.get('fieldType')).lower()
+            row["type"] = _type_map.get(field_type, types.String)
             rows.append(row)
         return rows
 

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.13rc1
+Version: 2.3.14
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -39,7 +39,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.13rc1-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.14-blue.svg)
 
 ## Introduction
 
@@ -324,6 +324,48 @@ query_id = '<query_id>'  # query id from execute function response.
 cursor.cancel(query_id)
 ```
 
+To get the status of a running or completed query:
+```python
+query_id = '<query_id>'  # query id from execute function response.
+status_response = cursor.status(query_id)
+
+# Check if query execution is complete
+is_complete = status_response.status  # Returns True when query is done, False if still running
+
+# Get the total row count
+row_count = status_response.rowCount  # Total number of rows in the result set
+
+print(f"Query complete: {is_complete}")
+print(f"Row count: {row_count}")
+```
+
+The `status()` method is useful for:
+- **Monitoring long-running queries**: Poll the status periodically to check if execution is complete
+- **Checking row counts**: Get the total number of rows without fetching all results
+- **Query progress tracking**: Integrate with monitoring systems or progress bars
+- **Conditional fetching**: Decide whether to fetch results based on completion status
+
+Example - Polling for query completion:
+```python
+import time
+
+cursor = conn.cursor(catalog_name=catalog_name)
+query_id = cursor.execute("SELECT * FROM large_table")
+
+# Poll until query is complete
+while True:
+    status_response = cursor.status(query_id)
+    if status_response.status:
+        print(f"Query complete! Total rows: {status_response.rowCount}")
+        break
+    else:
+        print("Query still running...")
+        time.sleep(1)  # Wait 1 second before checking again
+
+# Now fetch the results
+results = cursor.fetchall()
+```
+
 Switch database in an existing connection:
 ```python
 database = '<new_database_name>'  # Replace with the new database.

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/e6data_python_connector.egg-info/SOURCES.txt

@@ -45,7 +45,6 @@ test/analyze_all_cases.py
 test/analyze_binary.py
 test/analyze_correct_value.py
 test/analyze_fields.py
-test/benchmark_fastbinary_performance.py
 test/check_decimal_errors.py
 test/cleanup_test_files.py
 test/debug_38_nines.py
@@ -65,6 +64,7 @@ test/test_connection_pool_e2e.py
 test/test_current_implementation.py
 test/test_decimal128_binary_parsing.py
 test/test_decimal128_parsing.py
+test/test_dialect_columns.py
 test/test_fix.py
 test/test_improved_parsing.py
 test/test_known_case.py
@@ -72,12 +72,10 @@ test/test_manual_analysis.py
 test/test_mock_server.py
 test/test_multiprocessing_fix.py
 test/test_new_implementation.py
-test/test_optimizations_integration.py
 test/test_pool_concurrency_simple.py
 test/test_pool_threading_multiprocessing.py
 test/test_simple_connection_pool.py
 test/test_specific_binary.py
-test/test_ssl_cert.py
 test/test_strategy.py
 test/test_strategy_logic.py
 test/test_strategy_persistence_fix.py

{e6data_python_connector-2.3.13rc1 → e6data_python_connector-2.3.14}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 3, 13, 'rc1')
+VERSION = (2, 3, 14,)
 
 
 def get_long_desc():

e6data_python_connector-2.3.14/test/test_dialect_columns.py

@@ -0,0 +1,86 @@
+import unittest
+from unittest.mock import patch
+
+from sqlalchemy import types
+
+from e6data_python_connector import dialect as dialect_module
+from e6data_python_connector.dialect import (
+    E6dataDate,
+    E6dataDecimal,
+    E6dataDialect,
+    E6dataTimestamp,
+)
+
+
+class FakeClient(object):
+    def __init__(self, columns):
+        self.columns = columns
+        self.calls = []
+
+    def get_columns(self, catalog, schema, table_name):
+        self.calls.append((catalog, schema, table_name))
+        return self.columns
+
+
+class FakeCursorOwner(object):
+    def __init__(self, client):
+        self.client = client
+
+    def cursor(self, catalog_name=None):
+        return FakeCursor(self.client)
+
+
+class FakeCursor(object):
+    def __init__(self, client):
+        self.connection = client
+
+
+class FakeSQLAlchemyConnection(object):
+    def __init__(self, client):
+        self.connection = FakeCursorOwner(client)
+
+
+class TestDialectGetColumns(unittest.TestCase):
+    def test_get_columns_maps_each_reflected_column_to_its_own_sqlalchemy_type(self):
+        client = FakeClient([
+            {"fieldName": "id", "fieldType": "integer"},
+            {"fieldName": "customer_name", "fieldType": "varchar"},
+            {"fieldName": "amount", "fieldType": "decimal"},
+            {"fieldName": "created_on", "fieldType": "date"},
+            {"fieldName": "created_at", "fieldType": "timestamp"},
+        ])
+        connection = FakeSQLAlchemyConnection(client)
+        dialect = E6dataDialect()
+        dialect.catalog_name = "lakehouse"
+
+        with patch.object(dialect_module, "Connection", FakeSQLAlchemyConnection):
+            columns = dialect.get_columns(connection, "orders", "sales")
+
+        self.assertEqual(
+            ["id", "customer_name", "amount", "created_on", "created_at"],
+            [column["name"] for column in columns],
+        )
+        self.assertEqual([("lakehouse", "sales", "orders")], client.calls)
+        self.assertIs(columns[0]["type"], types.Integer)
+        self.assertIs(columns[1]["type"], types.String)
+        self.assertIs(columns[2]["type"], E6dataDecimal)
+        self.assertIs(columns[3]["type"], E6dataDate)
+        self.assertIs(columns[4]["type"], E6dataTimestamp)
+
+    def test_get_columns_defaults_unknown_e6data_type_to_string(self):
+        client = FakeClient([
+            {"fieldName": "payload", "fieldType": "variant"},
+        ])
+        connection = FakeSQLAlchemyConnection(client)
+        dialect = E6dataDialect()
+        dialect.catalog_name = "lakehouse"
+
+        with patch.object(dialect_module, "Connection", FakeSQLAlchemyConnection):
+            columns = dialect.get_columns(connection, "events", "sales")
+
+        self.assertEqual("payload", columns[0]["name"])
+        self.assertIs(columns[0]["type"], types.String)
+
+
+if __name__ == "__main__":
+    unittest.main()