python · erlend-aasland · Feb 14, 2024 · Jan 22, 2024 · Jan 23, 2024 · Jan 23, 2024
@@ -8,8 +8,13 @@
 
 --------------
 
-:mod:`dbm` is a generic interface to variants of the DBM database ---
-:mod:`dbm.gnu` or :mod:`dbm.ndbm`.  If none of these modules is installed, the
+:mod:`dbm` is a generic interface to variants of the DBM database:
+
+* :mod:`dbm.sqlite3`
+* :mod:`dbm.gnu`
+* :mod:`dbm.ndbm`
+
+If none of these modules are installed, the
 slow-but-simple implementation in module :mod:`dbm.dumb` will be used.  There
 is a `third party interface <https://www.jcea.es/programacion/pybsddb.htm>`_ to
 the Oracle Berkeley DB.
@@ -129,6 +134,69 @@ then prints out the contents of the database::
 
 The individual submodules are described in the following sections.
 
+.. Substitutions for the flag docs; all submodules use the same text.
+
+.. |flag_r| replace::
+   Open existing database for reading only (default)
+
+.. |flag_w| replace::
+   Open existing database for reading and writing
+
+.. |flag_c| replace::
+   Open database for reading and writing, creating it if it doesn't exist.
+
+.. |flag_n| replace::
+   Always create a new, empty database, open for reading and writing.
+
+:mod:`dbm.sqlite3` --- SQLite backend for dbm
+----------------------------------------------
+
+.. module:: dbm.sqlite3
+   :platform: All
+   :synopsis: SQLite backend for dbm
+
+.. versionadded:: 3.13
+
+**Source code:** :source:`Lib/dbm/sqlite3.py`
+
+--------------
+
+This module uses the standard library :mod:`sqlite3` to provide an
+SQLite backend for the :mod:`dbm` module.
+The files created by :mod:`dbm.sqlite3` can thus be opened by :mod:`sqlite3`,
+or any other SQLite browser, including the SQLite CLI.
+
+.. function:: open(filename, flag="r", mode=None)
+
+   Open an SQLite database.
+   The returned object, behaves like a :term:`mapping`,
+   but also implements a :meth:`!close` method
+   and supports a "closing" context manager via the :keyword:`with` keyword.
+
+   Neither keys nor values are coerced to a specific type
+   before being stored in the database.
+
+   :param filename:
+      The path to the database to be opened.
+   :type filename: :term:`path-like object`
+
+   :param str flag:
+
+      .. list-table::
+         :header-rows: 1
+
+         * - ``'r'``
+           - |flag_r|
+         * - ``'w'``
+           - |flag_w|
+         * - ``'c'``
+           - |flag_c|
+         * - ``'n'``
+           - |flag_n|
+
+   :param mode:
+      This parameter is ignored by the :mod:`!dbm.sqlite3` module.
+
 
 :mod:`dbm.gnu` --- GNU's reinterpretation of dbm
 ------------------------------------------------

diff --git a/Doc/whatsnew/3.13.rst b/Doc/whatsnew/3.13.rst
@@ -196,6 +196,9 @@ dbm
   from the database.
   (Contributed by Donghee Na in :gh:`107122`.)
 
+* Add new :mod:`dbm.sqlite3` backend.
+  (Contributed by Raymond Hettinger and Erlend E. Aasland in :gh:`100414`.)
+
 doctest
 -------
 

@@ -49,6 +49,13 @@ class error(Exception):
 except ImportError:
     ndbm = None
 
+try:
+    import sqlite3
+    _names.insert(0, 'dbm.sqlite3')
+    _has_sqlite3 = True
+except ImportError:
+    _has_sqlite3 = False
+
 
 def open(file, flag='r', mode=0o666):
     """Open or create database at path given by *file*.
@@ -164,6 +171,10 @@ def whichdb(filename):
     if len(s) != 4:
         return ""
 
+    # Check for SQLite3 header string.
+    if s16 == b"SQLite format 3\0":
+        return "dbm.sqlite3" if _has_sqlite3 else ""
+
     # Convert to 4-byte int in native byte order -- return "" if impossible
     try:
         (magic,) = struct.unpack("=l", s)

@@ -0,0 +1,104 @@
+import os
+import sqlite3
+from contextlib import suppress, closing
+from collections.abc import MutableMapping
+
+BUILD_TABLE = """
+  CREATE TABLE Dict (
+    key TEXT NOT NULL,
+    value BLOB NOT NULL,
+    PRIMARY KEY (key)
+  )
+"""
+GET_SIZE = "SELECT COUNT (key) FROM Dict"
+LOOKUP_KEY = "SELECT value FROM Dict WHERE key = ? LIMIT 1"
+STORE_KV = "REPLACE INTO Dict (key, value) VALUES (?, ?)"
+DELETE_KEY = "DELETE FROM Dict WHERE key = ?"
+ITER_KEYS = "SELECT key FROM Dict"
+
+
+def _normalize_uri_path(path):
+    path = path.replace("?", "%3f")
+    path = path.replace("#", "%23")
+    while "//" in path:
+        path = path.replace("//", "/")
+    return path
+
+
+class _Database(MutableMapping):
+
+    def __init__(self, path, flag):
+        match flag:
+            case "r":
+                flag = "ro"
+            case "w":
+                flag = "rw"
+            case "c":
+                flag = "rwc"
+            case "n":
+                flag = "rwc"
+                try:
+                    os.remove(path)
+                except FileNotFoundError:
+                    pass
+            case _:
+                raise ValueError("Flag must be one of 'r', 'w', 'c', or 'n', not",
+                                 repr(flag))
+
+        # We use the URI format when opening the database.
+        path = os.fsdecode(path)
+        if not path or path == ":memory:":
+            uri = "file:?mode=memory"
+        else:
+            path = _normalize_uri_path(path)
+            uri = f"file:{path}?mode={flag}"
+
+        self.cx = sqlite3.connect(uri, autocommit=True, uri=True)
+        self.cx.execute("PRAGMA journal_mode = wal")
+        with suppress(sqlite3.OperationalError):
+            self.cx.execute(BUILD_TABLE)
+
+    def __len__(self):
+        return self.cx.execute(GET_SIZE).fetchone()[0]
+
+    def __getitem__(self, key):
+        rows = [row for row in self.cx.execute(LOOKUP_KEY, (key,))]
+        if not rows:
+            raise KeyError(key)
+        assert len(rows) == 1
+        row = rows[0]
+        return row[0]
+
+    def __setitem__(self, key, value):
+        self.cx.execute(STORE_KV, (key, value));
+
+    def __delitem__(self, key):
+        if key not in self:
+            raise KeyError(key)
+        self.cx.execute(DELETE_KEY, (key,));
+
+    def __iter__(self):
+        with closing(self.cx.execute(ITER_KEYS)) as cu:
+            for row in cu:
+                yield row[0]
+
+    def close(self):
+        self.cx.close()
+        self.cx = None
+
+    def keys(self):
+        return list(super().keys())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class error(OSError, sqlite3.Error):
+    pass
+
+
+def open(path, flag="r", mode=None):
+    return _Database(path, flag)
diff --git a/Misc/NEWS.d/next/Library/2024-01-23-13-03-22.gh-issue-100414.5kTdU5.rst b/Misc/NEWS.d/next/Library/2024-01-23-13-03-22.gh-issue-100414.5kTdU5.rst
@@ -0,0 +1,2 @@
+Add :mod:`dbm.sqlite3` as a backend to :mod:`dbm`.
+Patch by Raymond Hettinger and Erlend E. Aasland.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Add :mod:`dbm.sqlite3` as a backend to :mod:`dbm`.
		Patch by Raymond Hettinger and Erlend E. Aasland.