Проверка 09.02.2025

venv/Lib/site-packages/sqlalchemy/dialects/sqlite/pysqlite.py

@@ -1,5 +1,5 @@
 # dialects/sqlite/pysqlite.py
-# Copyright (C) 2005-2024 the SQLAlchemy authors and contributors
+# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
 # <see AUTHORS file>
 #
 # This module is part of SQLAlchemy and is released under
@@ -28,7 +28,9 @@ 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::
+portion of the URL.  Note that the format of a SQLAlchemy url is:
+
+.. sourcecode:: text
 
     driver://user:pass@host/database
 
@@ -37,25 +39,28 @@ the **right** of the third slash.   So connecting to a relative filepath
 looks like::
 
     # relative path
-    e = create_engine('sqlite:///path/to/database.db')
+    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')
+    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')
+    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::
+To use sqlite ``:memory:`` database specify it as the filename using
+``sqlite:///:memory:``. It's also the default if no filepath is
+present, specifying only ``sqlite://`` and nothing else::
 
-    # in-memory database
-    e = create_engine('sqlite://')
+    # in-memory database (note three slashes)
+    e = create_engine("sqlite:///:memory:")
+    # also in-memory database
+    e2 = create_engine("sqlite://")
 
 .. _pysqlite_uri_connections:
 
@@ -95,7 +100,9 @@ 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
+        check_same_thread=True,
+        timeout=10,
+        uri=True,
     )
 
 Regarding future parameters added to either the Python or native drivers. new
@@ -141,8 +148,11 @@ as follows::
     def regexp(a, b):
         return re.search(a, b) is not None
 
+
     sqlite_connection.create_function(
-        "regexp", 2, regexp,
+        "regexp",
+        2,
+        regexp,
     )
 
 There is currently no support for regular expression flags as a separate
@@ -183,10 +193,12 @@ 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
+    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
@@ -241,6 +253,7 @@ Pooling may be disabled for a file based database by specifying the
 parameter::
 
     from sqlalchemy import NullPool
+
     engine = create_engine("sqlite:///myfile.db", poolclass=NullPool)
 
 It's been observed that the :class:`.NullPool` implementation incurs an
@@ -260,9 +273,12 @@ 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)
+
+    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.
@@ -281,14 +297,14 @@ 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)
+
+    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)
+
+    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
@@ -317,13 +333,14 @@ same column, use a custom type that will check each row individually::
     from sqlalchemy import String
     from sqlalchemy import TypeDecorator
 
+
     class MixedBinary(TypeDecorator):
         impl = String
         cache_ok = True
 
         def process_result_value(self, value, dialect):
             if isinstance(value, str):
-                value = bytes(value, 'utf-8')
+                value = bytes(value, "utf-8")
             elif value is not None:
                 value = bytes(value)
 
@@ -364,12 +381,14 @@ ourselves. This is achieved using two event listeners::
 
     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
@@ -439,7 +458,6 @@ connection when it is created. That is accomplished with an event listener::
         with engine.connect() as conn:
             print(conn.scalar(text("SELECT UDF()")))
 
-
 """  # noqa
 
 import math