Home/ Questions/Q 46637
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-10T15:59:49+00:00

I have developed some custom DAO-like classes to meet some very specialized requirements for

  • 0

I have developed some custom DAO-like classes to meet some very specialized requirements for my project that is a server-side process that does not run inside any kind of framework.

The solution works great except that every time a new request is made, I open a new connection via MySQLdb.connect.

What is the best ‘drop in’ solution to switch this over to using connection pooling in python? I am imagining something like the commons DBCP solution for Java.

The process is long running and has many threads that need to make requests, but not all at the same time… specifically they do quite a lot of work before brief bursts of writing out a chunk of their results.

Edited to add: After some more searching I found anitpool.py which looks decent, but as I’m relatively new to python I guess I just want to make sure I’m not missing a more obvious/more idiomatic/better solution.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. IMO, the "more obvious/more idiomatic/better solution" is to use an existing ORM rather than invent DAO-like classes.

    It appears to me that ORM’s are more popular than "raw" SQL connections. Why? Because Python is OO, and the mapping from a SQL row to an object is absolutely essential. There aren’t many use cases where you deal with SQL rows that don’t map to Python objects.

    I think that SQLAlchemy or SQLObject (and the associated connection pooling) are the more idiomatic Pythonic solutions.

    Pooling as a separate feature isn’t very common because pure SQL (without object mapping) isn’t very popular for the kind of complex, long-running processes that benefit from connection pooling. Yes, pure SQL is used, but it’s always used in simpler or more controlled applications where pooling isn’t helpful.

    I think you might have two alternatives:

    1. Revise your classes to use SQLAlchemy or SQLObject. While this appears painful at first (all that work wasted), you should be able to leverage all the design and thought. It’s merely an exercise in adopting a widely-used ORM and pooling solution.
    2. Roll out your own simple connection pool using the algorithm you outlined — a simple Set or List of connections that you cycle through.
    • 0