Сериализация Sqlite3 в Python

Ответ 1

Модуль SQLite Python не является потокобезопасным. Если вы отключите его проверку, вам необходимо обеспечить, чтобы весь код был сериализован и включал сборку мусора. (Мой модуль APSW является потокобезопасным, а также правильно обрабатывает проблемы безопасности потока сообщений об ошибках).

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

Ответ 2

Я написал библиотеку, чтобы решить эту проблему. Работает для меня.

https://github.com/palantir/sqlite3worker

Ответ 3

Страница sqlite http://www.sqlite.org/threadsafe.html говорит: "Режим по умолчанию сериализуется". Вы протестировали его и обнаружили, что это не так?

Edit:

Если он не работает, возможно, ctypes? Я не знаю, повлияет ли это на загруженный модуль sqlite. Наверное, я подозреваю, что это не так; как я полагаю, функция sqlite3_initialize(), вероятно, вызывается при загрузке модуля? Или, может быть, только при создании объекта базы данных?

http://www.sqlite.org/c3ref/config.html

>>> import sqlite3
>>> import ctypes
>>> from ctypes.util import find_library
>>> sqlite_lib = ctypes.CDLL(find_library('sqlite3'))
>>> sqlite_lib.sqlite3_config(3) # http://www.sqlite.org/c3ref/c_abort.html
0   # no error....
>>> 

Ответ 4

Из Verse Quiz, вас могут заинтересовать методы __init__, __serve и __fetch, чтобы вы начали создавая сериализованный интерфейс базы данных SQLite3 в Python. Надеюсь, что это поможет вам!

import _thread
import sqlite3
import queue

################################################################################

class Server:

    """Execute a protected SQLite3 database on a singular thread.

    Since a SQLite3 database can only accept queries on the thread that it
    was created on, this server receives requests through a queue and sends
    back the result through a list and mutex mechanism."""

    def __init__(self, *args):
        """Initialize the Server with a SQLite3 database thread."""
        self.__lock = _thread.allocate_lock()
        self.__lock.acquire()
        _thread.start_new_thread(self.__serve, args)
        self.__lock.acquire()
        del self.__lock
        if self.__error is not None:
            raise self.__error
        del self.__error

    def __serve(self, *args):
        """Run a server continuously to answer SQL queries.

        A SQLite3 connection is made in this thread with errors being raised
        again for the instantiator. If the connection was made successfully,
        then the server goes into a continuous loop, processing SQL queries."""
        try:
            database = sqlite3.connect(*args)
        except:
            self.__error = error = sys.exc_info()[1]
        else:
            self.__error = error = None
        self.__lock.release()
        if error is None:
            self.__QU = queue.Queue()
            while True:
                lock, one, sql, parameters, ret = self.__QU.get()
                try:
                    cursor = database.cursor()
                    cursor.execute(sql, parameters)
                    data = cursor.fetchone() if one else cursor.fetchall()
                    ret.extend([True, data])
                except:
                    ret.extend([False, sys.exc_info()[1]])
                lock.release()

    def fetch(self, one, sql, *parameters):
        """Execute the specified SQL query and return the results.

        This is a powerful shortcut method that is the closest connection
        other threads will have with the SQL server. The parameters for the
        query are dumped into a queue, and the answer is retrieved when it
        becomes available. This prevents SQLite3 from throwing exceptions."""
        lock, ret = _thread.allocate_lock(), []
        lock.acquire()
        self.__QU.put((lock, one, sql, parameters, ret))
        lock.acquire()
        if ret[0]:
            return ret[1]
        raise ret[1]