e6data-python-connector 2.3.11rc2__py3-none-any.whl → 2.3.12__py3-none-any.whl

e6data_python_connector/cluster_manager.py

@@ -9,27 +9,9 @@ import multiprocessing
 
 logger = logging.getLogger(__name__)
 
+from e6data_python_connector.common import get_ssl_credentials
 from e6data_python_connector.strategy import _get_active_strategy, _set_active_strategy, _set_pending_strategy, \
-    _get_grpc_header as _get_strategy_header
-
-
-def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
-    """
-    Generate gRPC metadata headers for the request.
-
-    This function creates a list of metadata headers to be used in gRPC requests.
-    It includes optional headers for the engine IP, cluster UUID, and deployment strategy.
-
-    Args:
-        engine_ip (str, optional): The IP address of the engine. Defaults to None.
-        cluster (str, optional): The UUID of the cluster. Defaults to None.
-        strategy (str, optional): The deployment strategy (blue/green). Defaults to None.
-
-    Returns:
-        list: A list of tuples representing the gRPC metadata headers.
-    """
-    # Use the strategy module's implementation
-    return _get_strategy_header(engine_ip=engine_ip, cluster=cluster, strategy=strategy)
+    _get_grpc_header
 
 
 class _StatusLock:
@@ -140,7 +122,7 @@ class ClusterManager:
     """
 
     def __init__(self, host: str, port: int, user: str, password: str, secure_channel: bool = False, timeout=60 * 5,
-                 cluster_uuid=None, grpc_options=None, debug=False):
+                 cluster_uuid=None, grpc_options=None, debug=False, ssl_cert=None):
         """
         Initializes a new instance of the ClusterManager class.
 
@@ -156,6 +138,8 @@ class ClusterManager:
             cluster_uuid (str, optional): The unique identifier for the target cluster;
                 defaults to None.
             debug (bool, optional): Enable debug logging; defaults to False.
+            ssl_cert (str or bytes, optional): Path to CA certificate file (PEM format) or
+                certificate content as bytes for secure connections; defaults to None.
         """
 
         self._host = host
@@ -169,6 +153,7 @@ class ClusterManager:
         if grpc_options is None:
             self._grpc_options = dict()
         self._debug = debug
+        self._ssl_cert = ssl_cert
 
     @property
     def _get_connection(self):
@@ -184,7 +169,7 @@ class ClusterManager:
             self._channel = grpc.secure_channel(
                 target='{}:{}'.format(self._host, self._port),
                 options=self._grpc_options,
-                credentials=grpc.ssl_channel_credentials()
+                credentials=get_ssl_credentials(self._ssl_cert)
             )
         else:
             self._channel = grpc.insecure_channel(

e6data_python_connector/common.py

@@ -15,6 +15,7 @@ from builtins import int
 from builtins import object
 from builtins import str
 
+import grpc
 from future.utils import with_metaclass
 from past.builtins import basestring
 
@@ -267,3 +268,46 @@ class UniversalSet(object):
 
     def __contains__(self, item):
         return True
+
+
+def get_ssl_credentials(ssl_cert):
+    """
+    Get SSL credentials for secure gRPC channel.
+
+    Handles three scenarios:
+    1. ssl_cert is a string (file path): Read the PEM certificate from the file
+    2. ssl_cert is bytes: Use the certificate content directly
+    3. ssl_cert is None: Use system default CA bundle
+
+    Parameters:
+        ssl_cert (str or bytes or None): SSL certificate as file path, bytes, or None
+
+    Returns:
+        grpc.ChannelCredentials: SSL credentials for gRPC channel
+
+    Raises:
+        FileNotFoundError: If ssl_cert is a file path but the file doesn't exist
+        IOError: If ssl_cert file cannot be read
+    """
+    if ssl_cert is None:
+        # Use system default CA bundle
+        return grpc.ssl_channel_credentials()
+    elif isinstance(ssl_cert, str):
+        # ssl_cert is a file path - read the certificate from file
+        try:
+            with open(ssl_cert, 'rb') as cert_file:
+                root_ca_cert = cert_file.read()
+            return grpc.ssl_channel_credentials(root_certificates=root_ca_cert)
+        except FileNotFoundError:
+            _logger.error("SSL certificate file not found: {}".format(ssl_cert))
+            raise
+        except IOError as e:
+            _logger.error("Failed to read SSL certificate file {}: {}".format(ssl_cert, e))
+            raise
+    elif isinstance(ssl_cert, bytes):
+        # ssl_cert is certificate content as bytes
+        return grpc.ssl_channel_credentials(root_certificates=ssl_cert)
+    else:
+        # Invalid type - fall back to system default CA bundle with warning
+        _logger.warning("Invalid ssl_cert type: {}. Using system default CA bundle.".format(type(ssl_cert)))
+        return grpc.ssl_channel_credentials()

e6data_python_connector/constants.py

@@ -1,5 +1,6 @@
 import pytz
 
+# Type definitions
 PRIMITIVE_TYPES = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20, 21}
 COMPLEX_TYPES = {10, 11, 12, 13, 14}
 COLLECTION_TYPES = {10, 11}
@@ -30,3 +31,26 @@ CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength"
 PRECISION = "precision"
 SCALE = "scale"
 ZONE = pytz.timezone('UTC')
+
+# Retry and timeout constants
+MAX_RETRY_ATTEMPTS = 5
+RETRY_SLEEP_SECONDS = 0.2
+STRATEGY_CACHE_TIMEOUT_SECONDS = 300  # 5 minutes
+DEFAULT_GRPC_PREPARE_TIMEOUT_SECONDS = 600  # 10 minutes
+DEFAULT_AUTO_RESUME_TIMEOUT_SECONDS = 300  # 5 minutes
+CLUSTER_STATUS_CHECK_SLEEP_SECONDS = 5
+LOCK_TIMEOUT_MS = 500
+
+# Connection pool constants
+POOL_GET_TIMEOUT_SECONDS = 0.1
+POOL_RETRY_SLEEP_SECONDS = 0.1
+
+# Blue-green deployment strategy constants
+STRATEGY_BLUE = 'blue'
+STRATEGY_GREEN = 'green'
+VALID_STRATEGIES = {STRATEGY_BLUE, STRATEGY_GREEN}
+
+# gRPC error codes and messages
+GRPC_ERROR_STRATEGY_MISMATCH = 'status: 456'
+GRPC_ERROR_SERVICE_UNAVAILABLE = 'status: 503'
+GRPC_ERROR_ACCESS_DENIED = 'Access denied'

e6data_python_connector/datainputstream.py

@@ -12,30 +12,39 @@ from e6data_python_connector.e6x_vector.ttypes import Chunk, Vector, VectorType
 from e6data_python_connector.constants import ZONE
 from e6data_python_connector.date_time_utils import floor_div, floor_mod, timezone_from_offset
 
+# Try to import fastbinary - it's optional but provides better performance
+_fastbinary_available = False
 try:
     from thrift.protocol import fastbinary
+    _fastbinary_available = True
 except ImportError:
-    raise Exception(
-        """
-        Failed to import fastbinary. 
-        Did you install system dependencies?
-        Please verify https://github.com/e6x-labs/e6data-python-connector#dependencies
-        """
-    )
+    pass  # Will check require_fastbinary flag at connection creation time
 
 _logger = logging.getLogger(__name__)
 
 
-def _binary_to_decimal128(binary_data):
+def is_fastbinary_available():
+    """
+    Check if fastbinary module is available.
+
+    Returns:
+        bool: True if fastbinary is available, False otherwise
+    """
+    return _fastbinary_available
+
+
+def _binary_to_decimal128(binary_data, scale=None):
     """
     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
-        
+        scale (int, optional): Scale parameter for decimal precision. If None,
+                               attempts to decode from IEEE format or defaults to 0.
+
     Returns:
         Decimal: Python Decimal object
     """
@@ -59,7 +68,7 @@ def _binary_to_decimal128(binary_data):
 
             # 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)
+                return _decode_decimal128_binary_java_style(binary_data, scale)
             else:
                 _logger.warning(f"Invalid Decimal128 binary length: {len(binary_data)} bytes, expected 16")
                 return Decimal('0')
@@ -73,16 +82,17 @@ def _binary_to_decimal128(binary_data):
         return Decimal('0')
 
 
-def _decode_decimal128_binary_java_style(binary_data):
+def _decode_decimal128_binary_java_style(binary_data, scale=None):
     """
     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
-        
+        scale (int, optional): Scale parameter for decimal precision
+
     Returns:
         Decimal: Python Decimal object
     """
@@ -103,17 +113,21 @@ def _decode_decimal128_binary_java_style(binary_data):
         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)
+        # The Java code creates BigDecimal from BigInteger with the provided scale
+        # If scale is provided, use it to create the properly scaled decimal
+        if scale is not None:
+            # Create decimal with the specified scale (like Java's BigDecimal constructor)
+            # This treats big_int_value as the unscaled value
+            decimal_value = Decimal(big_int_value) / (Decimal(10) ** scale)
+        else:
+            # Fallback: 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'):
+        # Only check range if scale was not provided (backward compatibility)
+        if scale is None and (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)
 
@@ -497,6 +511,16 @@ def read_values_from_array(query_columns_description: list, dis: DataInputStream
 
 
 def read_rows_from_chunk(query_columns_description: list, buffer):
+    """
+    Read rows from a Thrift-encoded chunk buffer.
+
+    Args:
+        query_columns_description: List of column descriptions
+        buffer: Thrift-encoded binary buffer
+
+    Returns:
+        List of rows
+    """
     # Create a transport and protocol instance for deserialization
     transport = TTransport.TMemoryBuffer(buffer)
     protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport)
@@ -624,10 +648,12 @@ def get_column_from_chunk(vector: Vector) -> list:
             if vector.isConstantVector:
                 # For constant vectors, get the binary data and convert it once
                 binary_data = vector.data.numericDecimal128ConstantData.data
+                # Get scale with backward compatibility for older engines
+                scale = getattr(vector.data.numericDecimal128ConstantData, 'scale', None)
 
                 # Convert binary data to BigDecimal equivalent
                 if binary_data:
-                    decimal_value = _binary_to_decimal128(binary_data)
+                    decimal_value = _binary_to_decimal128(binary_data, scale)
                 else:
                     decimal_value = Decimal('0')
 
@@ -639,13 +665,16 @@ def get_column_from_chunk(vector: Vector) -> list:
                         value_array.append(decimal_value)
             else:
                 # For non-constant vectors, process each row individually
+                # Get scale from decimal128Data (with backward compatibility)
+                scale = getattr(vector.data.decimal128Data, 'scale', None)
+
                 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)
+                    decimal_value = _binary_to_decimal128(binary_data, scale)
                     value_array.append(decimal_value)
         else:
             value_array.append(None)

e6data_python_connector/e6data_grpc.py

@@ -8,24 +8,28 @@ from __future__ import unicode_literals
 
 import datetime
 import logging
+import os
 import re
 import sys
+import threading
 import time
 from decimal import Decimal
 from io import BytesIO
 from ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
-import threading
-import multiprocessing
 
 import grpc
 from grpc._channel import _InactiveRpcError
 
 from e6data_python_connector.cluster_manager import ClusterManager
-from e6data_python_connector.strategy import _get_grpc_header as _get_strategy_header
-from e6data_python_connector.common import DBAPITypeObject, ParamEscaper, DBAPICursor
-from e6data_python_connector.constants import *
-from e6data_python_connector.datainputstream import get_query_columns_info, read_rows_from_chunk
+from e6data_python_connector.common import DBAPITypeObject, ParamEscaper, DBAPICursor, get_ssl_credentials
+from e6data_python_connector.constants import (
+    MAX_RETRY_ATTEMPTS, RETRY_SLEEP_SECONDS, GRPC_ERROR_STRATEGY_MISMATCH, GRPC_ERROR_ACCESS_DENIED,
+    PRIMITIVE_TYPES
+)
+from e6data_python_connector.datainputstream import get_query_columns_info, read_rows_from_chunk, \
+    is_fastbinary_available
 from e6data_python_connector.server import e6x_engine_pb2_grpc, e6x_engine_pb2
+from e6data_python_connector.strategy import _get_grpc_header
 from e6data_python_connector.typeId import *
 
 apilevel = '2.0'
@@ -69,7 +73,7 @@ TYPES_CONVERTER = {
 
 def re_auth(func):
     def wrapper(self, *args, **kwargs):
-        max_retry = 5
+        max_retry = MAX_RETRY_ATTEMPTS
         current_retry = 0
         while current_retry < max_retry:
             try:
@@ -78,10 +82,10 @@ def re_auth(func):
                 current_retry += 1
                 if current_retry == max_retry:
                     raise e
-                if e.code() == grpc.StatusCode.INTERNAL and 'Access denied' in e.details():
-                    time.sleep(0.2)
+                if e.code() == grpc.StatusCode.INTERNAL and GRPC_ERROR_ACCESS_DENIED in e.details():
+                    time.sleep(RETRY_SLEEP_SECONDS)
                     self.connection.get_re_authenticate_session_id()
-                elif 'status: 456' in e.details():
+                elif GRPC_ERROR_STRATEGY_MISMATCH in e.details():
                     # Strategy changed, clear cache and retry
                     _clear_strategy_cache()
                     # Force re-authentication which will detect new strategy
@@ -302,12 +306,6 @@ def _get_strategy_debug_info():
         }
 
 
-def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
-    """Generate gRPC metadata headers for the request."""
-    # Use the strategy module's implementation
-    return _get_strategy_header(engine_ip=engine_ip, cluster=cluster, strategy=strategy)
-
-
 def connect(*args, **kwargs):
     """Constructor for creating a connection to the database. See class :py:class:`Connection` for
     arguments.
@@ -329,10 +327,12 @@ class Connection(object):
             database: str = None,
             cluster_name: str = None,
             secure: bool = False,
+            ssl_cert = None,
             auto_resume: bool = True,
             scheme: str = 'e6data',
             grpc_options: dict = None,
             debug: bool = False,
+            require_fastbinary: bool = True,
     ):
         """
         Parameters
@@ -353,6 +353,9 @@ class Connection(object):
                 Cluster's name
             secure: bool, Optional
                 Flag to use a secure channel for data transfer
+            ssl_cert: str or bytes, Optional
+                Path to CA certificate file (PEM format) or certificate content as bytes for
+                secure connections. If None, system default CA bundle is used.
             auto_resume: bool, Optional
                 Flag to enable auto resume of the cluster before the query execution
             scheme: string, Optional
@@ -366,6 +369,10 @@ class Connection(object):
                 - keepalive_time_ms: This parameter defines the time, in milliseconds, Default to 30 seconds
             debug: bool, Optional
                 Flag to enable debug logging for blue-green deployment strategy changes
+            require_fastbinary: bool, Optional
+                Flag to require fastbinary module for Thrift deserialization. If True (default),
+                raises an exception if fastbinary is not available. If False, logs a warning
+                and continues with pure Python implementation (with reduced performance).
         """
         if not username or not password:
             raise ValueError("username or password cannot be empty.")
@@ -380,11 +387,35 @@ class Connection(object):
         self._port = port
 
         self._secure_channel = secure
+        self._ssl_cert = ssl_cert
 
         self.catalog_name = catalog
 
         self._auto_resume = auto_resume
 
+        # Store require_fastbinary flag
+        self._require_fastbinary = require_fastbinary
+
+        # Check fastbinary availability at connection creation time
+        if not is_fastbinary_available():
+            if require_fastbinary:
+                raise Exception(
+                    """
+                    Failed to import fastbinary.
+                    Did you install system dependencies?
+                    Please verify https://github.com/e6x-labs/e6data-python-connector#dependencies
+
+                    To continue without fastbinary (with reduced performance), set require_fastbinary=False
+                    in the connection parameters.
+                    """
+                )
+            else:
+                logger.warning(
+                    "fastbinary module is not available. Using pure Python implementation. "
+                    "Performance may be degraded. To enable fastbinary, install system dependencies: "
+                    "https://github.com/e6x-labs/e6data-python-connector#dependencies"
+                )
+
         self._grpc_options = grpc_options
         if self._grpc_options is None:
             self._grpc_options = dict()
@@ -400,8 +431,51 @@ class Connection(object):
         self._debug = debug
         if self._debug:
             _debug_connections.add(id(self))
+
+        # Enable comprehensive debugging if debug flag is set
+        if self._debug:
+            # Configure root logger for DEBUG level
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format='[%(name)s] %(asctime)s - %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S',
+                force=True  # Force reconfiguration even if logging is already configured
+            )
+
+            # Note: gRPC C++ core tracing (GRPC_VERBOSITY and GRPC_TRACE) must be set
+            # BEFORE the gRPC module is imported to take effect. Setting them at runtime
+            # will not enable HTTP/2 frame logs or low-level tracing.
+            #
+            # To enable full gRPC network tracing, set these environment variables
+            # before starting your Python script:
+            #   export GRPC_VERBOSITY=DEBUG
+            #   export GRPC_TRACE=client_channel,http2
+            #
+            # The following runtime settings only affect Python-level logging:
+
+            # Enable gRPC Python logging (this works at runtime)
+            os.environ['GRPC_PYTHON_LOG_LEVEL'] = 'DEBUG'
+            os.environ['GRPC_PYTHON_LOG_STDERR'] = '1'
+
+            # Ensure gRPC logger is at DEBUG level
+            grpc_logger = logging.getLogger('grpc')
+            grpc_logger.setLevel(logging.DEBUG)
+
+            # Enable gRPC transport logger
+            grpc_transport_logger = logging.getLogger('grpc._channel')
+            grpc_transport_logger.setLevel(logging.DEBUG)
+
+            # Enable gRPC server logger
+            grpc_server_logger = logging.getLogger('grpc._server')
+            grpc_server_logger.setLevel(logging.DEBUG)
+
+            # Set e6data connector logger to DEBUG
+            e6data_logger = logging.getLogger('e6data_python_connector')
+            e6data_logger.setLevel(logging.DEBUG)
+
             _strategy_debug_log(f"Debug mode enabled for connection {id(self)}")
-        
+            _strategy_debug_log(f"GRPC_TRACE={os.environ.get('GRPC_TRACE')}")
+
         self._create_client()
 
     @property
@@ -453,11 +527,12 @@ class Connection(object):
         Raises:
             grpc.RpcError: If there is an error in creating the gRPC channel or client stub.
         """
+
         if self._secure_channel:
             self._channel = grpc.secure_channel(
                 target='{}:{}'.format(self._host, self._port),
                 options=self._get_grpc_options,
-                credentials=grpc.ssl_channel_credentials()
+                credentials=get_ssl_credentials(self._ssl_cert)
             )
         else:
             self._channel = grpc.insecure_channel(
@@ -577,7 +652,7 @@ class Connection(object):
                         _strategy_debug_log(f"No cached strategy, will try strategies in order: {strategies}")
                     last_error = None
                     for strategy in strategies:
-                        _strategy_debug_log(f"1Attempting authentication with strategy: {strategy}")
+                        _strategy_debug_log(f"Attempting authentication with strategy: {strategy}.")
                         try:
                             authenticate_response = self._client.authenticate(
                                 authenticate_request,
@@ -639,7 +714,8 @@ class Connection(object):
                     secure_channel=self._secure_channel,
                     cluster_uuid=self.cluster_name,
                     timeout=self.grpc_auto_resume_timeout_seconds,
-                    debug=self._debug
+                    debug=self._debug,
+                    ssl_cert=self._ssl_cert
                 ).resume()
                 return status  # Return boolean status directly
             else:
@@ -1418,7 +1494,10 @@ class Cursor(DBAPICursor):
         if not buffer or len(buffer) == 0:
             return None
         # one batch retrieves the predefined set of rows
-        return read_rows_from_chunk(self._query_columns_description, buffer)
+        return read_rows_from_chunk(
+            self._query_columns_description,
+            buffer
+        )
 
     def fetchall(self):
         """

e6data_python_connector/e6x_vector/ttypes.py

@@ -881,13 +881,15 @@ class Decimal128Data(object):
     """
     Attributes:
      - data
+     - scale
 
     """
     thrift_spec = None
 
 
-    def __init__(self, data = None,):
+    def __init__(self, data = None, scale = None,):
         self.data = data
+        self.scale = scale
 
     def read(self, iprot):
         if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
@@ -908,6 +910,11 @@ class Decimal128Data(object):
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
+            elif fid == 2:
+                if ftype == TType.I32:
+                    self.scale = iprot.readI32()
+                else:
+                    iprot.skip(ftype)
             else:
                 iprot.skip(ftype)
             iprot.readFieldEnd()
@@ -926,6 +933,10 @@ class Decimal128Data(object):
                 oprot.writeBinary(iter55)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
+        if self.scale is not None:
+            oprot.writeFieldBegin('scale', TType.I32, 2)
+            oprot.writeI32(self.scale)
+            oprot.writeFieldEnd()
         oprot.writeFieldStop()
         oprot.writeStructEnd()
 
@@ -1310,13 +1321,15 @@ class NumericDecimal128ConstantData(object):
     """
     Attributes:
      - data
+     - scale
 
     """
     thrift_spec = None
 
 
-    def __init__(self, data = None,):
+    def __init__(self, data = None, scale = None,):
         self.data = data
+        self.scale = scale
 
     def read(self, iprot):
         if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
@@ -1332,6 +1345,11 @@ class NumericDecimal128ConstantData(object):
                     self.data = iprot.readBinary()
                 else:
                     iprot.skip(ftype)
+            elif fid == 2:
+                if ftype == TType.I32:
+                    self.scale = iprot.readI32()
+                else:
+                    iprot.skip(ftype)
             else:
                 iprot.skip(ftype)
             iprot.readFieldEnd()
@@ -1347,6 +1365,10 @@ class NumericDecimal128ConstantData(object):
             oprot.writeFieldBegin('data', TType.STRING, 1)
             oprot.writeBinary(self.data)
             oprot.writeFieldEnd()
+        if self.scale is not None:
+            oprot.writeFieldBegin('scale', TType.I32, 2)
+            oprot.writeI32(self.scale)
+            oprot.writeFieldEnd()
         oprot.writeFieldStop()
         oprot.writeStructEnd()
 
@@ -1783,6 +1805,7 @@ all_structs.append(Decimal128Data)
 Decimal128Data.thrift_spec = (
     None,  # 0
     (1, TType.LIST, 'data', (TType.STRING, 'BINARY', False), None, ),  # 1
+    (2, TType.I32, 'scale', None, None, ),  # 2
 )
 all_structs.append(VarcharData)
 VarcharData.thrift_spec = (
@@ -1818,6 +1841,7 @@ all_structs.append(NumericDecimal128ConstantData)
 NumericDecimal128ConstantData.thrift_spec = (
     None,  # 0
     (1, TType.STRING, 'data', 'BINARY', None, ),  # 1
+    (2, TType.I32, 'scale', None, None, ),  # 2
 )
 all_structs.append(TemporalIntervalConstantData)
 TemporalIntervalConstantData.thrift_spec = (