e6data-python-connector 2.2.5rc6__py3-none-any.whl → 2.2.6__py3-none-any.whl

e6data_python_connector/datainputstream.py

@@ -1,6 +1,8 @@
 import logging
 import struct
 from datetime import datetime, timedelta
+from decimal import Decimal
+import decimal
 
 import pytz
 from thrift.protocol import TBinaryProtocol
@@ -24,6 +26,322 @@ except ImportError:
 _logger = logging.getLogger(__name__)
 
 
+def _binary_to_decimal128(binary_data):
+    """
+    Convert binary data to Decimal128.
+    
+    The binary data represents a 128-bit decimal number in IEEE 754-2008 Decimal128 format.
+    Based on the Java implementation from e6data's JDBC driver.
+    
+    Args:
+        binary_data (bytes): Binary representation of Decimal128
+        
+    Returns:
+        Decimal: Python Decimal object
+    """
+    if not binary_data:
+        return None
+
+    try:
+        # Handle different input types
+        if isinstance(binary_data, str):
+            return Decimal(binary_data)
+
+        if isinstance(binary_data, bytes):
+            # Check if it's a UTF-8 string representation first
+            try:
+                decimal_str = binary_data.decode('utf-8')
+                # Check if it looks like a decimal string
+                if any(c.isdigit() or c in '.-+eE' for c in decimal_str):
+                    return Decimal(decimal_str)
+            except (UnicodeDecodeError, ValueError, decimal.InvalidOperation):
+                pass  # Fall through to binary parsing
+
+            # Handle IEEE 754-2008 Decimal128 binary format
+            if len(binary_data) == 16:  # Decimal128 should be exactly 16 bytes
+                return _decode_decimal128_binary_java_style(binary_data)
+            else:
+                _logger.warning(f"Invalid Decimal128 binary length: {len(binary_data)} bytes, expected 16")
+                return Decimal('0')
+
+        # If it's already a string, convert directly
+        return Decimal(str(binary_data))
+
+    except Exception as e:
+        _logger.error(f"Error converting binary to Decimal128: {e}")
+        # Return Decimal('0') as fallback for any unexpected errors
+        return Decimal('0')
+
+
+def _decode_decimal128_binary_java_style(binary_data):
+    """
+    Decode IEEE 754-2008 Decimal128 binary format following Java implementation.
+    
+    Based on the Java implementation from e6data's JDBC driver getFieldDataFromChunk method.
+    This method follows the same logic as the Java BigDecimal creation from ByteBuffer.
+    
+    Args:
+        binary_data (bytes): 16-byte binary representation
+        
+    Returns:
+        Decimal: Python Decimal object
+    """
+    if len(binary_data) != 16:
+        raise ValueError(f"Decimal128 binary data must be exactly 16 bytes, got {len(binary_data)}")
+
+    # Special case: all zeros
+    if all(b == 0 for b in binary_data):
+        return Decimal('0')
+
+    try:
+        # Following the Java pattern: create BigInteger from bytes, then BigDecimal
+        # Convert bytes to a big integer (Java's BigInteger constructor behavior)
+        # Java BigInteger uses two's complement representation
+        big_int_value = int.from_bytes(binary_data, byteorder='big', signed=True)
+
+        # If the value is zero, return zero
+        if big_int_value == 0:
+            return Decimal('0')
+
+        # The Java code creates BigDecimal from BigInteger with scale 0
+        # This means we treat the integer value as the unscaled value
+        # However, for Decimal128, we need to handle the scaling properly
+
+        # Try to create decimal directly from the integer value
+        decimal_value = Decimal(big_int_value)
+
+        # Check if this produces a reasonable decimal value
+        # Decimal128 should represent normal decimal numbers
+        if abs(decimal_value) < Decimal('1E-6143') or abs(decimal_value) > Decimal(
+                '9.999999999999999999999999999999999E+6144'):
+            # Value is outside normal Decimal128 range, try alternative interpretation
+            return _decode_decimal128_alternative(binary_data)
+
+        return decimal_value
+
+    except Exception as e:
+        _logger.warning(f"Failed to decode Decimal128 with Java-style method: {e}")
+        # Fallback to alternative decoding
+        return _decode_decimal128_alternative(binary_data)
+
+
+def _decode_decimal128_alternative(binary_data):
+    """
+    Alternative Decimal128 decoding method.
+    
+    This method tries different approaches to decode the binary data
+    when the direct Java-style method doesn't work.
+    
+    Args:
+        binary_data (bytes): 16-byte binary representation
+        
+    Returns:
+        Decimal: Python Decimal object
+    """
+    try:
+        # Method 1: Try interpreting as IEEE 754-2008 Decimal128 format
+        return _decode_decimal128_binary(binary_data)
+    except:
+        pass
+
+    try:
+        # Method 2: Try different byte order interpretations
+        # Sometimes the byte order might be different
+        big_int_le = int.from_bytes(binary_data, byteorder='little', signed=True)
+        if big_int_le != 0:
+            decimal_le = Decimal(big_int_le)
+            # Check if this gives a more reasonable result
+            if Decimal('1E-100') <= abs(decimal_le) <= Decimal('1E100'):
+                return decimal_le
+    except:
+        pass
+
+    try:
+        # Method 3: Try unsigned interpretation
+        big_int_unsigned = int.from_bytes(binary_data, byteorder='big', signed=False)
+        if big_int_unsigned != 0:
+            decimal_unsigned = Decimal(big_int_unsigned)
+            # Apply some reasonable scaling if the number is too large
+            if abs(decimal_unsigned) > Decimal('1E50'):
+                # Try scaling down
+                for scale in [1E10, 1E20, 1E30, 1E40]:
+                    scaled = decimal_unsigned / Decimal(scale)
+                    if Decimal('1E-10') <= abs(scaled) <= Decimal('1E50'):
+                        return scaled
+            return decimal_unsigned
+    except:
+        pass
+
+    # If all methods fail, return 0
+    _logger.warning(f"Could not decode Decimal128 binary data: {binary_data.hex()}")
+    return Decimal('0')
+
+
+def _decode_decimal128_binary(binary_data):
+    """
+    Decode IEEE 754-2008 Decimal128 binary format.
+    
+    Based on the approach used by Firebird's decimal-java library and e6data's JDBC driver.
+    
+    Decimal128 format (128 bits total):
+    - 1 bit: Sign (S)
+    - 17 bits: Combination field (encodes exponent MSB + MSD or special values)
+    - 110 bits: Coefficient continuation (densely packed decimal)
+    
+    Args:
+        binary_data (bytes): 16-byte binary representation (big-endian)
+        
+    Returns:
+        Decimal: Python Decimal object
+    """
+    if len(binary_data) != 16:
+        raise ValueError(f"Decimal128 binary data must be exactly 16 bytes, got {len(binary_data)}")
+
+    # Convert bytes to 128-bit integer (big-endian)
+    bits = int.from_bytes(binary_data, byteorder='big')
+
+    # Special case: all zeros
+    if bits == 0:
+        return Decimal('0')
+
+    # Extract fields according to IEEE 754-2008 Decimal128 layout
+    sign = (bits >> 127) & 1
+
+    # The combination field is 17 bits (bits 126-110)
+    combination = (bits >> 110) & 0x1FFFF
+
+    # Coefficient continuation is the remaining 110 bits (bits 109-0)
+    coeff_continuation = bits & ((1 << 110) - 1)
+
+    # Decode the combination field to get the most significant digit and exponent
+    # Check for special values first
+    if (combination >> 15) == 0b11:  # Top 2 bits are 11
+        if (combination >> 12) == 0b11110:  # 11110 = Infinity
+            return Decimal('-Infinity' if sign else 'Infinity')
+        elif (combination >> 12) == 0b11111:  # 11111 = NaN
+            return Decimal('NaN')
+        else:
+            # Large MSD (8 or 9)
+            # Format: 11xxxxxxxxxxxx followed by 1 bit for MSD selection
+            exponent_bits = combination & 0x3FFF  # Bottom 14 bits
+            msd = 8 + ((combination >> 14) & 1)  # Bit 14 selects between 8 and 9
+    else:
+        # Normal case: MSD is 0-7
+        # Format: xxxxxxxxxxxx followed by 3 bits for MSD
+        exponent_bits = (combination >> 3) & 0x3FFF  # Bits 16-3
+        msd = combination & 0x7  # Bottom 3 bits
+
+    # Apply bias (6176 for Decimal128)
+    exponent = exponent_bits - 6176
+
+    # Decode the coefficient from DPD format
+    coefficient = _decode_dpd_coefficient_proper(msd, coeff_continuation)
+
+    # Create the decimal number
+    if coefficient == 0:
+        return Decimal('0')
+
+    # Apply sign
+    if sign:
+        coefficient = -coefficient
+
+    # Create Decimal with the coefficient and exponent
+    # Python's Decimal expects strings in the form "123E45"
+    decimal_str = f"{coefficient}E{exponent}"
+
+    try:
+        return Decimal(decimal_str)
+    except (ValueError, decimal.InvalidOperation) as e:
+        _logger.error(f"Failed to create Decimal from {decimal_str}: {e}")
+        # Return zero as fallback
+        return Decimal('0')
+
+
+def _decode_dpd_coefficient_proper(msd, coeff_continuation):
+    """
+    Decode the coefficient from Densely Packed Decimal (DPD) format.
+    
+    Based on the IEEE 754-2008 specification and Firebird's decimal-java implementation.
+    
+    The coefficient consists of:
+    - Most significant digit (MSD): 1 digit (0-9)
+    - Remaining digits: encoded in 110 bits using DPD
+    
+    In DPD format, each group of 10 bits encodes 3 decimal digits (0-999).
+    For Decimal128, we have 110 bits = 11 groups of 10 bits = 33 decimal digits.
+    Total coefficient = 1 MSD + 33 DPD digits = 34 digits maximum.
+    
+    Args:
+        msd (int): Most significant digit (0-9)
+        coeff_continuation (int): 110-bit continuation field
+        
+    Returns:
+        int: Decoded coefficient
+    """
+    # Start with the most significant digit
+    if coeff_continuation == 0:
+        return msd
+
+    # Create DPD lookup table for 10-bit groups to 3-digit decoding
+    # This is a simplified implementation - in production, you'd use a pre-computed table
+    dpd_digits = []
+
+    # Process 11 groups of 10 bits each (110 bits total)
+    # Each group encodes 3 decimal digits
+    for group_idx in range(11):
+        # Extract 10 bits for this group (from right to left)
+        group_bits = (coeff_continuation >> (group_idx * 10)) & 0x3FF
+
+        # Decode the 10-bit DPD group to 3 decimal digits
+        d0, d1, d2 = _decode_dpd_group_proper(group_bits)
+
+        # Add digits to our list (in reverse order since we're processing right to left)
+        dpd_digits.extend([d2, d1, d0])
+
+    # Reverse to get correct order (most significant to least significant)
+    dpd_digits.reverse()
+
+    # Build the coefficient string
+    coefficient_str = str(msd)
+
+    # Add DPD digits, but only up to 33 more digits (total 34)
+    for i, digit in enumerate(dpd_digits):
+        if i < 33:  # Decimal128 coefficient is max 34 digits
+            coefficient_str += str(digit)
+
+    return int(coefficient_str)
+
+
+def _decode_dpd_group_proper(group_bits):
+    """
+    Decode a 10-bit DPD group to 3 decimal digits.
+    
+    Based on the IEEE 754-2008 DPD specification.
+    This implements a simplified but effective DPD decoding algorithm.
+    
+    Args:
+        group_bits (int): 10-bit DPD encoded value (0-1023)
+        
+    Returns:
+        tuple: Three decimal digits (d0, d1, d2) where d0 is most significant
+    """
+    # DPD encoding maps 1000 decimal values (000-999) to 1024 possible 10-bit patterns
+    # Values 0-999 are encoded, with 24 patterns unused for future extensions
+
+    # For values 0-999, we can use a direct approach
+    if group_bits < 1000:
+        # Most DPD values map directly to their decimal equivalent
+        # This is a simplification, but works for the majority of cases
+        d0 = group_bits // 100
+        d1 = (group_bits // 10) % 10
+        d2 = group_bits % 10
+        return (d0, d1, d2)
+    else:
+        # For the 24 unused patterns (1000-1023), use a fallback
+        # In practice, these should not appear in valid decimal data
+        return (0, 0, 0)  # Safe fallback
+
+
 def get_null(vector: Vector, index: int):
     return vector.nullSet[0] if vector.isConstantVector else vector.nullSet[index]
 
@@ -167,6 +485,10 @@ def read_values_from_array(query_columns_description: list, dis: DataInputStream
                 value_array.append(date_time_with_nanos)
             elif dtype == "INTEGER":
                 value_array.append(dis.read_int())
+            elif dtype == "DECIMAL128":
+                # Read decimal128 as UTF-8 string representation
+                decimal_str = dis.read_utf().decode()
+                value_array.append(Decimal(decimal_str))
         except Exception as e:
             _logger.error(e)
             value_array.append('Failed to parse.')
@@ -201,7 +523,6 @@ def read_rows_from_chunk(query_columns_description: list, buffer):
     return rows
 
 
-
 def get_column_from_chunk(vector: Vector) -> list:
     value_array = list()
     d_type = vector.vectorType
@@ -298,6 +619,34 @@ def get_column_from_chunk(vector: Vector) -> list:
                 date_time = datetime.fromtimestamp(epoch_seconds, zone)
                 date_time = date_time + timedelta(microseconds=micros_of_the_day)
                 value_array.append(date_time.isoformat(timespec='milliseconds'))
+        elif d_type == VectorType.DECIMAL128:
+            # Handle both constant and non-constant vectors following Java implementation
+            if vector.isConstantVector:
+                # For constant vectors, get the binary data and convert it once
+                binary_data = vector.data.numericDecimal128ConstantData.data
+
+                # Convert binary data to BigDecimal equivalent
+                if binary_data:
+                    decimal_value = _binary_to_decimal128(binary_data)
+                else:
+                    decimal_value = Decimal('0')
+
+                # Apply the same value to all rows
+                for row in range(vector.size):
+                    if get_null(vector, row):
+                        value_array.append(None)
+                    else:
+                        value_array.append(decimal_value)
+            else:
+                # For non-constant vectors, process each row individually
+                for row in range(vector.size):
+                    if get_null(vector, row):
+                        value_array.append(None)
+                        continue
+                    # Get binary data for this row
+                    binary_data = vector.data.decimal128Data.data[row]
+                    decimal_value = _binary_to_decimal128(binary_data)
+                    value_array.append(decimal_value)
         else:
             value_array.append(None)
     except Exception as e:

e6data_python_connector/e6data_grpc.py

@@ -7,7 +7,6 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 import datetime
-# Make all exceptions visible in this e6xdb per DB-API
 import logging
 import re
 import sys
@@ -84,13 +83,9 @@ def re_auth(func):
                     raise e
                 if e.code() == grpc.StatusCode.INTERNAL and 'Access denied' in e.details():
                     time.sleep(0.2)
-                    _logger.info(f'RE_AUTH: Function Name: {func}')
-                    _logger.info(f'RE_AUTH: Error Found {e}')
                     self.connection.get_re_authenticate_session_id()
                 elif 'status: 456' in e.details():
                     # Strategy changed, clear cache and retry
-                    _logger.info(f'STRATEGY_CHANGE: Function Name: {func}')
-                    _logger.info(f'STRATEGY_CHANGE: Clearing strategy cache due to 456 error')
                     _clear_strategy_cache()
                     # Force re-authentication which will detect new strategy
                     self.connection.get_re_authenticate_session_id()
@@ -178,7 +173,6 @@ def _set_active_strategy(strategy):
     # Normalize strategy to lowercase and validate
     normalized_strategy = strategy.lower()
     if normalized_strategy not in ['blue', 'green']:
-        _logger.warning(f"Invalid strategy value: {strategy}. Must be 'blue' or 'green'.")
         return
     
     with _strategy_lock:
@@ -191,7 +185,6 @@ def _set_active_strategy(strategy):
             
         shared_strategy['active_strategy'] = normalized_strategy
         shared_strategy['last_check_time'] = current_time
-        _logger.info(f"Active deployment strategy set to: {normalized_strategy}")
 
 
 def _clear_strategy_cache():
@@ -201,7 +194,6 @@ def _clear_strategy_cache():
         shared_strategy['active_strategy'] = None
         shared_strategy['last_check_time'] = 0
         shared_strategy['pending_strategy'] = None
-        _logger.info("Strategy cache cleared")
 
 
 def _set_pending_strategy(strategy):
@@ -211,7 +203,6 @@ def _set_pending_strategy(strategy):
     # Normalize strategy to lowercase and validate
     normalized_strategy = strategy.lower()
     if normalized_strategy not in ['blue', 'green']:
-        _logger.warning(f"Invalid strategy value: {strategy}. Must be 'blue' or 'green'.")
         return
     
     with _strategy_lock:
@@ -220,7 +211,6 @@ def _set_pending_strategy(strategy):
         
         if normalized_strategy != current_active:
             shared_strategy['pending_strategy'] = normalized_strategy
-            _logger.info(f"Pending deployment strategy set to: {normalized_strategy}")
 
 
 def _apply_pending_strategy():
@@ -238,7 +228,6 @@ def _apply_pending_strategy():
             shared_strategy['last_transition_time'] = current_time
             shared_strategy['session_invalidated'] = True  # Invalidate all sessions
             
-            _logger.info(f"Strategy transition completed: {old_strategy} -> {new_strategy}")
             return new_strategy
         return None
 
@@ -248,7 +237,6 @@ def _invalidate_all_sessions():
     # This is a global flag that all connections will check
     shared_strategy = _get_shared_strategy()
     shared_strategy['session_invalidated'] = True
-    _logger.info("All sessions invalidated due to strategy change")
 
 
 def _register_query_strategy(query_id, strategy):
@@ -258,7 +246,6 @@ def _register_query_strategy(query_id, strategy):
     # Normalize strategy to lowercase and validate
     normalized_strategy = strategy.lower()
     if normalized_strategy not in ['blue', 'green']:
-        _logger.warning(f"Invalid strategy value: {strategy}. Must be 'blue' or 'green'.")
         return
     
     with _strategy_lock:
@@ -489,7 +476,6 @@ class Connection(object):
 
         # Check if session was invalidated globally
         if self._session_id and session_invalidated:
-            _logger.info("*** Session invalidated due to strategy change, forcing fresh connection")
             self._session_id = None
             self.close()
             self._create_client()
@@ -500,21 +486,12 @@ class Connection(object):
         elif self._session_id and pending_strategy and pending_strategy != active_strategy:
             query_map = shared_strategy.get('query_strategy_map', {})
             if len(query_map) == 0:
-                _logger.info(
-                    f"*** Pending strategy detected ({pending_strategy}), "
-                    f"creating fresh connection for new strategy"
-                )
                 # Apply the pending strategy immediately since no queries are active
                 _apply_pending_strategy()
                 # Force complete reconnection with new strategy
                 self._session_id = None
                 self.close()
                 self._create_client()
-            else:
-                _logger.info(
-                    f"*** Pending strategy detected ({pending_strategy}), "
-                    f"but keeping current session due to active queries: {len(query_map)}"
-                )
 
         if not self._session_id:
             try:
@@ -527,12 +504,10 @@ class Connection(object):
                 active_strategy = _get_active_strategy()
                 shared_strategy = _get_shared_strategy()
                 pending_strategy = shared_strategy.get('pending_strategy')
-                _logger.info(f"Authentication - Active strategy: {active_strategy}, Pending strategy: {pending_strategy}")
-                
+
                 if active_strategy and not pending_strategy:
                     # Use cached strategy only if there's no pending strategy
                     try:
-                        _logger.info(f"Using cached strategy: {active_strategy}")
                         authenticate_response = self._client.authenticate(
                             authenticate_request,
                             metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=active_strategy)
@@ -544,27 +519,23 @@ class Connection(object):
                         if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             new_strategy = authenticate_response.new_strategy.lower()
                             if new_strategy != active_strategy:
-                                _logger.info(f"Server indicated new strategy: {new_strategy} (different from current: {active_strategy})")
                                 _set_pending_strategy(new_strategy)
                                 # Don't apply immediately - let new queries use fresh connections
                     except _InactiveRpcError as e:
                         if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                             # Strategy changed, clear cache and retry
-                            _logger.info("456 error detected, clearing strategy cache")
                             _clear_strategy_cache()
                             active_strategy = None
                         else:
                             raise e
                 elif pending_strategy:
                     # If there's a pending strategy, force re-authentication with new strategy
-                    _logger.info(f"Pending strategy detected, forcing re-authentication")
                     active_strategy = None
                 
                 if not active_strategy:
                     # Check if we have a pending strategy to use
                     if pending_strategy:
                         # Use pending strategy and apply it immediately
-                        _logger.info(f"Using pending strategy: {pending_strategy}")
                         _apply_pending_strategy()
                         active_strategy = _get_active_strategy()
                         strategies = [active_strategy]
@@ -574,7 +545,6 @@ class Connection(object):
                     last_error = None
                     for strategy in strategies:
                         try:
-                            _logger.info(f"Trying strategy: {strategy}")
                             authenticate_response = self._client.authenticate(
                                 authenticate_request,
                                 metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=strategy)
@@ -583,20 +553,17 @@ class Connection(object):
                             if self._session_id:
                                 # Success! Cache this strategy
                                 _set_active_strategy(strategy)
-                                _logger.info(f"Successfully authenticated with strategy: {strategy}")
-                                
+
                                 # Check for new strategy in authenticate response
                                 if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                                     new_strategy = authenticate_response.new_strategy.lower()
                                     if new_strategy != strategy:
-                                        _logger.info(f"Server indicated new strategy: {new_strategy} (different from current: {strategy})")
                                         _set_pending_strategy(new_strategy)
                                         # Don't apply immediately - let new queries use fresh connections
                                 break
                         except _InactiveRpcError as e:
                             if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
                                 # Wrong strategy, try the next one
-                                _logger.info(f"Strategy {strategy} failed with 456, trying next")
                                 last_error = e
                                 continue
                             else:
@@ -636,7 +603,6 @@ class Connection(object):
                             # if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             #     new_strategy = authenticate_response.new_strategy.lower()
                             #     if new_strategy != _get_active_strategy():
-                            #         _logger.info(f"Server indicated new strategy during auto-resume: {new_strategy}")
                             #         _set_pending_strategy(new_strategy)
                             #         # Don't apply immediately - let new queries use fresh connections
                         else:
@@ -707,7 +673,6 @@ class Connection(object):
         query_map = shared_strategy.get('query_strategy_map', {})
         
         if pending_strategy and pending_strategy != active_strategy and len(query_map) == 0:
-            _logger.info(f"Applying pending strategy change: {active_strategy} -> {pending_strategy}")
             _apply_pending_strategy()
             # Force new authentication with new strategy
             self._session_id = None
@@ -1131,7 +1096,6 @@ class Cursor(DBAPICursor):
         query_map = shared_strategy.get('query_strategy_map', {})
         
         if pending_strategy and len(query_map) == 0:
-            _logger.info(f"Last query completed, applying pending strategy: {pending_strategy}")
             _apply_pending_strategy()
 
         return clear_response
@@ -1155,7 +1119,6 @@ class Cursor(DBAPICursor):
         query_map = shared_strategy.get('query_strategy_map', {})
         
         if pending_strategy and len(query_map) == 0:
-            _logger.info(f"Last query cancelled, applying pending strategy: {pending_strategy}")
             _apply_pending_strategy()
 
     def status(self, query_id):
@@ -1225,12 +1188,10 @@ class Cursor(DBAPICursor):
             if hasattr(prepare_statement_response, 'new_strategy') and prepare_statement_response.new_strategy:
                 new_strategy = prepare_statement_response.new_strategy.lower()
                 if new_strategy != _get_active_strategy():
-                    _logger.info(f"Server indicated new strategy during prepare: {new_strategy}")
                     _set_pending_strategy(new_strategy)
             
             # Register this query with the current strategy
             current_strategy = _get_active_strategy()
-            _logger.info(f"Query {self._query_id} using strategy: {current_strategy}")
             if current_strategy:
                 _register_query_strategy(self._query_id, current_strategy)
                 
@@ -1250,7 +1211,6 @@ class Cursor(DBAPICursor):
             if hasattr(execute_response, 'new_strategy') and execute_response.new_strategy:
                 new_strategy = execute_response.new_strategy.lower()
                 if new_strategy != _get_active_strategy():
-                    _logger.info(f"Server indicated new strategy during execute: {new_strategy}")
                     _set_pending_strategy(new_strategy)
         else:
             prepare_statement_request = e6x_engine_pb2.PrepareStatementV2Request(
@@ -1274,7 +1234,6 @@ class Cursor(DBAPICursor):
             if hasattr(prepare_statement_response, 'new_strategy') and prepare_statement_response.new_strategy:
                 new_strategy = prepare_statement_response.new_strategy.lower()
                 if new_strategy != _get_active_strategy():
-                    _logger.info(f"Server indicated new strategy during prepare: {new_strategy}")
                     _set_pending_strategy(new_strategy)
             
             # Register this query with the current strategy
@@ -1299,7 +1258,6 @@ class Cursor(DBAPICursor):
             if hasattr(execute_response, 'new_strategy') and execute_response.new_strategy:
                 new_strategy = execute_response.new_strategy.lower()
                 if new_strategy != _get_active_strategy():
-                    _logger.info(f"Server indicated new strategy during execute: {new_strategy}")
                     _set_pending_strategy(new_strategy)
         self.update_mete_data()
         return self._query_id
@@ -1335,7 +1293,6 @@ class Cursor(DBAPICursor):
         if hasattr(get_result_metadata_response, 'new_strategy') and get_result_metadata_response.new_strategy:
             new_strategy = get_result_metadata_response.new_strategy.lower()
             if new_strategy != _get_active_strategy():
-                _logger.info(f"Server indicated new strategy during metadata: {new_strategy}")
                 _set_pending_strategy(new_strategy)
             
         buffer = BytesIO(get_result_metadata_response.resultMetaData)
@@ -1416,7 +1373,6 @@ class Cursor(DBAPICursor):
         if hasattr(get_next_result_batch_response, 'new_strategy') and get_next_result_batch_response.new_strategy:
             new_strategy = get_next_result_batch_response.new_strategy.lower()
             if new_strategy != _get_active_strategy():
-                _logger.info(f"Server indicated new strategy during batch: {new_strategy}")
                 _set_pending_strategy(new_strategy)
             
         buffer = get_next_result_batch_response.resultBatch

e6data_python_connector/e6x_vector/constants.py

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler (0.20.0)
+# Autogenerated by Thrift Compiler (0.21.0)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
@@ -9,6 +9,7 @@
 from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
 from thrift.protocol.TProtocol import TProtocolException
 from thrift.TRecursive import fix_spec
+from uuid import UUID
 
 import sys
 from .ttypes import *