SNOW-2900899: snowflake.connector.connect modifies the input session_parameters dictionary in-place

[tekumara]

Python version

n/a

Operating system and processor architecture

n/a

Installed packages

snowflake-connector-python==4.1.1

What did you do?

def test_server_session_parameters_are_modified(server: dict) -> None:
    session_parameters = {"CLIENT_VALIDATE_DEFAULT_PARAMETERS": True}
    original_session_parameters = session_parameters.copy()

    with snowflake.connector.connect(**server | {"session_parameters": session_parameters}, autocommit=False):
        pass

    # session_parameters are modified by the connector based on connect kwargs and defaults
    assert session_parameters == original_session_parameters

Fails with

FAILED tests/test_server.py::test_server_session_parameters_are_modified - AssertionError: assert {'CLIENT_VALIDATE_DEFAULT_PARAMETERS': True, 'AUTOCOMMIT': False, 'CLIENT_PREFETCH_THREADS': 4, 'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY': 3600, 'TIMEZONE': 'Etc/UTC'} == {'CLIENT_VALIDATE_DEFAULT_PARAMETERS': True}
  
  Common items:
  {'CLIENT_VALIDATE_DEFAULT_PARAMETERS': True}
  Left contains 4 more items:
  {'AUTOCOMMIT': False,
   'CLIENT_PREFETCH_THREADS': 4,
   'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY': 3600,
   'TIMEZONE': 'Etc/UTC'}
  
  Full diff:
    {
  +     'AUTOCOMMIT': False,
  +     'CLIENT_PREFETCH_THREADS': 4,
  +     'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY': 3600,
        'CLIENT_VALIDATE_DEFAULT_PARAMETERS': True,
  +     'TIMEZONE': 'Etc/UTC',
    }

What did you expect to see?

The session_parameters dict should not be modified, because this can cause unintended side effects. If a user defines a session_parameters dictionary and reuses it for multiple connections, modifying it in-place means the second connection inherits settings (like autocommit=False) from the first one. This can lead to subtle bugs where subsequent connections behave differently than the first one, solely based on execution order.

Also session_parameters are inputs to the connection. By writing back response values (like TIMEZONE, or CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY) into the input dictionary, the connector is mixing "configuration" (what I want) with "state" (what I got), which makes the dictionary an unreliable record of the initial configuration.

Can you set logging to DEBUG and collect the logs?

import logging
import os

for logger_name in ('snowflake.connector',):
    logger = logging.getLogger(logger_name)
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.DEBUG)
    ch.setFormatter(logging.Formatter('%(asctime)s - %(threadName)s %(filename)s:%(lineno)d - %(funcName)s() - %(levelname)s - %(message)s'))
    logger.addHandler(ch)

[sfc-gh-sghosh]

Hello @tekumara ,

Thanks for raising the issue.

Could you please clarify what you expecting, by default after connection, there will be many default parameters will get added to the session, its by default.

If you observing that while creating the connection the parameters which user has set in session_parameters, got changed after the connection, then that could be the concern, but I dont see that issue here, whatever parameters being set explicitly by user in session_parameters during connection, the same value is being honoured after connection as well, but yes many other default parameters will get added, that is by design.

Example:

import snowflake.connector
from typing import Dict, Any


# !!! IMPORTANT: REPLACE THESE WITH YOUR ACTUAL SNOWFLAKE CREDENTIALS !!!
SNOWFLAKE_ACCOUNT = "xxxxx"  
SNOWFLAKE_USER = "xxxx"
SNOWFLAKE_PASSWORD = "xxxx"


tracking_session_params: Dict[str, Any] = {
    "QUERY_TAG": "EndOfMonthFinancials",
    "AUTOCOMMIT": "False" 
}

# Preserve the original state for comparison
original_keys_and_values = tracking_session_params.copy()

# All other connection arguments
CONNECTION_KWARGS = {
    "account": SNOWFLAKE_ACCOUNT,
    "user": SNOWFLAKE_USER,
    "password": SNOWFLAKE_PASSWORD,
   
}




PARAMETER_TO_CHECK = "AUTOCOMMIT" 

print(f"--- INITIAL STATE ---")
print(f"Original dictionary size: {len(tracking_session_params)} keys.")
print(f"Initial value of '{PARAMETER_TO_CHECK}': **{tracking_session_params[PARAMETER_TO_CHECK]}** (Type: {type(tracking_session_params[PARAMETER_TO_CHECK]).__name__})")
print("-" * 30)

print("Attempting connection...")
conn = None # Initialize conn outside try block
try:
    
    conn = snowflake.connector.connect(
        **CONNECTION_KWARGS,
        session_parameters=tracking_session_params 
    )
    print("Connection successful.")
    
    
    print(f"Autocommit setting on the connection object (conn.autocommit): **{conn.autocommit}**")

except snowflake.connector.errors.ProgrammingError as e:
    print(f"ERROR: Failed to connect to Snowflake. Check credentials.")
finally:
    if conn:
        conn.close()





Output:
--- INITIAL STATE ---
Original dictionary size: 2 keys.
Initial value of 'AUTOCOMMIT': **False** (Type: str)
------------------------------
Attempting connection...
Connection successful.
Autocommit setting on the connection object (conn.autocommit): **<bound method SnowflakeConnection.autocommit of <snowflake.connector.connection.SnowflakeConnection object at 0x11af42fd0>>**
------------------------------
--- CHECKING FOR MUTATION IN INPUT DICTIONARY ---
Original value of 'AUTOCOMMIT': **False**
Final value of 'AUTOCOMMIT' in the dictionary: **False** (Type: bool)

[tekumara]

I understand that there are default session parameters included in the login request, which is fine.

The point is defaults, and kwargs like autocommit, should not be added to the session_parameters input dictionary passed by the caller, for the reasons stated above.