Какое лучшее решение для пула соединений с базой данных в python?

ИМО, более очевидное/более идиоматичное/лучшее решение - использовать существующую ORM, а не изобретать классы, подобные DAO.

Мне кажется, что ORM более популярны, чем необработанные соединения SQL. Почему? Потому что Python является объектно-ориентированным, и сопоставление строки SQL с объектом является абсолютно необходимым. Существует не так много случаев использования, когда вы имеете дело со строками SQL, которые не сопоставляются с объектами Python.

Я думаю, что SQLAlchemy или SQLObject (и связанный с ним пул соединений) являются более идиоматичными решениями Pythonic.

Объединение в пул как отдельная функция не очень распространено, потому что чистый SQL (без сопоставления объектов) не очень популярен для сложных, длительных процессов, которые выигрывают от объединения соединений. Да, чистый SQL используется, но он всегда используется в более простых или более контролируемых приложениях, где объединение в пул бесполезно.

Я думаю, у вас может быть два варианта:

1. Пересмотрите свои классы, чтобы использовать SQLAlchemy или SQLObject. Хотя поначалу это кажется болезненным (вся эта работа потрачена впустую), вы должны быть в состоянии использовать весь дизайн и мысли. Это просто упражнение по внедрению широко используемого решения ORM и пула.
2. Разверните свой собственный простой пул соединений, используя описанный вами алгоритм — простой набор или список соединений, которые вы циклически перебираете.

В MySQL?

Я бы сказал, не беспокойтесь о пуле соединений. Они часто являются источником проблем, и с MySQL они не принесут вам преимущества в производительности, на которое вы надеетесь. Этот путь может потребовать больших усилий — политически — потому что в этом пространстве так много передовых практик и пустословия в учебниках о преимуществах пула соединений.

Пулы соединений — это просто мост между пост-веб-эрой приложений без сохранения состояния (например, протокола HTTP) и до-веб-эрой долгоживущих приложений пакетной обработки с отслеживанием состояния. Поскольку соединения в базах данных до Интернета были очень дорогими (поскольку никто не слишком заботился о том, сколько времени требуется для установления соединения), пост-веб-приложения разработали эту схему пула соединений, чтобы каждое попадание не вызывало таких огромных накладных расходов на обработку. на РСУБД.

Поскольку MySQL больше похож на СУБД веб-эры, соединения чрезвычайно легкие и быстрые. Я написал много веб-приложений большого объема, которые вообще не используют пул соединений для MySQL.

Это осложнение, без которого вы можете обойтись, если не существует политического препятствия, которое необходимо преодолеть.

Оберните свой класс подключения.

Установите ограничение на количество подключений, которые вы делаете. Вернуть неиспользуемое соединение. Перехват близко, чтобы освободить соединение.

Обновление: я поместил что-то вроде этого в dbpool.py:

import sqlalchemy.pool as pool
import MySQLdb as mysql
mysql = pool.manage(mysql)

Старый поток, но для пула общего назначения (соединений или любого дорогого объекта) я использую что-то вроде:

def pool(ctor, limit=None):
    local_pool = multiprocessing.Queue()
    n = multiprocesing.Value('i', 0)
    @contextlib.contextmanager
    def pooled(ctor=ctor, lpool=local_pool, n=n):
        # block iff at limit
        try: i = lpool.get(limit and n.value >= limit)
        except multiprocessing.queues.Empty:
            n.value += 1
            i = ctor()
        yield i
        lpool.put(i)
    return pooled

Который строится лениво, имеет необязательный предел и должен обобщаться на любой вариант использования, который я могу придумать. Конечно, это предполагает, что вам действительно нужен пул любого ресурса, чего может не быть для многих современных SQL-подобных. Использование:

# in main:
my_pool = pool(lambda: do_something())
# in thread:
with my_pool() as my_obj:
    my_obj.do_something()

Это предполагает, что любой объект, который создает ctor, имеет соответствующий деструктор, если это необходимо (некоторые серверы не убивают объекты подключения, если они не закрыты явно).

Я как раз искал нечто подобное.

Я нашел pysqlpool и модуль пула sqlalchemy

Создание собственного пула соединений — ПЛОХАЯ идея, если ваше приложение когда-нибудь решит начать использовать многопоточность. Создание пула соединений для многопоточного приложения намного сложнее, чем для однопоточного приложения. В этом случае вы можете использовать что-то вроде PySQLPool.

Также ПЛОХАЯ идея использовать ORM, если вам нужна производительность.

Если вы будете иметь дело с огромными/тяжелыми базами данных, которые должны обрабатывать множество выборок, вставок, обновлений и удалений одновременно, вам понадобится производительность, а это означает, что вам понадобится собственный SQL, написанный для оптимизации поиска. и время блокировки. С ORM у вас обычно нет такой гибкости.

В общем, да, вы можете создать свой собственный пул соединений и использовать ORM, но только если вы уверены, что вам не понадобится ничего из того, что я только что описал.

Отвечая на старый поток, но в последний раз, когда я проверял, MySQL предлагает пул соединений как часть своих драйверов.

Вы можете ознакомиться с ними по адресу:

https://dev.mysql.com/doc/connector-python/en/connector-python-connection-pooling.html

Из TFA, если вы хотите явно открыть пул соединений (как заявил OP):

dbconfig = {  "database": "test", "user":"joe" }
cnxpool = mysql.connector.pooling.MySQLConnectionPool(pool_name = "mypool",pool_size = 3, **dbconfig)

Затем доступ к этому пулу осуществляется путем запроса из пула через функцию get_connection().

cnx1 = cnxpool.get_connection()
cnx2 = cnxpool.get_connection()

Используйте DBUtils, просто и надежно.

pip install DBUtils