Edit File: pysqlite.cpython-311.pyc
� u�d�Q � � � d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd lm Z dd lm Z G d � d e� � Z G d� de� � Z G d� de� � ZeZdS )a�; .. dialect:: sqlite+pysqlite :name: pysqlite :dbapi: sqlite3 :connectstring: sqlite+pysqlite:///file_path :url: http://docs.python.org/library/sqlite3.html Note that ``pysqlite`` is the same driver as the ``sqlite3`` module included with the Python distribution. Driver ------ The ``sqlite3`` Python DBAPI is standard on all modern Python versions; for cPython and Pypy, no additional installation is necessary. Connect Strings --------------- The file specification for the SQLite database is taken as the "database" portion of the URL. Note that the format of a SQLAlchemy url is:: driver://user:pass@host/database This means that the actual filename to be used starts with the characters to the **right** of the third slash. So connecting to a relative filepath looks like:: # relative path e = create_engine('sqlite:///path/to/database.db') An absolute path, which is denoted by starting with a slash, means you need **four** slashes:: # absolute path e = create_engine('sqlite:////path/to/database.db') To use a Windows path, regular drive specifications and backslashes can be used. Double backslashes are probably needed:: # absolute path on Windows e = create_engine('sqlite:///C:\\path\\to\\database.db') The sqlite ``:memory:`` identifier is the default if no filepath is present. Specify ``sqlite://`` and nothing else:: # in-memory database e = create_engine('sqlite://') .. _pysqlite_uri_connections: URI Connections ^^^^^^^^^^^^^^^ Modern versions of SQLite support an alternative system of connecting using a `driver level URI <https://www.sqlite.org/uri.html>`_, which has the advantage that additional driver-level arguments can be passed including options such as "read only". The Python sqlite3 driver supports this mode under modern Python 3 versions. The SQLAlchemy pysqlite driver supports this mode of use by specifing "uri=true" in the URL query string. The SQLite-level "URI" is kept as the "database" portion of the SQLAlchemy url (that is, following a slash):: e = create_engine("sqlite:///file:path/to/database?mode=ro&uri=true") .. note:: The "uri=true" parameter must appear in the **query string** of the URL. It will not currently work as expected if it is only present in the :paramref:`_sa.create_engine.connect_args` parameter dictionary. The logic reconciles the simultaneous presence of SQLAlchemy's query string and SQLite's query string by separating out the parameters that belong to the Python sqlite3 driver vs. those that belong to the SQLite URI. This is achieved through the use of a fixed list of parameters known to be accepted by the Python side of the driver. For example, to include a URL that indicates the Python sqlite3 "timeout" and "check_same_thread" parameters, along with the SQLite "mode" and "nolock" parameters, they can all be passed together on the query string:: e = create_engine( "sqlite:///file:path/to/database?" "check_same_thread=true&timeout=10&mode=ro&nolock=1&uri=true" ) Above, the pysqlite / sqlite3 DBAPI would be passed arguments as:: sqlite3.connect( "file:path/to/database?mode=ro&nolock=1", check_same_thread=True, timeout=10, uri=True ) Regarding future parameters added to either the Python or native drivers. new parameter names added to the SQLite URI scheme should be automatically accommodated by this scheme. New parameter names added to the Python driver side can be accommodated by specifying them in the :paramref:`_sa.create_engine.connect_args` dictionary, until dialect support is added by SQLAlchemy. For the less likely case that the native SQLite driver adds a new parameter name that overlaps with one of the existing, known Python driver parameters (such as "timeout" perhaps), SQLAlchemy's dialect would require adjustment for the URL scheme to continue to support this. As is always the case for all SQLAlchemy dialects, the entire "URL" process can be bypassed in :func:`_sa.create_engine` through the use of the :paramref:`_sa.create_engine.creator` parameter which allows for a custom callable that creates a Python sqlite3 driver level connection directly. .. versionadded:: 1.3.9 .. seealso:: `Uniform Resource Identifiers <https://www.sqlite.org/uri.html>`_ - in the SQLite documentation Compatibility with sqlite3 "native" date and datetime types ----------------------------------------------------------- The pysqlite driver includes the sqlite3.PARSE_DECLTYPES and sqlite3.PARSE_COLNAMES options, which have the effect of any column or expression explicitly cast as "date" or "timestamp" will be converted to a Python date or datetime object. The date and datetime types provided with the pysqlite dialect are not currently compatible with these options, since they render the ISO date/datetime including microseconds, which pysqlite's driver does not. Additionally, SQLAlchemy does not at this time automatically render the "cast" syntax required for the freestanding functions "current_timestamp" and "current_date" to return datetime/date types natively. Unfortunately, pysqlite does not provide the standard DBAPI types in ``cursor.description``, leaving SQLAlchemy with no way to detect these types on the fly without expensive per-row type checks. Keeping in mind that pysqlite's parsing option is not recommended, nor should be necessary, for use with SQLAlchemy, usage of PARSE_DECLTYPES can be forced if one configures "native_datetime=True" on create_engine():: engine = create_engine('sqlite://', connect_args={'detect_types': sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES}, native_datetime=True ) With this flag enabled, the DATE and TIMESTAMP types (but note - not the DATETIME or TIME types...confused yet ?) will not perform any bind parameter or result processing. Execution of "func.current_date()" will return a string. "func.current_timestamp()" is registered as returning a DATETIME type in SQLAlchemy, so this function still receives SQLAlchemy-level result processing. .. _pysqlite_threading_pooling: Threading/Pooling Behavior --------------------------- Pysqlite's default behavior is to prohibit the usage of a single connection in more than one thread. This is originally intended to work with older versions of SQLite that did not support multithreaded operation under various circumstances. In particular, older SQLite versions did not allow a ``:memory:`` database to be used in multiple threads under any circumstances. Pysqlite does include a now-undocumented flag known as ``check_same_thread`` which will disable this check, however note that pysqlite connections are still not safe to use in concurrently in multiple threads. In particular, any statement execution calls would need to be externally mutexed, as Pysqlite does not provide for thread-safe propagation of error messages among other things. So while even ``:memory:`` databases can be shared among threads in modern SQLite, Pysqlite doesn't provide enough thread-safety to make this usage worth it. SQLAlchemy sets up pooling to work with Pysqlite's default behavior: * When a ``:memory:`` SQLite database is specified, the dialect by default will use :class:`.SingletonThreadPool`. This pool maintains a single connection per thread, so that all access to the engine within the current thread use the same ``:memory:`` database - other threads would access a different ``:memory:`` database. * When a file-based database is specified, the dialect will use :class:`.NullPool` as the source of connections. This pool closes and discards connections which are returned to the pool immediately. SQLite file-based connections have extremely low overhead, so pooling is not necessary. The scheme also prevents a connection from being used again in a different thread and works best with SQLite's coarse-grained file locking. Using a Memory Database in Multiple Threads ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To use a ``:memory:`` database in a multithreaded scenario, the same connection object must be shared among threads, since the database exists only within the scope of that connection. The :class:`.StaticPool` implementation will maintain a single connection globally, and the ``check_same_thread`` flag can be passed to Pysqlite as ``False``:: from sqlalchemy.pool import StaticPool engine = create_engine('sqlite://', connect_args={'check_same_thread':False}, poolclass=StaticPool) Note that using a ``:memory:`` database in multiple threads requires a recent version of SQLite. Using Temporary Tables with SQLite ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Due to the way SQLite deals with temporary tables, if you wish to use a temporary table in a file-based SQLite database across multiple checkouts from the connection pool, such as when using an ORM :class:`.Session` where the temporary table should continue to remain after :meth:`.Session.commit` or :meth:`.Session.rollback` is called, a pool which maintains a single connection must be used. Use :class:`.SingletonThreadPool` if the scope is only needed within the current thread, or :class:`.StaticPool` is scope is needed within multiple threads for this case:: # maintain the same connection per thread from sqlalchemy.pool import SingletonThreadPool engine = create_engine('sqlite:///mydb.db', poolclass=SingletonThreadPool) # maintain the same connection across all threads from sqlalchemy.pool import StaticPool engine = create_engine('sqlite:///mydb.db', poolclass=StaticPool) Note that :class:`.SingletonThreadPool` should be configured for the number of threads that are to be used; beyond that number, connections will be closed out in a non deterministic way. Unicode ------- The pysqlite driver only returns Python ``unicode`` objects in result sets, never plain strings, and accommodates ``unicode`` objects within bound parameter values in all cases. Regardless of the SQLAlchemy string type in use, string-based result values will by Python ``unicode`` in Python 2. The :class:`.Unicode` type should still be used to indicate those columns that require unicode, however, so that non-``unicode`` values passed inadvertently will emit a warning. Pysqlite will emit an error if a non-``unicode`` string is passed containing non-ASCII characters. Dealing with Mixed String / Binary Columns in Python 3 ------------------------------------------------------ The SQLite database is weakly typed, and as such it is possible when using binary values, which in Python 3 are represented as ``b'some string'``, that a particular SQLite database can have data values within different rows where some of them will be returned as a ``b''`` value by the Pysqlite driver, and others will be returned as Python strings, e.g. ``''`` values. This situation is not known to occur if the SQLAlchemy :class:`.LargeBinary` datatype is used consistently, however if a particular SQLite database has data that was inserted using the Pysqlite driver directly, or when using the SQLAlchemy :class:`.String` type which was later changed to :class:`.LargeBinary`, the table will not be consistently readable because SQLAlchemy's :class:`.LargeBinary` datatype does not handle strings so it has no way of "encoding" a value that is in string format. To deal with a SQLite table that has mixed string / binary data in the same column, use a custom type that will check each row individually:: # note this is Python 3 only from sqlalchemy import String from sqlalchemy import TypeDecorator class MixedBinary(TypeDecorator): impl = String def process_result_value(self, value, dialect): if isinstance(value, str): value = bytes(value, 'utf-8') elif value is not None: value = bytes(value) return value Then use the above ``MixedBinary`` datatype in the place where :class:`.LargeBinary` would normally be used. .. _pysqlite_serializable: Serializable isolation / Savepoints / Transactional DDL ------------------------------------------------------- In the section :ref:`sqlite_concurrency`, we refer to the pysqlite driver's assortment of issues that prevent several features of SQLite from working correctly. The pysqlite DBAPI driver has several long-standing bugs which impact the correctness of its transactional behavior. In its default mode of operation, SQLite features such as SERIALIZABLE isolation, transactional DDL, and SAVEPOINT support are non-functional, and in order to use these features, workarounds must be taken. The issue is essentially that the driver attempts to second-guess the user's intent, failing to start transactions and sometimes ending them prematurely, in an effort to minimize the SQLite databases's file locking behavior, even though SQLite itself uses "shared" locks for read-only activities. SQLAlchemy chooses to not alter this behavior by default, as it is the long-expected behavior of the pysqlite driver; if and when the pysqlite driver attempts to repair these issues, that will be more of a driver towards defaults for SQLAlchemy. The good news is that with a few events, we can implement transactional support fully, by disabling pysqlite's feature entirely and emitting BEGIN ourselves. This is achieved using two event listeners:: from sqlalchemy import create_engine, event engine = create_engine("sqlite:///myfile.db") @event.listens_for(engine, "connect") def do_connect(dbapi_connection, connection_record): # disable pysqlite's emitting of the BEGIN statement entirely. # also stops it from emitting COMMIT before any DDL. dbapi_connection.isolation_level = None @event.listens_for(engine, "begin") def do_begin(conn): # emit our own BEGIN conn.execute("BEGIN") .. warning:: When using the above recipe, it is advised to not use the :paramref:`.Connection.execution_options.isolation_level` setting on :class:`_engine.Connection` and :func:`_sa.create_engine` with the SQLite driver, as this function necessarily will also alter the ".isolation_level" setting. Above, we intercept a new pysqlite connection and disable any transactional integration. Then, at the point at which SQLAlchemy knows that transaction scope is to begin, we emit ``"BEGIN"`` ourselves. When we take control of ``"BEGIN"``, we can also control directly SQLite's locking modes, introduced at `BEGIN TRANSACTION <http://sqlite.org/lang_transaction.html>`_, by adding the desired locking mode to our ``"BEGIN"``:: @event.listens_for(engine, "begin") def do_begin(conn): conn.execute("BEGIN EXCLUSIVE") .. seealso:: `BEGIN TRANSACTION <http://sqlite.org/lang_transaction.html>`_ - on the SQLite site `sqlite3 SELECT does not BEGIN a transaction <http://bugs.python.org/issue9924>`_ - on the Python bug tracker `sqlite3 module breaks transactions and potentially corrupts data <http://bugs.python.org/issue10740>`_ - on the Python bug tracker � N� )�DATE)�DATETIME)� SQLiteDialect� )�exc)�pool)�types)�utilc � � e Zd Zd� Zd� ZdS )�_SQLite_pysqliteTimeStampc �> � |j rd S t j | |� � S �N)�native_datetimer �bind_processor��self�dialects �Z/opt/cloudlinux/venv/lib64/python3.11/site-packages/sqlalchemy/dialects/sqlite/pysqlite.pyr z(_SQLite_pysqliteTimeStamp.bind_processorx s% � � � "� :��4��*�4��9�9� 9� c �@ � |j rd S t j | ||� � S r )r r �result_processor�r r �coltypes r r z*_SQLite_pysqliteTimeStamp.result_processor~ s( � � � "� E��4��,�T�7�G�D�D� Dr N��__name__� __module__� __qualname__r r � r r r r w s7 � � � � � �:� :� :� E� E� E� E� Er r c � � e Zd Zd� Zd� ZdS )�_SQLite_pysqliteDatec �> � |j rd S t j | |� � S r )r r r r s r r z#_SQLite_pysqliteDate.bind_processor� s% � � � "� 6��4��&�t�W�5�5� 5r c �@ � |j rd S t j | ||� � S r )r r r r s r r z%_SQLite_pysqliteDate.result_processor� s( � � � "� A��4��(��w��@�@� @r Nr r r r r! r! � s7 � � � � � �6� 6� 6� A� A� A� A� Ar r! c �� � � e Zd ZdZ ej ej ej e ej e i� � Zej sdZdZed� � � Zed� � � Zed� � � Zd� Z� fd�Zd � Zd � Z� xZS ) �SQLiteDialect_pysqlite�qmarkN�pysqlitec � � t j r4 ddlm} n2# t $ r ddlm} n# t $ r}|�d }~ww xY wY n w xY wddlm} |S )Nr )�dbapi2)r �py2k� pysqlite2r) � ImportError�sqlite3)�cls�sqlite�es r �dbapiz SQLiteDialect_pysqlite.dbapi� s� � � �9� 1� �6�6�6�6�6�6�6�� � � � � �8�8�8�8�8�8�8��"� � � ��G����� ���� 9�8� ���� 1� 0� 0� 0� 0� 0�� s$ � � >�'�>� 8�3�8�>�>c �. � |j r |j dk rdS dS )N�:memory:TF)�database�r. �urls r �_is_url_file_dbz&SQLiteDialect_pysqlite._is_url_file_db� s" � � �<� �C�L�J� 6� 6��4��5r c �\ � | � |� � r t j S t j S r )r7 r �NullPool�SingletonThreadPoolr5 s r �get_pool_classz%SQLiteDialect_pysqlite.get_pool_class� s) � � � � �s� #� #� ,��=� ��+� +r c � � | j j S r )r1 �sqlite_version_info)r � connections r �_get_server_version_infoz/SQLiteDialect_pysqlite._get_server_version_info� s � ��z�-�-r c � �� t |d� � r|j }n|}|dk r d |_ d S d|_ t t | � � � ||� � S )Nr> � AUTOCOMMIT� )�hasattrr> �isolation_level�superr% �set_isolation_level)r r> �level�dbapi_connection� __class__s �r rF z*SQLiteDialect_pysqlite.set_isolation_level� sr �� � �:�|� ,� ,� *� )� 4� � � )� � �L� � �/3� � ,� ,� ,�/1� � ,��/��6�6�J�J��E�� � r c � �� |j s|j s|j s|j rt j d|�d�� � �dt fdt fdt fdt fdt fdt fg}|j }i }|D ] \ }}t j ||||� � � � |� dd � � rp|� � � �|D ]\ }}�� |d � � � |j }�r4|d d � �fd �t% �� � D � � � � z z }n.|j pd}|dk r t& j � |� � }|g|fS )NzInvalid SQLite URL: z� Valid SQLite URL forms are: sqlite:///:memory: (or, sqlite://) sqlite:///relative/path/to/file.db sqlite:////absolute/path/to/file.db�uri�timeoutrD � detect_types�check_same_thread�cached_statements)�destF�?�&c 3 �2 �K � | ]}|�d �| ��V � �dS )�=Nr )�.0�key�uri_optss �r � <genexpr>z=SQLiteDialect_pysqlite.create_connect_args.<locals>.<genexpr>� sF �� � � � � � � $'�3�3��� � �6� � � � � � r r3 )�username�password�host�portr � ArgumentError�bool�float�str�int�queryr �coerce_kw_type�get�copy�popr4 �join�sorted�os�path�abspath) r r6 � pysqlite_args�opts� pysqlite_optsrV �type_�filenamerW s @r �create_connect_argsz*SQLiteDialect_pysqlite.create_connect_args� s� �� � �<� �3�<� �3�8� �s�x� ��#�#� ;>�#�#� @�� � � �D�M� �� � �� $� �S� !� �$� '� �#� &� � � �y��� �'� F� F�J�C�� � ��c�5�}� E� E� E� E� E� � � �U�E� *� *� 5��y�y�{�{�H� ,� (� (� ��U�� � �S�$�'�'�'�'��|�H�� ��C��H�H� � � � �#)�(�#3�#3� � � � � � � ��� �|�1�z�H��:�%�%� �7�?�?�8�4�4��� �M�*�*r c �X � t || j j � � odt |� � v S )Nz$Cannot operate on a closed database.)� isinstancer1 �ProgrammingErrorr` )r r0 r> �cursors r � is_disconnectz$SQLiteDialect_pysqlite.is_disconnect s1 � �� �t�z�*� � � ?�4��A���>� ?r )r r r �default_paramstyler � update_copyr �colspecs�sqltypes�Dater! � TIMESTAMPr r* �description_encoding�driver� classmethodr1 r7 r; r? rF rq rv � __classcell__)rI s @r r% r% � s �� � � � � � �� �t� �� � �M�/� � � 9� �� �H� �9� $� #� � �F�� � � �[� � �� � �[�� �,� ,� �[�,� .� .� .� � � � � � 8+� 8+� 8+�t?� ?� ?� ?� ?� ?� ?r r% )�__doc__ri �baser r r rB r r r rz r r r! r% r r r r �<module>r� s= ��b� b�H � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � !� !� !� !� !� !� � � � � � � E� E� E� E� E�� E� E� E� A� A� A� A� A�4� A� A� A� z?� z?� z?� z?� z?�]� z?� z?� z?�z !���r