Add sqlite3.Connection.autocommit for PEP 249 compliant behaviour

Doc/library/asyncio-llapi-index.rst

@@ -358,6 +358,10 @@ pipes, etc).  Returned from methods like
 
     * - :meth:`transport.get_write_buffer_size()
         <WriteTransport.get_write_buffer_size>`
+      - Return the current size of the output buffer.
+
+    * - :meth:`transport.get_write_buffer_limits()
+        <WriteTransport.get_write_buffer_limits>`
       - Return high and low water marks for write flow control.
 
     * - :meth:`transport.set_write_buffer_limits()

Doc/library/dis.rst

@@ -887,7 +887,20 @@ iterations of the loop.
 
 .. opcode:: LOAD_ATTR (namei)
 
-   Replaces TOS with ``getattr(TOS, co_names[namei])``.
+   If the low bit of ``namei`` is not set, this replaces TOS with
+   ``getattr(TOS, co_names[namei>>1])``.
+
+   If the low bit of ``namei`` is set, this will attempt to load a method named
+   ``co_names[namei>>1]`` from the TOS object. TOS is popped.
+   This bytecode distinguishes two cases: if TOS has a method with the correct
+   name, the bytecode pushes the unbound method and TOS. TOS will be used as
+   the first argument (``self``) by :opcode:`CALL` when calling the
+   unbound method. Otherwise, ``NULL`` and the object return by the attribute
+   lookup are pushed.
+
+   .. versionchanged:: 3.12
+      If the low bit of ``namei`` is set, then a ``NULL`` or ``self`` is
+      pushed to the stack before the attribute or unbound method respectively.
 
 
 .. opcode:: COMPARE_OP (opname)
@@ -1189,18 +1202,6 @@ iterations of the loop.
    .. versionadded:: 3.6
 
 
-.. opcode:: LOAD_METHOD (namei)
-
-   Loads a method named ``co_names[namei]`` from the TOS object. TOS is popped.
-   This bytecode distinguishes two cases: if TOS has a method with the correct
-   name, the bytecode pushes the unbound method and TOS. TOS will be used as
-   the first argument (``self``) by :opcode:`CALL` when calling the
-   unbound method. Otherwise, ``NULL`` and the object return by the attribute
-   lookup are pushed.
-
-   .. versionadded:: 3.7
-
-
 .. opcode:: PUSH_NULL
 
     Pushes a ``NULL`` to the stack.

Doc/library/sqlite3.rst

@@ -236,7 +236,7 @@ Module functions and constants
    the preceding space: the column name would simply be "Expiration date".
 
 
-.. function:: connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri])
+.. function:: connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri, autocommit])
 
    Opens a connection to the SQLite database file *database*. By default returns a
    :class:`Connection` object, unless a custom *factory* is given.
@@ -255,6 +255,11 @@ Module functions and constants
    For the *isolation_level* parameter, please see the
    :attr:`~Connection.isolation_level` property of :class:`Connection` objects.
 
+   For the *autocommit* parameter, please see the
+   :attr:`~Connection.autocommit` property. *autocommit* currently defaults to
+   :data:`~Connection.DEPRECATED_TRANSACTION_CONTROL`.
+   The default will change to :const:`False` in a future Python release.
+
    SQLite natively supports only the types TEXT, INTEGER, REAL, BLOB and NULL. If
    you want to use other types you must add support for them yourself. The
    *detect_types* parameter and the using custom **converters** registered with the
@@ -318,6 +323,9 @@ Module functions and constants
    .. versionchanged:: 3.10
       Added the ``sqlite3.connect/handle`` auditing event.
 
+   .. versionchanged:: 3.12
+      Added the *autocommit* parameter.
+
 
 .. function:: register_converter(typename, callable)
 
@@ -385,6 +393,25 @@ Connection Objects
 
    An SQLite database connection has the following attributes and methods:
 
+   .. attribute:: autocommit
+
+      Get or set the :pep:`249` transaction behaviour.
+      *autocommit* has tree allowed values:
+
+      * :const:`False`: PEP 249 compliant transaction behaviour,
+        implying that a transaction is always open.
+        Use :meth:`commit` and :meth:`rollback` to close transactions.
+        Closing a transaction immediately opens a new one.
+        This will be the default value of *autocommit* in a future Python
+        release.
+
+      * :const:`True`: Use SQLite's autocommit behaviour.
+        You are also free to :meth:`execute` custom transaction statements.
+
+      * :data:`DEPRECATED_TRANSACTION_CONTROL`: Pre Python 3.12 compliant
+        transaction control. See :attr:`isolation_level`.
+        This is currently the default value of *autocommit*.
+
    .. attribute:: isolation_level
 
       Get or set the current default isolation level. :const:`None` for autocommit mode or
@@ -1365,41 +1392,83 @@ timestamp converter.
 
 .. _sqlite3-controlling-transactions:
 
-Controlling Transactions
-------------------------
+Controlling Transactions Using the Autocommit Property
+------------------------------------------------------
 
 The underlying ``sqlite3`` library operates in ``autocommit`` mode by default,
 but the Python :mod:`sqlite3` module by default does not.
 
-``autocommit`` mode means that statements that modify the database take effect
+Use the :attr:`~Connection.autocommit` property to select transaction mode.
+This attribute can also be set when :meth:`connecting <~Connection.connect>`.
+
+Currently, *autocommit* defaults to :const:`DEPRECATED_TRANSACTION_CONTROL`,
+which means transaction control is selected using the
+:attr:`~Connection.isolation_level` property.
+See :ref:`sqlite3-deprecated-transaction-control` for more information.
+
+In a future Python release, *autocommit* will default to :const:False,
+which will imply :pep:`249` compliant transaction control. This means:
+
+* A transaction is always open.
+* Commit transactions using :meth:`~Connection.commit`.
+* Roll back transactions using :meth:`~Connection.rollback`.
+* Commit and rollback will open a new transaction immediately after execution.
+* An implicit rollback is performed if the database is closed with pending
+  changes.
+
+Set *autocommit* to :const:`True` to enable SQLite's autocommit mode.
+This mode is equal to setting :attr:`~Connection.isolation_level` to
+:const:`None`.
+
+``autocommit=True`` means that statements that modify the database take effect
 immediately.  A ``BEGIN`` or ``SAVEPOINT`` statement disables ``autocommit``
 mode, and a ``COMMIT``, a ``ROLLBACK``, or a ``RELEASE`` that ends the
 outermost transaction, turns ``autocommit`` mode back on.
 
-The Python :mod:`sqlite3` module by default issues a ``BEGIN`` statement
-implicitly before a Data Modification Language (DML) statement (i.e.
-``INSERT``/``UPDATE``/``DELETE``/``REPLACE``).
 
-You can control which kind of ``BEGIN`` statements :mod:`sqlite3` implicitly
+.. _sqlite3-deprecated-transaction-control:
+
+Controlling Transactions Using the Isolation Level Property
+-----------------------------------------------------------
+
+.. note::
+
+   The recommended way of controlling transactions, is via the
+   :attr:`~Connection.autocommit` parameter.
+
+If :attr:`~Connection.autocommit` is set to
+:data:`DEPRECATED_TRANSACTION_CONTROL`, transaction control is selected using
+the :attr:`~Connection.isolation_level` parameter.
+
+``isolation_level`` defaults to the empty string: ``""``. This implies that
+the Python :mod:`sqlite3` module issues a ``BEGIN`` statement
+implicitly before a Data Modification Language (DML) statement
+(``INSERT``, ``UPDATE``, ``DELETE``, and ``REPLACE``).
+
+You can control the kind of ``BEGIN`` statement ``sqlite3`` implicitly
 executes via the *isolation_level* parameter to the :func:`connect`
-call, or via the :attr:`isolation_level` property of connections.
-If you specify no *isolation_level*, a plain ``BEGIN`` is used, which is
-equivalent to specifying ``DEFERRED``.  Other possible values are ``IMMEDIATE``
-and ``EXCLUSIVE``.
+call, or via the :attr:`isolation_level` property of connection objects.
+By default, ``BEGIN`` is used, which is equivalent to
+``isolation_level="DEFERRED"``.
+Other possible values are ``"IMMEDIATE"`` and ``"EXCLUSIVE"``.
 
-You can disable the :mod:`sqlite3` module's implicit transaction management by
+Disable the :mod:`sqlite3` module's implicit transaction control by
 setting :attr:`isolation_level` to ``None``.  This will leave the underlying
 ``sqlite3`` library operating in ``autocommit`` mode.  You can then completely
-control the transaction state by explicitly issuing ``BEGIN``, ``ROLLBACK``,
+control transactions by explicitly executing ``BEGIN``, ``ROLLBACK``,
 ``SAVEPOINT``, and ``RELEASE`` statements in your code.
 
 Note that :meth:`~Cursor.executescript` disregards
 :attr:`isolation_level`; any transaction control must be added explicitly.
 
 .. versionchanged:: 3.6
-   :mod:`sqlite3` used to implicitly commit an open transaction before DDL
+   ``sqlite3`` used to implicitly commit an open transaction before DDL
    statements.  This is no longer the case.
 
+.. versionchanged: 3.12
+   The recommended way of controlling transactions is now via the
+   :attr:`~Connection.autocommit` parameter.
+
 
 Using :mod:`sqlite3` efficiently
 --------------------------------
@@ -1441,6 +1510,10 @@ committed:
 
 .. literalinclude:: ../includes/sqlite3/ctx_manager.py
 
+.. note::
+
+   The context manager does not implicitly begin a new transaction.
+
 
 .. rubric:: Footnotes
 

Doc/whatsnew/3.12.rst

@@ -98,6 +98,14 @@ os
   (Contributed by Kumar Aditya in :gh:`93312`.)
 
 
+sqlite3
+-------
+
+* Add :attr:`~sqlite3.Connection.autocommit` parameter for :pep:`249` compliant
+  transaction handling.
+  (Contributed by Erlend E. Aasland in :gh:`83638`.)
+
+
 Optimizations
 =============
 
@@ -106,6 +114,15 @@ Optimizations
   (Contributed by Inada Naoki in :gh:`92536`.)
 
 
+CPython bytecode changes
+========================
+
+* Removed the :opcode:`LOAD_METHOD` instruction. It has been merged into
+  :opcode:`LOAD_ATTR`. :opcode:`LOAD_ATTR` will now behave like the old
+  :opcode:`LOAD_METHOD` instruction if the low bit of its oparg is set.
+  (Contributed by Ken Jin in :gh:`93429`.)
+
+
 Deprecated
 ==========
 

Include/cpython/code.h

@@ -89,6 +89,7 @@ typedef uint16_t _Py_CODEUNIT;
     PyObject *co_linetable;       /* bytes object that holds location info */  \
     PyObject *co_weakreflist;     /* to support weakrefs to code objects */    \
     void *_co_code;               /* cached co_code object/attribute */        \
+    int _co_firsttraceable;       /* index of first traceable instruction */   \
     /* Scratch space for extra data relating to the code object.               \
        Type is a void* to keep the format private in codeobject.c to force     \
        people to go through the proper APIs. */                                \

Include/cpython/import.h

@@ -40,3 +40,6 @@ struct _frozen {
    collection of frozen modules: */
 
 PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules;
+
+PyAPI_DATA(PyObject *) _PyImport_GetModuleAttr(PyObject *, PyObject *);
+PyAPI_DATA(PyObject *) _PyImport_GetModuleAttrString(const char *, const char *);

Include/internal/pycore_code.h

@@ -58,18 +58,18 @@ typedef struct {
     _Py_CODEUNIT index;
 } _PyAttrCache;
 
-#define INLINE_CACHE_ENTRIES_LOAD_ATTR CACHE_ENTRIES(_PyAttrCache)
-
-#define INLINE_CACHE_ENTRIES_STORE_ATTR CACHE_ENTRIES(_PyAttrCache)
-
 typedef struct {
     _Py_CODEUNIT counter;
     _Py_CODEUNIT type_version[2];
     _Py_CODEUNIT keys_version[2];
     _Py_CODEUNIT descr[4];
 } _PyLoadMethodCache;
 
-#define INLINE_CACHE_ENTRIES_LOAD_METHOD CACHE_ENTRIES(_PyLoadMethodCache)
+
+// MUST be the max(_PyAttrCache, _PyLoadMethodCache)
+#define INLINE_CACHE_ENTRIES_LOAD_ATTR CACHE_ENTRIES(_PyLoadMethodCache)
+
+#define INLINE_CACHE_ENTRIES_STORE_ATTR CACHE_ENTRIES(_PyAttrCache)
 
 typedef struct {
     _Py_CODEUNIT counter;
@@ -233,8 +233,6 @@ extern int _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr,
 extern int _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr,
                                     PyObject *name);
 extern int _Py_Specialize_LoadGlobal(PyObject *globals, PyObject *builtins, _Py_CODEUNIT *instr, PyObject *name);
-extern int _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr,
-                                     PyObject *name);
 extern int _Py_Specialize_BinarySubscr(PyObject *sub, PyObject *container, _Py_CODEUNIT *instr);
 extern int _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *instr);
 extern int _Py_Specialize_Call(PyObject *callable, _Py_CODEUNIT *instr,

Include/internal/pycore_global_strings.h

@@ -226,7 +226,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(_showwarnmsg)
         STRUCT_FOR_ID(_shutdown)
         STRUCT_FOR_ID(_slotnames)
-        STRUCT_FOR_ID(_strptime_time)
         STRUCT_FOR_ID(_uninitialized_submodules)
         STRUCT_FOR_ID(_warn_unawaited_coroutine)
         STRUCT_FOR_ID(_xoptions)
@@ -252,7 +251,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(difference_update)
         STRUCT_FOR_ID(dispatch_table)
         STRUCT_FOR_ID(displayhook)
-        STRUCT_FOR_ID(enable)
         STRUCT_FOR_ID(encode)
         STRUCT_FOR_ID(encoding)
         STRUCT_FOR_ID(end_lineno)
@@ -311,7 +309,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(opcode)
         STRUCT_FOR_ID(open)
         STRUCT_FOR_ID(parent)
-        STRUCT_FOR_ID(partial)
         STRUCT_FOR_ID(path)
         STRUCT_FOR_ID(peek)
         STRUCT_FOR_ID(persistent_id)
@@ -357,7 +354,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(warnoptions)
         STRUCT_FOR_ID(writable)
         STRUCT_FOR_ID(write)
-        STRUCT_FOR_ID(zipimporter)
     } identifiers;
     struct {
         PyASCIIObject _ascii;