sqlite-utils 3.38a0__tar.gz → 3.39__tar.gz

{sqlite_utils-3.38a0/sqlite_utils.egg-info → sqlite_utils-3.39}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sqlite-utils
-Version: 3.38a0
+Version: 3.39
 Summary: CLI tool and Python library for manipulating SQLite databases
 Home-page: https://github.com/simonw/sqlite-utils
 Author: Simon Willison
@@ -15,22 +15,21 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Topic :: Database
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlite-fts4
-Requires-Dist: click
+Requires-Dist: click>=8.3.1
 Requires-Dist: click-default-group>=1.2.3
 Requires-Dist: tabulate
 Requires-Dist: python-dateutil
 Requires-Dist: pluggy
+Requires-Dist: pip
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: black>=24.1.1; extra == "test"
@@ -54,6 +53,18 @@ Provides-Extra: flake8
 Requires-Dist: flake8; extra == "flake8"
 Provides-Extra: tui
 Requires-Dist: trogon; extra == "tui"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # sqlite-utils
 

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/docs/changelog.rst

@@ -4,6 +4,27 @@
  Changelog
 ===========
 
+.. _v3_39:
+
+3.39 (2025-11-24)
+-----------------
+
+- Fixed a bug with ``sqlite-utils install`` when the tool had been installed using ``uv``. (:issue:`687`)
+- The ```--functions``` argument now optionally accepts a path to a Python file as an alternative to a string full of code, and can be specified multiple times - see :ref:`cli_query_functions`.  (:issue:`659`)
+- ``sqlite-utils`` now requires on Python 3.10 or higher.
+
+`sqlite-utils 4.0a1 <https://sqlite-utils.datasette.io/en/latest/changelog.html#a1-2025-11-23>`__ is now available as an alpha with some `minor breaking changes <https://simonwillison.net/2025/Nov/24/sqlite-utils-40a1/>`__.
+
+.. _v3_38:
+
+3.38 (2024-11-23)
+-----------------
+
+- Plugins can now reuse the implementation of the ``sqlite-utils memory`` CLI command with the new ``return_db=True`` parameter. (:issue:`643`)
+- ``table.transform()`` now recreates indexes after transforming a table. A new ``sqlite_utils.db.TransformError`` exception is raised if these indexes cannot be recreated due to conflicting changes to the table such as a column rename. Thanks, `Mat Miller <https://github.com/matdmiller>`__. (:issue:`633`)
+- ``table.search()`` now accepts a ``include_rank=True`` parameter, causing the resulting rows to have a ``rank`` column showing the calculated relevance score. Thanks, `liunux4odoo <https://github.com/liunux4odoo>`__. (`#628 <https://github.com/simonw/sqlite-utils/pull/628>`__)
+- Fixed an error that occurred when creating a strict table with at least one floating point column. These ``FLOAT`` columns are now correctly created as ``REAL`` as well, but only for strict tables. (:issue:`644`)
+
 .. _v3_37:
 
 3.37 (2024-07-18)

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/docs/cli-reference.rst

@@ -132,7 +132,7 @@ See :ref:`cli_query`.
       -r, --raw                   Raw output, first column of first row
       --raw-lines                 Raw output, first column of each row
       -p, --param <TEXT TEXT>...  Named :parameters for SQL query
-      --functions TEXT            Python code defining one or more custom SQL
+      --functions TEXT            Python code or file path defining custom SQL
                                   functions
       --load-extension TEXT       Path to SQLite extension, with optional
                                   :entrypoint
@@ -175,7 +175,7 @@ See :ref:`cli_memory`.
           sqlite-utils memory animals.csv --schema
 
     Options:
-      --functions TEXT            Python code defining one or more custom SQL
+      --functions TEXT            Python code or file path defining custom SQL
                                   functions
       --attach <TEXT FILE>...     Additional databases to attach - specify alias and
                                   filepath
@@ -375,7 +375,7 @@ See :ref:`cli_bulk`.
 
     Options:
       --batch-size INTEGER   Commit every X records
-      --functions TEXT       Python code defining one or more custom SQL functions
+      --functions TEXT       Python code or file path defining custom SQL functions
       --flatten              Flatten nested JSON objects, so {"a": {"b": 1}} becomes
                              {"a_b": 1}
       --nl                   Expect newline-delimited JSON
@@ -1497,7 +1497,7 @@ See :ref:`cli_spatialite`.
       paths. To load it from a specific path, use --load-extension.
 
     Options:
-      -t, --type [POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION|GEOMETRY]
+      -t, --type [point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection|geometry]
                                       Specify a geometry type for this column.
                                       [default: GEOMETRY]
       --srid INTEGER                  Spatial Reference ID. See

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/docs/cli.rst

@@ -368,6 +368,22 @@ This example defines a function which extracts the domain from a URL:
 
 Every callable object defined in the block will be registered as a SQL function with the same name, with the exception of functions with names that begin with an underscore.
 
+You can also pass the path to a Python file containing function definitions:
+
+.. code-block:: bash
+
+    sqlite-utils query sites.db "select url, domain(url) from urls" --functions functions.py
+
+The ``--functions`` option can be used multiple times to load functions from multiple sources:
+
+.. code-block:: bash
+
+    sqlite-utils query sites.db "select url, domain(url), extract_path(url) from urls" \
+      --functions domain_funcs.py \
+      --functions 'def extract_path(url):
+        from urllib.parse import urlparse
+        return urlparse(url).path'
+
 .. _cli_query_extensions:
 
 SQLite extensions
@@ -1128,7 +1144,7 @@ You can insert binary data into a BLOB column by first encoding it using base64
 Inserting newline-delimited JSON
 --------------------------------
 
-You can also import `newline-delimited JSON <http://ndjson.org/>`__ using the ``--nl`` option:
+You can also import newline-delimited JSON (see `JSON Lines <https://jsonlines.org/>`__) using the ``--nl`` option:
 
 .. code-block:: bash
 
@@ -2796,7 +2812,7 @@ To enable this feature you will need to install the ``trogon`` dependency. You c
 
 .. code-block:: bash
 
-    sqite-utils install trogon
+    sqlite-utils install trogon
 
 Once installed, running the ``sqlite-utils tui`` command will launch the TUI interface:
 

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/docs/python-api.rst

@@ -1249,6 +1249,9 @@ If you pass a Python type, it will be mapped to SQLite types as shown here::
     np.float32: "FLOAT"
     np.float64: "FLOAT"
 
+.. note::
+    In sqlite-utils 3.x ``FLOAT`` is used for floating point columns when the correct column type is actually ``REAL``. If you specify ``strict=True`` tables created in strict mode will use the correct column type of ``REAL`` instead. We plan to change this behavior in ``sqlite-utils`` 4.x to always use ``REAL``, but this will represent a minor breaking change and so is being held for the next major release, see issue :issue:`645`.
+
 You can also add a column that is a foreign key reference to another table using the ``fk`` parameter:
 
 .. code-block:: python
@@ -1402,6 +1405,8 @@ To keep the original table around instead of dropping it, pass the ``keep_table=
 
     table.transform(types={"age": int}, keep_table="original_table")
 
+This method raises a ``sqlite_utils.db.TransformError`` exception if the table cannot be transformed, usually because there are existing constraints or indexes that are incompatible with modifications to the columns.
+
 .. _python_api_transform_alter_column_types:
 
 Altering column types
@@ -2309,6 +2314,9 @@ The ``.search()`` method also accepts the following optional parameters:
 ``where_args`` dictionary
     Arguments to use for ``:param`` placeholders in the extra WHERE clause
 
+``include_rank`` bool
+    If set a ``rank`` column will be included with the BM25 ranking score - for FTS5 tables only.
+
 ``quote`` bool
     Apply :ref:`FTS quoting rules <python_api_quote_fts>` to the search query, disabling advanced query syntax in a way that avoids surprising errors.
 
@@ -2703,7 +2711,7 @@ By default, the name of the Python function will be used as the name of the SQL
 
     print(db.execute('select rev("hello")').fetchone()[0])
 
-Python 3.8 added the ability to register `deterministic SQLite functions <https://sqlite.org/deterministic.html>`__, allowing you to indicate that a function will return the exact same result for any given inputs and hence allowing SQLite to apply some performance optimizations. You can mark a function as deterministic using ``deterministic=True``, like this:
+If a function will return the exact same result for any given inputs you can register it as a `deterministic SQLite function <https://sqlite.org/deterministic.html>`__ allowing SQLite to apply some performance optimizations:
 
 .. code-block:: python
 
@@ -2711,8 +2719,6 @@ Python 3.8 added the ability to register `deterministic SQLite functions <https:
     def reverse_string(s):
         return "".join(reversed(list(s)))
 
-If you run this on a version of Python prior to 3.8 your code will still work, but the ``deterministic=True`` parameter will be ignored.
-
 By default registering a function with the same name and number of arguments will have no effect - the ``Database`` instance keeps track of functions that have already been registered and skips registering them if ``@db.register_function`` is called a second time.
 
 If you want to deliberately replace the registered function with a new implementation, use the ``replace=True`` argument:

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import io
 import os
 
-VERSION = "3.38a0"
+VERSION = "3.39"
 
 
 def get_long_description():
@@ -25,11 +25,12 @@ setup(
     package_data={"sqlite_utils": ["py.typed"]},
     install_requires=[
         "sqlite-fts4",
-        "click",
+        "click>=8.3.1",
         "click-default-group>=1.2.3",
         "tabulate",
         "python-dateutil",
         "pluggy",
+        "pip",
     ],
     extras_require={
         "test": ["pytest", "black>=24.1.1", "hypothesis", "cogapp"],
@@ -64,20 +65,18 @@ setup(
         "Issues": "https://github.com/simonw/sqlite-utils/issues",
         "CI": "https://github.com/simonw/sqlite-utils/actions",
     },
-    python_requires=">=3.8",
+    python_requires=">=3.10",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
         "Intended Audience :: Science/Research",
         "Intended Audience :: End Users/Desktop",
         "Topic :: Database",
-        "License :: OSI Approved :: Apache Software License",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
     ],
     # Needed to bundle py.typed so mypy can see it:
     zip_safe=False,

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/sqlite_utils/cli.py

@@ -1,7 +1,7 @@
 import base64
 import click
 from click_default_group import DefaultGroup  # type: ignore
-from datetime import datetime
+from datetime import datetime, timezone
 import hashlib
 import pathlib
 from runpy import run_module
@@ -962,7 +962,7 @@ def insert_upsert_implementation(
     db = sqlite_utils.Database(path)
     _load_extensions(db, load_extension)
     if functions:
-        _register_functions(db, functions)
+        _register_functions_from_multiple(db, functions)
     if (delimiter or quotechar or sniff or no_headers) and not tsv:
         csv = True
     if (nl + csv + tsv) >= 2:
@@ -1370,7 +1370,9 @@ def upsert(
 @click.argument("file", type=click.File("rb"), required=True)
 @click.option("--batch-size", type=int, default=100, help="Commit every X records")
 @click.option(
-    "--functions", help="Python code defining one or more custom SQL functions"
+    "--functions",
+    help="Python code or file path defining custom SQL functions",
+    multiple=True,
 )
 @import_options
 @load_extension_option
@@ -1759,7 +1761,9 @@ def drop_view(path, view, ignore, load_extension):
     help="Named :parameters for SQL query",
 )
 @click.option(
-    "--functions", help="Python code defining one or more custom SQL functions"
+    "--functions",
+    help="Python code or file path defining custom SQL functions",
+    multiple=True,
 )
 @load_extension_option
 def query(
@@ -1796,7 +1800,7 @@ def query(
     db.register_fts4_bm25()
 
     if functions:
-        _register_functions(db, functions)
+        _register_functions_from_multiple(db, functions)
 
     _execute_query(
         db,
@@ -1824,7 +1828,9 @@ def query(
 )
 @click.argument("sql")
 @click.option(
-    "--functions", help="Python code defining one or more custom SQL functions"
+    "--functions",
+    help="Python code or file path defining custom SQL functions",
+    multiple=True,
 )
 @click.option(
     "--attach",
@@ -1996,7 +2002,7 @@ def memory(
     db.register_fts4_bm25()
 
     if functions:
-        _register_functions(db, functions)
+        _register_functions_from_multiple(db, functions)
 
     if return_db:
         return db
@@ -3203,8 +3209,12 @@ FILE_COLUMNS = {
     "ctime": lambda p: p.stat().st_ctime,
     "mtime_int": lambda p: int(p.stat().st_mtime),
     "ctime_int": lambda p: int(p.stat().st_ctime),
-    "mtime_iso": lambda p: datetime.utcfromtimestamp(p.stat().st_mtime).isoformat(),
-    "ctime_iso": lambda p: datetime.utcfromtimestamp(p.stat().st_ctime).isoformat(),
+    "mtime_iso": lambda p: datetime.fromtimestamp(p.stat().st_mtime, timezone.utc)
+    .replace(tzinfo=None)
+    .isoformat(),
+    "ctime_iso": lambda p: datetime.fromtimestamp(p.stat().st_ctime, timezone.utc)
+    .replace(tzinfo=None)
+    .isoformat(),
     "size": lambda p: p.stat().st_size,
     "stem": lambda p: p.stem,
     "suffix": lambda p: p.suffix,
@@ -3281,6 +3291,13 @@ def _load_extensions(db, load_extension):
 
 def _register_functions(db, functions):
     # Register any Python functions as SQL functions:
+    # Check if this is a file path
+    if "\n" not in functions and functions.endswith(".py"):
+        try:
+            functions = pathlib.Path(functions).read_text()
+        except FileNotFoundError:
+            raise click.ClickException("File not found: {}".format(functions))
+
     sqlite3.enable_callback_tracebacks(True)
     globals = {}
     try:
@@ -3291,3 +3308,12 @@ def _register_functions(db, functions):
     for name, value in globals.items():
         if callable(value) and not name.startswith("_"):
             db.register_function(value, name=name)
+
+
+def _register_functions_from_multiple(db, functions_list):
+    """Register functions from multiple --functions arguments."""
+    if not functions_list:
+        return
+    for functions in functions_list:
+        if isinstance(functions, str) and functions.strip():
+            _register_functions(db, functions)

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/sqlite_utils/db.py

@@ -156,6 +156,10 @@ XIndexColumn = namedtuple(
 Trigger = namedtuple("Trigger", ("name", "table", "sql"))
 
 
+class TransformError(Exception):
+    pass
+
+
 ForeignKeyIndicator = Union[
     str,
     ForeignKey,
@@ -233,36 +237,43 @@ if pd:
 
 class AlterError(Exception):
     "Error altering table"
+
     pass
 
 
 class NoObviousTable(Exception):
     "Could not tell which table this operation refers to"
+
     pass
 
 
 class NoTable(Exception):
     "Specified table does not exist"
+
     pass
 
 
 class BadPrimaryKey(Exception):
     "Table does not have a single obvious primary key"
+
     pass
 
 
 class NotFoundError(Exception):
     "Record not found"
+
     pass
 
 
 class PrimaryKeyRequired(Exception):
     "Primary key needs to be specified"
+
     pass
 
 
 class InvalidColumns(Exception):
     "Specified columns do not exist"
+
     pass
 
 
@@ -364,7 +375,7 @@ class Database:
             pm.hook.prepare_connection(conn=self.conn)
         self.strict = strict
 
-    def close(self):
+    def close(self) -> None:
         "Close the SQLite connection, and the underlying database file"
         self.conn.close()
 
@@ -934,10 +945,15 @@ class Database:
                         other_column=foreign_keys_by_column[column_name].other_column,
                     )
                 )
+            column_type_str = COLUMN_TYPE_MAPPING[column_type]
+            # Special case for strict tables to map FLOAT to REAL
+            # Refs https://github.com/simonw/sqlite-utils/issues/644
+            if strict and column_type_str == "FLOAT":
+                column_type_str = "REAL"
             column_defs.append(
                 "   [{column_name}] {column_type}{column_extras}".format(
                     column_name=column_name,
-                    column_type=COLUMN_TYPE_MAPPING[column_type],
+                    column_type=column_type_str,
                     column_extras=(
                         (" " + " ".join(column_extras)) if column_extras else ""
                     ),
@@ -1972,6 +1988,30 @@ class Table(Queryable):
         sqls.append(
             "ALTER TABLE [{}] RENAME TO [{}];".format(new_table_name, self.name)
         )
+        # Re-add existing indexes
+        for index in self.indexes:
+            if index.origin != "pk":
+                index_sql = self.db.execute(
+                    """SELECT sql FROM sqlite_master WHERE type = 'index' AND name = :index_name;""",
+                    {"index_name": index.name},
+                ).fetchall()[0][0]
+                if index_sql is None:
+                    raise TransformError(
+                        f"Index '{index.name}' on table '{self.name}' does not have a "
+                        "CREATE INDEX statement. You must manually drop this index prior to running this "
+                        "transformation and manually recreate the new index after running this transformation."
+                    )
+                if keep_table:
+                    sqls.append(f"DROP INDEX IF EXISTS [{index.name}];")
+                for col in index.columns:
+                    if col in rename.keys() or col in drop:
+                        raise TransformError(
+                            f"Index '{index.name}' column '{col}' is not in updated table '{self.name}'. "
+                            f"You must manually drop this index prior to running this transformation "
+                            f"and manually recreate the new index after running this transformation. "
+                            f"The original index sql statement is: `{index_sql}`. No changes have been applied to this table."
+                        )
+                sqls.append(index_sql)
         return sqls
 
     def extract(
@@ -2650,6 +2690,7 @@ class Table(Queryable):
         offset: Optional[int] = None,
         where: Optional[str] = None,
         where_args: Optional[Union[Iterable, dict]] = None,
+        include_rank: bool = False,
         quote: bool = False,
     ) -> Generator[dict, None, None]:
         """
@@ -2663,6 +2704,7 @@ class Table(Queryable):
         :param offset: Optional integer SQL offset.
         :param where: Extra SQL fragment for the WHERE clause
         :param where_args: Arguments to use for :param placeholders in the extra WHERE clause
+        :param include_rank: Select the search rank column in the final query
         :param quote: Apply quoting to disable any special characters in the search query
 
         See :ref:`python_api_fts_search`.
@@ -2682,6 +2724,7 @@ class Table(Queryable):
                 limit=limit,
                 offset=offset,
                 where=where,
+                include_rank=include_rank,
             ),
             args,
         )
@@ -3167,7 +3210,7 @@ class Table(Queryable):
         :param not_null: Set of strings specifying columns that should be ``NOT NULL``.
         :param defaults: Dictionary specifying default values for specific columns.
         :param hash_id: Name of a column to create and use as a primary key, where the
-          value of thet primary key will be derived as a SHA1 hash of the other column values
+          value of that primary key will be derived as a SHA1 hash of the other column values
           in the record. ``hash_id="id"`` is a common column name used for this.
         :param alter: Boolean, should any missing columns be added automatically?
         :param ignore: Boolean, if a record already exists with this primary key, ignore this insert.
@@ -3816,7 +3859,7 @@ def jsonify_if_needed(value):
 
 
 def resolve_extracts(
-    extracts: Optional[Union[Dict[str, str], List[str], Tuple[str]]]
+    extracts: Optional[Union[Dict[str, str], List[str], Tuple[str]]],
 ) -> dict:
     if extracts is None:
         extracts = {}

{sqlite_utils-3.38a0 → sqlite_utils-3.39/sqlite_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sqlite-utils
-Version: 3.38a0
+Version: 3.39
 Summary: CLI tool and Python library for manipulating SQLite databases
 Home-page: https://github.com/simonw/sqlite-utils
 Author: Simon Willison
@@ -15,22 +15,21 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Topic :: Database
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlite-fts4
-Requires-Dist: click
+Requires-Dist: click>=8.3.1
 Requires-Dist: click-default-group>=1.2.3
 Requires-Dist: tabulate
 Requires-Dist: python-dateutil
 Requires-Dist: pluggy
+Requires-Dist: pip
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: black>=24.1.1; extra == "test"
@@ -54,6 +53,18 @@ Provides-Extra: flake8
 Requires-Dist: flake8; extra == "flake8"
 Provides-Extra: tui
 Requires-Dist: trogon; extra == "tui"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # sqlite-utils
 

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/sqlite_utils.egg-info/requires.txt

@@ -1,9 +1,10 @@
 sqlite-fts4
-click
+click>=8.3.1
 click-default-group>=1.2.3
 tabulate
 python-dateutil
 pluggy
+pip
 
 [docs]
 furo

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_cli.py

@@ -806,6 +806,77 @@ def test_hidden_functions_are_hidden(db_path):
     assert "_two" not in functions
 
 
+def test_query_functions_from_file(db_path, tmp_path):
+    # Create a temporary file with function definitions
+    functions_file = tmp_path / "my_functions.py"
+    functions_file.write_text(TEST_FUNCTIONS)
+
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            db_path,
+            "select zero(), one(1), two(1, 2)",
+            "--functions",
+            str(functions_file),
+        ],
+    )
+    assert result.exit_code == 0
+    assert json.loads(result.output.strip()) == [
+        {"zero()": 0, "one(1)": 1, "two(1, 2)": 3}
+    ]
+
+
+def test_query_functions_file_not_found(db_path):
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            db_path,
+            "select zero()",
+            "--functions",
+            "nonexistent.py",
+        ],
+    )
+    assert result.exit_code == 1
+    assert "File not found: nonexistent.py" in result.output
+
+
+def test_query_functions_multiple_invocations(db_path):
+    # Test using --functions multiple times
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            db_path,
+            "select triple(2), quadruple(2)",
+            "--functions",
+            "def triple(x):\n    return x * 3",
+            "--functions",
+            "def quadruple(x):\n    return x * 4",
+        ],
+    )
+    assert result.exit_code == 0
+    assert json.loads(result.output.strip()) == [{"triple(2)": 6, "quadruple(2)": 8}]
+
+
+def test_query_functions_file_and_inline(db_path, tmp_path):
+    # Test combining file and inline code
+    functions_file = tmp_path / "file_funcs.py"
+    functions_file.write_text("def triple(x):\n    return x * 3")
+
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            db_path,
+            "select triple(2), quadruple(2)",
+            "--functions",
+            str(functions_file),
+            "--functions",
+            "def quadruple(x):\n    return x * 4",
+        ],
+    )
+    assert result.exit_code == 0
+    assert json.loads(result.output.strip()) == [{"triple(2)": 6, "quadruple(2)": 8}]
+
+
 LOREM_IPSUM_COMPRESSED = (
     b"x\x9c\xed\xd1\xcdq\x03!\x0c\x05\xe0\xbb\xabP\x01\x1eW\x91\xdc|M\x01\n\xc8\x8e"
     b"f\xf83H\x1e\x97\x1f\x91M\x8e\xe9\xe0\xdd\x96\x05\x84\xf4\xbek\x9fRI\xc7\xf2J"
@@ -916,7 +987,7 @@ def test_query_json_with_json_cols(db_path):
 
 @pytest.mark.parametrize(
     "content,is_binary",
-    [(b"\x00\x0Fbinary", True), ("this is text", False), (1, False), (1.5, False)],
+    [(b"\x00\x0fbinary", True), ("this is text", False), (1, False), (1.5, False)],
 )
 def test_query_raw(db_path, content, is_binary):
     Database(db_path)["files"].insert({"content": content})
@@ -931,7 +1002,7 @@ def test_query_raw(db_path, content, is_binary):
 
 @pytest.mark.parametrize(
     "content,is_binary",
-    [(b"\x00\x0Fbinary", True), ("this is text", False), (1, False), (1.5, False)],
+    [(b"\x00\x0fbinary", True), ("this is text", False), (1, False), (1.5, False)],
 )
 def test_query_raw_lines(db_path, content, is_binary):
     Database(db_path)["files"].insert_all({"content": content} for _ in range(3))
@@ -2416,11 +2487,13 @@ def test_create_table_strict(strict):
         db = Database("test.db")
         result = runner.invoke(
             cli.cli,
-            ["create-table", "test.db", "items", "id", "integer"]
+            ["create-table", "test.db", "items", "id", "integer", "w", "float"]
             + (["--strict"] if strict else []),
         )
         assert result.exit_code == 0
         assert db["items"].strict == strict or not db.supports_strict
+        # Should have a floating point column
+        assert db["items"].columns_dict == {"id": int, "w": float}
 
 
 @pytest.mark.parametrize("method", ("insert", "upsert"))

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_cli_bulk.py

@@ -45,6 +45,32 @@ def test_cli_bulk(test_db_and_path):
     ] == list(db["example"].rows)
 
 
+def test_cli_bulk_multiple_functions(test_db_and_path):
+    db, db_path = test_db_and_path
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            "bulk",
+            db_path,
+            "insert into example (id, name) values (:id, myupper(mylower(:name)))",
+            "-",
+            "--nl",
+            "--functions",
+            "myupper = lambda s: s.upper()",
+            "--functions",
+            "mylower = lambda s: s.lower()",
+        ],
+        input='{"id": 3, "name": "ThReE"}\n{"id": 4, "name": "FoUr"}\n',
+    )
+    assert result.exit_code == 0, result.output
+    assert [
+        {"id": 1, "name": "One"},
+        {"id": 2, "name": "Two"},
+        {"id": 3, "name": "THREE"},
+        {"id": 4, "name": "FOUR"},
+    ] == list(db["example"].rows)
+
+
 def test_cli_bulk_batch_size(test_db_and_path):
     db, db_path = test_db_and_path
     proc = subprocess.Popen(

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_cli_memory.py

@@ -307,6 +307,22 @@ def test_memory_functions():
     assert result.output.strip() == '[{"hello()": "Hello"}]'
 
 
+def test_memory_functions_multiple():
+    result = CliRunner().invoke(
+        cli.cli,
+        [
+            "memory",
+            "select triple(2), quadruple(2)",
+            "--functions",
+            "def triple(x):\n    return x * 3",
+            "--functions",
+            "def quadruple(x):\n    return x * 4",
+        ],
+    )
+    assert result.exit_code == 0
+    assert result.output.strip() == '[{"triple(2)": 6, "quadruple(2)": 8}]'
+
+
 def test_memory_return_db(tmpdir):
     # https://github.com/simonw/sqlite-utils/issues/643
     from sqlite_utils.cli import cli

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_create.py

@@ -1350,8 +1350,14 @@ def test_insert_upsert_strict(fresh_db, method_name, strict):
 
 @pytest.mark.parametrize("strict", (False, True))
 def test_create_table_strict(fresh_db, strict):
-    table = fresh_db.create_table("t", {"id": int}, strict=strict)
+    table = fresh_db.create_table("t", {"id": int, "f": float}, strict=strict)
     assert table.strict == strict or not fresh_db.supports_strict
+    expected_schema = "CREATE TABLE [t] (\n" "   [id] INTEGER,\n" "   [f] FLOAT\n" ")"
+    if strict and not fresh_db.supports_strict:
+        return
+    if strict:
+        expected_schema = "CREATE TABLE [t] (\n   [id] INTEGER,\n   [f] REAL\n) STRICT"
+    assert table.schema == expected_schema
 
 
 @pytest.mark.parametrize("strict", (False, True))

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_fts.py

@@ -1,6 +1,7 @@
 import pytest
 from sqlite_utils import Database
 from sqlite_utils.utils import sqlite3
+from unittest.mock import ANY
 
 search_records = [
     {
@@ -126,6 +127,32 @@ def test_search_where_args_disallows_query(fresh_db):
     )
 
 
+def test_search_include_rank(fresh_db):
+    table = fresh_db["t"]
+    table.insert_all(search_records)
+    table.enable_fts(["text", "country"], fts_version="FTS5")
+    results = list(table.search("are", include_rank=True))
+    assert results == [
+        {
+            "rowid": 1,
+            "text": "tanuki are running tricksters",
+            "country": "Japan",
+            "not_searchable": "foo",
+            "rank": ANY,
+        },
+        {
+            "rowid": 2,
+            "text": "racoons are biting trash pandas",
+            "country": "USA",
+            "not_searchable": "bar",
+            "rank": ANY,
+        },
+    ]
+    assert isinstance(results[0]["rank"], float)
+    assert isinstance(results[1]["rank"], float)
+    assert results[0]["rank"] < results[1]["rank"]
+
+
 def test_enable_fts_table_names_containing_spaces(fresh_db):
     table = fresh_db["test"]
     table.insert({"column with spaces": "in its name"})

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_recipes.py

@@ -64,6 +64,7 @@ def test_dayfirst_yearfirst(fresh_db, recipe, kwargs, expected):
 
 @pytest.mark.parametrize("fn", ("parsedate", "parsedatetime"))
 @pytest.mark.parametrize("errors", (None, recipes.SET_NULL, recipes.IGNORE))
+@pytest.mark.filterwarnings("ignore::pytest.PytestUnraisableExceptionWarning")
 def test_dateparse_errors(fresh_db, fn, errors):
     fresh_db["example"].insert_all(
         [

{sqlite_utils-3.38a0 → sqlite_utils-3.39}/tests/test_transform.py

@@ -1,4 +1,4 @@
-from sqlite_utils.db import ForeignKey
+from sqlite_utils.db import ForeignKey, TransformError
 from sqlite_utils.utils import OperationalError
 import pytest
 
@@ -539,3 +539,125 @@ def test_transform_strict(fresh_db, strict):
     assert dogs.strict == strict or not fresh_db.supports_strict
     dogs.transform(not_null={"name"})
     assert dogs.strict == strict or not fresh_db.supports_strict
+
+
+@pytest.mark.parametrize(
+    "indexes, transform_params",
+    [
+        ([["name"]], {"types": {"age": str}}),
+        ([["name"], ["age", "breed"]], {"types": {"age": str}}),
+        ([], {"types": {"age": str}}),
+        ([["name"]], {"types": {"age": str}, "keep_table": "old_dogs"}),
+    ],
+)
+def test_transform_indexes(fresh_db, indexes, transform_params):
+    # https://github.com/simonw/sqlite-utils/issues/633
+    # New table should have same indexes as old table after transformation
+    dogs = fresh_db["dogs"]
+    dogs.insert({"id": 1, "name": "Cleo", "age": 5, "breed": "Labrador"}, pk="id")
+
+    for index in indexes:
+        dogs.create_index(index)
+
+    indexes_before_transform = dogs.indexes
+
+    dogs.transform(**transform_params)
+
+    assert sorted(
+        [
+            {k: v for k, v in idx._asdict().items() if k != "seq"}
+            for idx in dogs.indexes
+        ],
+        key=lambda x: x["name"],
+    ) == sorted(
+        [
+            {k: v for k, v in idx._asdict().items() if k != "seq"}
+            for idx in indexes_before_transform
+        ],
+        key=lambda x: x["name"],
+    ), f"Indexes before transform: {indexes_before_transform}\nIndexes after transform: {dogs.indexes}"
+    if "keep_table" in transform_params:
+        assert all(
+            index.origin == "pk"
+            for index in fresh_db[transform_params["keep_table"]].indexes
+        )
+
+
+def test_transform_retains_indexes_with_foreign_keys(fresh_db):
+    dogs = fresh_db["dogs"]
+    owners = fresh_db["owners"]
+
+    dogs.insert({"id": 1, "name": "Cleo", "owner_id": 1}, pk="id")
+    owners.insert({"id": 1, "name": "Alice"}, pk="id")
+
+    dogs.create_index(["name"])
+
+    indexes_before_transform = dogs.indexes
+
+    fresh_db.add_foreign_keys([("dogs", "owner_id", "owners", "id")])  # calls transform
+
+    assert sorted(
+        [
+            {k: v for k, v in idx._asdict().items() if k != "seq"}
+            for idx in dogs.indexes
+        ],
+        key=lambda x: x["name"],
+    ) == sorted(
+        [
+            {k: v for k, v in idx._asdict().items() if k != "seq"}
+            for idx in indexes_before_transform
+        ],
+        key=lambda x: x["name"],
+    ), f"Indexes before transform: {indexes_before_transform}\nIndexes after transform: {dogs.indexes}"
+
+
+@pytest.mark.parametrize(
+    "transform_params",
+    [
+        {"rename": {"age": "dog_age"}},
+        {"drop": ["age"]},
+    ],
+)
+def test_transform_with_indexes_errors(fresh_db, transform_params):
+    # Should error with a compound (name, age) index if age is renamed or dropped
+    dogs = fresh_db["dogs"]
+    dogs.insert({"id": 1, "name": "Cleo", "age": 5}, pk="id")
+
+    dogs.create_index(["name", "age"])
+
+    with pytest.raises(TransformError) as excinfo:
+        dogs.transform(**transform_params)
+
+    assert (
+        "Index 'idx_dogs_name_age' column 'age' is not in updated table 'dogs'. "
+        "You must manually drop this index prior to running this transformation"
+        in str(excinfo.value)
+    )
+
+
+def test_transform_with_unique_constraint_implicit_index(fresh_db):
+    dogs = fresh_db["dogs"]
+    # Create a table with a UNIQUE constraint on 'name', which creates an implicit index
+    fresh_db.execute(
+        """
+        CREATE TABLE dogs (
+            id INTEGER PRIMARY KEY,
+            name TEXT UNIQUE,
+            age INTEGER
+        );
+    """
+    )
+    dogs.insert({"id": 1, "name": "Cleo", "age": 5})
+
+    # Attempt to transform the table without modifying 'name'
+    with pytest.raises(TransformError) as excinfo:
+        dogs.transform(types={"age": str})
+
+    assert (
+        "Index 'sqlite_autoindex_dogs_1' on table 'dogs' does not have a CREATE INDEX statement."
+        in str(excinfo.value)
+    )
+    assert (
+        "You must manually drop this index prior to running this transformation and manually recreate the new index after running this transformation."
+        in str(excinfo.value)
+    )