Jun 6, 2025 · May 4, 2025 · May 4, 2025 · May 4, 2025 · May 4, 2025 · May 4, 2025
diff --git a/Lib/sqlite3/__main__.py b/Lib/sqlite3/__main__.py
 from textwrap import dedent
 from _colorize import get_theme, theme_no_color

 from ._completer importenable_completer
 from ._completer importcompleter


 def execute(c, sql, suppress_errors=True, theme=theme_no_color):
            execute(con, args.sql, suppress_errors=False, theme=theme)
        else:
            # No SQL provided; start the REPL.
            withenable_completer():
            withcompleter():
                console = SqliteInteractiveConsole(con, use_color=True)
                console.interact(banner, exitmsg="")
    finally:
diff --git a/Lib/sqlite3/_completer.py b/Lib/sqlite3/_completer.py
 from contextlib import contextmanager

 try:
    from _sqlite3 import SQLITE_KEYWORDS
 except ImportError:
    SQLITE_KEYWORDS = ()

 _completion_matches = []


 def _complete(text, state):
    try:
        from _sqlite3 import SQLITE_KEYWORDS
    except ImportError:
        SQLITE_KEYWORDS = ()
    global _completion_matches

    if state == 0:
        text_upper = text.upper()
        _completion_matches = [c for c in SQLITE_KEYWORDS if c.startswith(text_upper)]


 @contextmanager
 defenable_completer():
 defcompleter():
    try:
        import readline
    except ImportError:
diff --git a/Lib/test/test_sqlite3/test_cli.py b/Lib/test/test_sqlite3/test_cli.py
 import textwrap
 import unittest

 from _sqlite3 import SQLITE_KEYWORDS
 from sqlite3.__main__ import main as cli
 from test.support.import_helper import import_module
 from test.support.os_helper import TESTFN, unlink

 @requires_subprocess()
 @force_not_colorized_test_class
 classCompletionTest(unittest.TestCase):
 classCompletion(unittest.TestCase):
    PS1 = "sqlite> "

    @classmethod
    def setUpClass(cls):
        _sqlite3 = import_module("_sqlite3")
        if not hasattr(_sqlite3, "SQLITE_KEYWORDS"):
            raise unittest.SkipTest("unable to determine SQLite keywords")

        readline = import_module("readline")
        if readline.backend == "editline":
            raise unittest.SkipTest("libedit readline is not supported")

    def write_input(self,input, env=None):
    def write_input(self,input_, env=None):
        script = textwrap.dedent("""
            import readline
            from sqlite3.__main__ import main

            readline.parse_and_bind("set colored-completion-prefix off")
 from sqlite3.__main__ import main;main()
            main()
        """)
        return run_pty(script,input, env)
        return run_pty(script,input_, env)

    deftest_keyword_completion(self):
    deftest_complete_sql_keywords(self):
        # List candidates starting with 'S', there should be multiple matches.
 input = b"S\t\tEL\t 1;\n.quit\n"
        output = self.write_input(input)
 input_ = b"S\t\tEL\t 1;\n.quit\n"
        output = self.write_input(input_)
        self.assertIn(b"SELECT", output)
        self.assertIn(b"SET", output)
        self.assertIn(b"SAVEPOINT", output)
        self.assertIn(b"(1,)", output)

        # Keywords are completed in upper case for even lower case user input
 input = b"sel\t\t 1;\n.quit\n"
        output = self.write_input(input)
        # Keywords are completed in upper case for even lower case user input.
 input_ = b"sel\t\t 1;\n.quit\n"
        output = self.write_input(input_)
        self.assertIn(b"SELECT", output)
        self.assertIn(b"(1,)", output)

    @unittest.skipIf(sys.platform.startswith("freebsd"),
                    "Two actual tabs are inserted when there are no matching"
                    " completions in the pseudo-terminal opened by run_pty()"
                    " on FreeBSD")
    def test_nothing_to_complete(self):
        input = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
        # set NO_COLOR to disable coloring for self.PS1
        output = self.write_input(input, env={"NO_COLOR": "1"})
        output_lines = output.decode().splitlines()
        line_num = next((i for i, line in enumerate(output_lines, 1)
                         if line.startswith(f"{self.PS1}xyzzy")), -1)
    def test_complete_no_match(self):
        input_ = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
        # Set NO_COLOR to disable coloring for self.PS1.
        output = self.write_input(input_, env={"NO_COLOR": "1"})
        lines = output.decode().splitlines()
        indices = (
            i for i, line in enumerate(lines, 1)
            if line.startswith(f"{self.PS1}xyzzy")
        )
        line_num = next(indices, -1)
        self.assertNotEqual(line_num, -1)
        # completions occupy lines, assert no extra lines when there is nothing
        # to complete
        self.assertEqual(line_num, len(output_lines))
        # Completions occupy lines, assert no extra lines when there is nothing
        # to complete.
        self.assertEqual(line_num, len(lines))

    def test_complete_no_input(self):
        from _sqlite3 import SQLITE_KEYWORDS

    def test_completion_for_nothing(self):
        script = textwrap.dedent("""
            import readline
            from sqlite3.__main__ import main

            # Configure readline to ...:
            # - hide control sequences surrounding each candidate
            # - hide "Display all xxx possibilities? (y or n)"
            # - hide "--More--"
            # - show candidates one per line
            readline.parse_and_bind("set colored-completion-prefix off")
            # hide control sequences surrounding each candidate
            readline.parse_and_bind("set colored-stats off")
            # hide "Display all xxx possibilities? (y or n)"
            readline.parse_and_bind("set completion-query-items 0")
            # hide "--More--"
            readline.parse_and_bind("set page-completions off")
            # show candidates one per line
            readline.parse_and_bind("set completion-display-width 0")
            from sqlite3.__main__ import main; main()

            main()
        """)
        input = b"\t\t.quit\n"
        output = run_pty(script, input, env={"NO_COLOR": "1"})
        output_lines = output.decode().splitlines()
        indices = [i for i, line in enumerate(output_lines)
                   if line.startswith(self.PS1)]
        input_ = b"\t\t.quit\n"
        output = run_pty(script, input_, env={"NO_COLOR": "1"})
        lines = output.decode().splitlines()
        indices = [
            i for i, line in enumerate(lines)
            if line.startswith(self.PS1)
        ]
        self.assertEqual(len(indices), 2)
        start, end = indices[0] + 1, indices[1]
        candidates =list(map(str.strip, output_lines[start:end]))
        start, end = indices
        candidates =[l.strip() for l in lines[start+1:end]]
        self.assertEqual(candidates, sorted(SQLITE_KEYWORDS))


diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
    return NULL;
 }

 #if SQLITE_VERSION_NUMBER < 3024000
 static int
 add_keyword_tuple(PyObject *module)
 {
 #if SQLITE_VERSION_NUMBER >= 3024000
    int count = sqlite3_keyword_count();
    PyObject *keywords = PyTuple_New(count);
    if (keywords == NULL) {
 goto error;
 return -1;
    }
    for (int i = 0; i < count; i++) {
        const char *keyword;
        if (!kwd) {
            goto error;
        }
        if (PyTuple_SetItem(keywords, i, kwd) < 0) {
            goto error;
        }
        PyTuple_SET_ITEM(keywords, i, kwd);
    }
    return PyModule_Add(module, "SQLITE_KEYWORDS", keywords);

 error:
 Py_XDECREF(keywords);
 Py_DECREF(keywords);
    return -1;
 }
 #else
    return 0;
 #endif
 }

 static int
 add_integer_constants(PyObject *module) {
        goto error;
    }

 #if SQLITE_VERSION_NUMBER < 3024000
    if (add_keyword_tuple(module) < 0) {
        goto error;
    }
 #endif

    if (PyModule_AddStringConstant(module, "sqlite_version", sqlite3_libversion())) {
        goto error;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -12,7 +12,7 @@
		from textwrap import dedent
		from _colorize import get_theme, theme_no_color

		from ._completer importenable_completer
		from ._completer importcompleter


		def execute(c, sql, suppress_errors=True, theme=theme_no_color):
Expand DownExpand Up		@@ -138,7 +138,7 @@ def main(*args):
		execute(con, args.sql, suppress_errors=False, theme=theme)
		else:
		# No SQL provided; start the REPL.
		withenable_completer():
		withcompleter():
		console = SqliteInteractiveConsole(con, use_color=True)
		console.interact(banner, exitmsg="")
		finally:
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,16 @@
		from contextlib import contextmanager

		try:
		from _sqlite3 import SQLITE_KEYWORDS
		except ImportError:
		SQLITE_KEYWORDS = ()

		_completion_matches = []


		def _complete(text, state):
		try:
		from _sqlite3 import SQLITE_KEYWORDS
		except ImportError:
		SQLITE_KEYWORDS = ()
		global _completion_matches

		if state == 0:
		text_upper = text.upper()
		_completion_matches = [c for c in SQLITE_KEYWORDS if c.startswith(text_upper)]
Expand All		@@ -19,7 +21,7 @@ def _complete(text, state):


		@contextmanager
		defenable_completer():
		defcompleter():
		try:
		import readline
		except ImportError:
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,7 +4,6 @@
		import textwrap
		import unittest

		from _sqlite3 import SQLITE_KEYWORDS
		from sqlite3.__main__ import main as cli
		from test.support.import_helper import import_module
		from test.support.os_helper import TESTFN, unlink
Expand DownExpand Up		@@ -209,76 +208,93 @@ def test_color(self):

		@requires_subprocess()
picnixz marked this conversation as resolved. Show resolvedHide resolved
		@force_not_colorized_test_class
		classCompletionTest(unittest.TestCase):
		classCompletion(unittest.TestCase):
		PS1 = "sqlite> "
Copy link Member StanFromIrelandMay 16, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. This is no longer freely customizable by users via sys.ps1 ? Copy link Contributor erlend-aaslandJun 6, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Can you explain your remark. Do you want changes?

		@classmethod
		def setUpClass(cls):
		_sqlite3 = import_module("_sqlite3")
		if not hasattr(_sqlite3, "SQLITE_KEYWORDS"):
		raise unittest.SkipTest("unable to determine SQLite keywords")

		readline = import_module("readline")
		if readline.backend == "editline":
		raise unittest.SkipTest("libedit readline is not supported")
picnixz marked this conversation as resolved. Show resolvedHide resolved

		def write_input(self,input, env=None):
		def write_input(self,input_, env=None):
		script = textwrap.dedent("""
		import readline
		from sqlite3.__main__ import main

		readline.parse_and_bind("set colored-completion-prefix off")
		from sqlite3.__main__ import main;main()
		main()
		""")
		return run_pty(script,input, env)
		return run_pty(script,input_, env)

		deftest_keyword_completion(self):
		deftest_complete_sql_keywords(self):
		# List candidates starting with 'S', there should be multiple matches.
		input = b"S\t\tEL\t 1;\n.quit\n"
		output = self.write_input(input)
		input_ = b"S\t\tEL\t 1;\n.quit\n"
		output = self.write_input(input_)
		self.assertIn(b"SELECT", output)
		self.assertIn(b"SET", output)
		self.assertIn(b"SAVEPOINT", output)
		self.assertIn(b"(1,)", output)

		# Keywords are completed in upper case for even lower case user input
		input = b"sel\t\t 1;\n.quit\n"
		output = self.write_input(input)
		# Keywords are completed in upper case for even lower case user input.
		input_ = b"sel\t\t 1;\n.quit\n"
		output = self.write_input(input_)
		self.assertIn(b"SELECT", output)
		self.assertIn(b"(1,)", output)

		@unittest.skipIf(sys.platform.startswith("freebsd"),
		"Two actual tabs are inserted when there are no matching"
		" completions in the pseudo-terminal opened by run_pty()"
		" on FreeBSD")
		def test_nothing_to_complete(self):
		input = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
		# set NO_COLOR to disable coloring for self.PS1
		output = self.write_input(input, env={"NO_COLOR": "1"})
		output_lines = output.decode().splitlines()
		line_num = next((i for i, line in enumerate(output_lines, 1)
		if line.startswith(f"{self.PS1}xyzzy")), -1)
		def test_complete_no_match(self):
		input_ = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
		# Set NO_COLOR to disable coloring for self.PS1.
		output = self.write_input(input_, env={"NO_COLOR": "1"})
		lines = output.decode().splitlines()
		indices = (
		i for i, line in enumerate(lines, 1)
		if line.startswith(f"{self.PS1}xyzzy")
		)
		line_num = next(indices, -1)
		self.assertNotEqual(line_num, -1)
		# completions occupy lines, assert no extra lines when there is nothing
		# to complete
		self.assertEqual(line_num, len(output_lines))
		# Completions occupy lines, assert no extra lines when there is nothing
		# to complete.
		self.assertEqual(line_num, len(lines))

		def test_complete_no_input(self):
		from _sqlite3 import SQLITE_KEYWORDS

		def test_completion_for_nothing(self):
		script = textwrap.dedent("""
		import readline
		from sqlite3.__main__ import main

		# Configure readline to ...:
		# - hide control sequences surrounding each candidate
		# - hide "Display all xxx possibilities? (y or n)"
		# - hide "--More--"
		# - show candidates one per line
		readline.parse_and_bind("set colored-completion-prefix off")
		# hide control sequences surrounding each candidate
		readline.parse_and_bind("set colored-stats off")
		# hide "Display all xxx possibilities? (y or n)"
		readline.parse_and_bind("set completion-query-items 0")
		# hide "--More--"
		readline.parse_and_bind("set page-completions off")
		# show candidates one per line
		readline.parse_and_bind("set completion-display-width 0")
		from sqlite3.__main__ import main; main()

		main()
		""")
		input = b"\t\t.quit\n"
		output = run_pty(script, input, env={"NO_COLOR": "1"})
		output_lines = output.decode().splitlines()
		indices = [i for i, line in enumerate(output_lines)
		if line.startswith(self.PS1)]
		input_ = b"\t\t.quit\n"
		output = run_pty(script, input_, env={"NO_COLOR": "1"})
		lines = output.decode().splitlines()
		indices = [
		i for i, line in enumerate(lines)
		if line.startswith(self.PS1)
		]
		self.assertEqual(len(indices), 2)
		start, end = indices[0] + 1, indices[1]
		candidates =list(map(str.strip, output_lines[start:end]))
		start, end = indices
		candidates =[l.strip() for l in lines[start+1:end]]
		self.assertEqual(candidates, sorted(SQLITE_KEYWORDS))


Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -405,14 +405,14 @@ pysqlite_error_name(int rc)
		return NULL;
		}

		#if SQLITE_VERSION_NUMBER < 3024000
		static int
		add_keyword_tuple(PyObject *module)
		{
		#if SQLITE_VERSION_NUMBER >= 3024000
		int count = sqlite3_keyword_count();
erlend-aasland marked this conversation as resolved. Show resolvedHide resolved
		PyObject *keywords = PyTuple_New(count);
		if (keywords == NULL) {
		goto error;
		return -1;
		}
		for (int i = 0; i < count; i++) {
		const char *keyword;
Expand All		@@ -427,17 +427,17 @@ add_keyword_tuple(PyObject *module)
		if (!kwd) {
		goto error;
		}
		if (PyTuple_SetItem(keywords, i, kwd) < 0) {
		goto error;
		}
		PyTuple_SET_ITEM(keywords, i, kwd);
		}
		return PyModule_Add(module, "SQLITE_KEYWORDS", keywords);

		error:
		Py_XDECREF(keywords);
		Py_DECREF(keywords);
		return -1;
		}
		#else
		return 0;
		#endif
		}

		static int
		add_integer_constants(PyObject *module) {
Expand DownExpand Up		@@ -737,11 +737,9 @@ module_exec(PyObject *module)
		goto error;
		}

		#if SQLITE_VERSION_NUMBER < 3024000
		if (add_keyword_tuple(module) < 0) {
		goto error;
		}
		#endif

		if (PyModule_AddStringConstant(module, "sqlite_version", sqlite3_libversion())) {
		goto error;
Expand Down