Implement Sqlite3 Module (RustPython#4260)

* add supporting for PyAtomic<PyObject>

* create sqlite module

* add dependency sqlite3-sys

* add module constants

* import sqlite3 from cpython

* adjust lib

* add module structure

* impl Connection.cursor

* add module exceptions

* impl lstrip_sql

* impl statement new

* wip cursor.execute

* wip cursor

* wip error to exception

* add SqliteRaw and SqliteStatementRaw

* impl statement parameters binding

* wip cursor.execute

* add test_sqlite

* impl closeable connection

* impl closeable cursor

* impl cursor.executemany

* impl cursor.executescript

* impl cursor.fetch*

* impl connection.backup

* stage 1

* add support connection.backup with progress

* fix backup deadlock

* support changable isolation_level

* impl converter

* impl adapter

* impl text_factory and blob

* impl create_function

* impl create_function 2

* fix empty statement

* impl blob support

* impl create_aggregate

* impl create_aggregate 2

* refactor create_*

* impl enable_callback_traceback

* impl create_collation

* refactor create_* with CallbackData

* fix text and blob use SQLITE_TRANSIENT

* fix str to SQLITE_TEXT

* impl thread check

* impl Connection Factory

* impl busy timeout

* shift sqlite3-sys -> libsqlite3-sys

* refactor CallbackData

* impl create_window_function

* refactor callback functions

* add module attr converters

* fix nullable isolation_level

* add module attr adapters

* fix nullable adapt proto

* impl set_authorizer

* impl trace_callback

* impl set_progress_handler

* impl cancellable sqlite function*

* impl attributes for Connection

* fix some failed tests

* impl Row

* impl Blob methods

* impl Blob subscript & ass_subscript

* pass tests

* rebase

* no sqlite for wasm

* use ThreadId instead u64

* no libsqlite3-sys for wasm

* fix into_cstring for all platform

* fixup

* rebase

* fix windows into_bytes

* disable sqlite for android

* fixup

Author: qingshi163

Cargo.lock

@@ -0,0 +1,70 @@
+# pysqlite2/__init__.py: the pysqlite2 package.
+#
+# Copyright (C) 2005 Gerhard Häring <gh@ghaering.de>
+#
+# This file is part of pysqlite.
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+"""
+The sqlite3 extension module provides a DB-API 2.0 (PEP 249) compliant
+interface to the SQLite library, and requires SQLite 3.7.15 or newer.
+
+To use the module, start by creating a database Connection object:
+
+    import sqlite3
+    cx = sqlite3.connect("test.db")  # test.db will be created or opened
+
+The special path name ":memory:" can be provided to connect to a transient
+in-memory database:
+
+    cx = sqlite3.connect(":memory:")  # connect to a database in RAM
+
+Once a connection has been established, create a Cursor object and call
+its execute() method to perform SQL queries:
+
+    cu = cx.cursor()
+
+    # create a table
+    cu.execute("create table lang(name, first_appeared)")
+
+    # insert values into a table
+    cu.execute("insert into lang values (?, ?)", ("C", 1972))
+
+    # execute a query and iterate over the result
+    for row in cu.execute("select * from lang"):
+        print(row)
+
+    cx.close()
+
+The sqlite3 module is written by Gerhard Häring <gh@ghaering.de>.
+"""
+
+from sqlite3.dbapi2 import *
+from sqlite3.dbapi2 import (_deprecated_names,
+                            _deprecated_version_info,
+                            _deprecated_version)
+
+
+def __getattr__(name):
+    if name in _deprecated_names:
+        from warnings import warn
+
+        warn(f"{name} is deprecated and will be removed in Python 3.14",
+             DeprecationWarning, stacklevel=2)
+        return globals()[f"_deprecated_{name}"]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

Lib/sqlite3/__init__.py

@@ -0,0 +1,132 @@
+"""A simple SQLite CLI for the sqlite3 module.
+
+Apart from using 'argparse' for the command-line interface,
+this module implements the REPL as a thin wrapper around
+the InteractiveConsole class from the 'code' stdlib module.
+"""
+import sqlite3
+import sys
+
+from argparse import ArgumentParser
+from code import InteractiveConsole
+from textwrap import dedent
+
+
+def execute(c, sql, suppress_errors=True):
+    """Helper that wraps execution of SQL code.
+
+    This is used both by the REPL and by direct execution from the CLI.
+
+    'c' may be a cursor or a connection.
+    'sql' is the SQL string to execute.
+    """
+
+    try:
+        for row in c.execute(sql):
+            print(row)
+    except sqlite3.Error as e:
+        tp = type(e).__name__
+        try:
+            print(f"{tp} ({e.sqlite_errorname}): {e}", file=sys.stderr)
+        except AttributeError:
+            print(f"{tp}: {e}", file=sys.stderr)
+        if not suppress_errors:
+            sys.exit(1)
+
+
+class SqliteInteractiveConsole(InteractiveConsole):
+    """A simple SQLite REPL."""
+
+    def __init__(self, connection):
+        super().__init__()
+        self._con = connection
+        self._cur = connection.cursor()
+
+    def runsource(self, source, filename="<input>", symbol="single"):
+        """Override runsource, the core of the InteractiveConsole REPL.
+
+        Return True if more input is needed; buffering is done automatically.
+        Return False is input is a complete statement ready for execution.
+        """
+        if source == ".version":
+            print(f"{sqlite3.sqlite_version}")
+        elif source == ".help":
+            print("Enter SQL code and press enter.")
+        elif source == ".quit":
+            sys.exit(0)
+        elif not sqlite3.complete_statement(source):
+            return True
+        else:
+            execute(self._cur, source)
+            return False
+        # TODO: RUSTPYTHON match statement supporting
+        # match source:
+        #     case ".version":
+        #         print(f"{sqlite3.sqlite_version}")
+        #     case ".help":
+        #         print("Enter SQL code and press enter.")
+        #     case ".quit":
+        #         sys.exit(0)
+        #     case _:
+            # if not sqlite3.complete_statement(source):
+            #     return True
+            # execute(self._cur, source)
+        # return False
+
+
+def main():
+    parser = ArgumentParser(
+        description="Python sqlite3 CLI",
+        prog="python -m sqlite3",
+    )
+    parser.add_argument(
+        "filename", type=str, default=":memory:", nargs="?",
+        help=(
+            "SQLite database to open (defaults to ':memory:'). "
+            "A new database is created if the file does not previously exist."
+        ),
+    )
+    parser.add_argument(
+        "sql", type=str, nargs="?",
+        help=(
+            "An SQL query to execute. "
+            "Any returned rows are printed to stdout."
+        ),
+    )
+    parser.add_argument(
+        "-v", "--version", action="version",
+        version=f"SQLite version {sqlite3.sqlite_version}",
+        help="Print underlying SQLite library version",
+    )
+    args = parser.parse_args()
+
+    if args.filename == ":memory:":
+        db_name = "a transient in-memory database"
+    else:
+        db_name = repr(args.filename)
+
+    # Prepare REPL banner and prompts.
+    banner = dedent(f"""
+        sqlite3 shell, running on SQLite version {sqlite3.sqlite_version}
+        Connected to {db_name}
+
+        Each command will be run using execute() on the cursor.
+        Type ".help" for more information; type ".quit" or CTRL-D to quit.
+    """).strip()
+    sys.ps1 = "sqlite> "
+    sys.ps2 = "    ... "
+
+    con = sqlite3.connect(args.filename, isolation_level=None)
+    try:
+        if args.sql:
+            # SQL statement provided on the command-line; execute it directly.
+            execute(con, args.sql, suppress_errors=False)
+        else:
+            # No SQL provided; start the REPL.
+            console = SqliteInteractiveConsole(con)
+            console.interact(banner, exitmsg="")
+    finally:
+        con.close()
+
+
+main()

Lib/sqlite3/__main__.py

@@ -0,0 +1,108 @@
+# pysqlite2/dbapi2.py: the DB-API 2.0 interface
+#
+# Copyright (C) 2004-2005 Gerhard Häring <gh@ghaering.de>
+#
+# This file is part of pysqlite.
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+import datetime
+import time
+import collections.abc
+
+from _sqlite3 import *
+from _sqlite3 import _deprecated_version
+
+_deprecated_names = frozenset({"version", "version_info"})
+
+paramstyle = "qmark"
+
+apilevel = "2.0"
+
+Date = datetime.date
+
+Time = datetime.time
+
+Timestamp = datetime.datetime
+
+def DateFromTicks(ticks):
+    return Date(*time.localtime(ticks)[:3])
+
+def TimeFromTicks(ticks):
+    return Time(*time.localtime(ticks)[3:6])
+
+def TimestampFromTicks(ticks):
+    return Timestamp(*time.localtime(ticks)[:6])
+
+_deprecated_version_info = tuple(map(int, _deprecated_version.split(".")))
+sqlite_version_info = tuple([int(x) for x in sqlite_version.split(".")])
+
+Binary = memoryview
+collections.abc.Sequence.register(Row)
+
+def register_adapters_and_converters():
+    from warnings import warn
+
+    msg = ("The default {what} is deprecated as of Python 3.12; "
+           "see the sqlite3 documentation for suggested replacement recipes")
+
+    def adapt_date(val):
+        warn(msg.format(what="date adapter"), DeprecationWarning, stacklevel=2)
+        return val.isoformat()
+
+    def adapt_datetime(val):
+        warn(msg.format(what="datetime adapter"), DeprecationWarning, stacklevel=2)
+        return val.isoformat(" ")
+
+    def convert_date(val):
+        warn(msg.format(what="date converter"), DeprecationWarning, stacklevel=2)
+        return datetime.date(*map(int, val.split(b"-")))
+
+    def convert_timestamp(val):
+        warn(msg.format(what="timestamp converter"), DeprecationWarning, stacklevel=2)
+        datepart, timepart = val.split(b" ")
+        year, month, day = map(int, datepart.split(b"-"))
+        timepart_full = timepart.split(b".")
+        hours, minutes, seconds = map(int, timepart_full[0].split(b":"))
+        if len(timepart_full) == 2:
+            microseconds = int('{:0<6.6}'.format(timepart_full[1].decode()))
+        else:
+            microseconds = 0
+
+        val = datetime.datetime(year, month, day, hours, minutes, seconds, microseconds)
+        return val
+
+
+    register_adapter(datetime.date, adapt_date)
+    register_adapter(datetime.datetime, adapt_datetime)
+    register_converter("date", convert_date)
+    register_converter("timestamp", convert_timestamp)
+
+register_adapters_and_converters()
+
+# Clean up namespace
+
+del(register_adapters_and_converters)
+
+def __getattr__(name):
+    if name in _deprecated_names:
+        from warnings import warn
+
+        warn(f"{name} is deprecated and will be removed in Python 3.14",
+             DeprecationWarning, stacklevel=2)
+        return globals()[f"_deprecated_{name}"]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")