Why each get_connection call needs its own close in Python

by

Summary

The core issue is whether a supplier method (get_connection()) that returns a database connection will allow proper closing across different methods. The key takeaway is: closing a connection in one method does not affect other instances of the connection created by get_connection(), as each call generates a new connection object.

Root Cause

  • Each get_connection() call creates a new database connection
  • Closing in one method (do_update) only affects that specific connection
  • Other methods calling get_connection() later will get a fresh, unclosed connection

Why This Happens in Real Systems

  • Python does not reuse objects between function calls unless explicitly shared
  • Database connections are stateful objects; closing one does not impact others
  • No central connection pool is implied by the get_connection() pattern

Real-World Impact

  • Resource exhaustion: Unclosed connections could accumulate if methods call get_connection() repeatedly
  • Connection leaks: Failure to close connections in all paths may hit database limits
  • Unexpected behavior: A closed connection in one method does not propagate to others

Example or Code (if necessary and relevant)

def get_connection():  
    return pyodbc.connect(...)  # Creates a NEW connection each time  

def do_update():  
    cnxn = get_connection()  # New connection A  
    # ... operations ...  
    cnxn.close()  # Closes ONLY connection A  

def do_delete():  
    cnxn = get_connection()  # New connection B  
    # ... operations ...  
    # If NOT closed here, connection B leaks

Note: This code is valid syntax but does not reuse connections across methods.

How Senior Engineers Fix It

  • Pass the connection object explicitly between methods instead of using get_connection() 
    def do_update(conn):  
    # Use conn here  
    conn.close()  
def do_delete():  
    conn = get_connection()  
    do_update(conn)  # Explicitly pass and close
  • Use context managers (with statements) for automatic cleanup 
    with pyodbc.connect(...) as conn:  
    # Operations  
# conn is automatically closed
  • Implement a connection pool for shared, managed connections in high-concurrency scenarios

Why Juniors Miss It

  • Junior engineers assume closing a connection in one method affects all future calls to get_connection()
  • They forget that get_connection() creates a new connection on each invocation
  • They miss the distinction between object lifetime and function scope
  • They overlook the need for explicit connection management in distributed method calls

Leave a Comment