Ability to list just FTS4 or FTS5 table names

docs/cli.rst

@@ -16,6 +16,11 @@ You can list the names of tables in a database using the ``table_names`` subcomm
     cats
     chickens
 
+If you just want to see the FTS4 tables, you can use ``--fts4`` (or ``--fts5`` for FTS5 tables)::
+
+    $ sqlite-utils table_names --fts4 docs.db
+    docs_fts
+
 Vacuum
 ======
 

docs/python-api.rst

@@ -40,12 +40,14 @@ If the table does not yet exist, it will be created the first time you attempt t
 Listing tables
 ==============
 
-You can list the names of tables in a database using the ``.table_names`` property::
+You can list the names of tables in a database using the ``.table_names()`` method::
 
-    >>> db.table_names
+    >>> db.table_names()
     ['dogs']
 
-You can also iterate through the table objects themselves using ``.tables``::
+To see just the FTS4 tables, use ``.table_names(fts4=True)``. For FTS5, use ``.table_names(fts5=True)``.
+
+You can also iterate through the table objects themselves using the ``.tables`` property::
 
     >>> db.tables
     [<Table dogs>]

sqlite_utils/cli.py

@@ -15,10 +15,16 @@ def cli():
     type=click.Path(exists=True, file_okay=True, dir_okay=False, allow_dash=False),
     required=True,
 )
-def table_names(path):
+@click.option(
+    "--fts4", help="Just show FTS4 enabled tables", default=False, is_flag=True
+)
+@click.option(
+    "--fts5", help="Just show FTS5 enabled tables", default=False, is_flag=True
+)
+def table_names(path, fts4, fts5):
     """List the tables in the database"""
     db = sqlite_utils.Database(path)
-    for name in db.table_names:
+    for name in db.table_names(fts4=fts4, fts5=fts5):
         print(name)
 
 

sqlite_utils/db.py

@@ -25,18 +25,18 @@ class Database:
     def __repr__(self):
         return "<Database {}>".format(self.conn)
 
-    @property
-    def table_names(self):
-        return [
-            r[0]
-            for r in self.conn.execute(
-                "select name from sqlite_master where type = 'table'"
-            ).fetchall()
-        ]
+    def table_names(self, fts4=False, fts5=False):
+        where = ["type = 'table'"]
+        if fts4:
+            where.append("sql like '%FTS4%'")
+        if fts5:
+            where.append("sql like '%FTS5%'")
+        sql = "select name from sqlite_master where {}".format(" AND ".join(where))
+        return [r[0] for r in self.conn.execute(sql).fetchall()]
 
     @property
     def tables(self):
-        return [self[name] for name in self.table_names]
+        return [self[name] for name in self.table_names()]
 
     def execute_returning_dicts(self, sql, params=None):
         cursor = self.conn.execute(sql, params or tuple())
@@ -106,7 +106,7 @@ class Table:
     def __init__(self, db, name):
         self.db = db
         self.name = name
-        self.exists = self.name in self.db.table_names
+        self.exists = self.name in self.db.table_names()
 
     def __repr__(self):
         return "<Table {}{}>".format(

tests/test_cli.py

@@ -1,4 +1,4 @@
-from sqlite_utils import cli
+from sqlite_utils import cli, Database
 from click.testing import CliRunner
 import pytest
 import sqlite3
@@ -23,6 +23,18 @@ def test_table_names(db_path):
     assert "Gosh\nGosh2" == result.output.strip()
 
 
+def test_table_names_fts4(db_path):
+    Database(db_path)["Gosh"].enable_fts(["c2"], fts_version="FTS4")
+    result = CliRunner().invoke(cli.cli, ["table_names", "--fts4", db_path])
+    assert "Gosh_fts" == result.output.strip()
+
+
+def test_table_names_fts5(db_path):
+    Database(db_path)["Gosh"].enable_fts(["c2"], fts_version="FTS5")
+    result = CliRunner().invoke(cli.cli, ["table_names", "--fts5", db_path])
+    assert "Gosh_fts" == result.output.strip()
+
+
 def test_vacuum(db_path):
     result = CliRunner().invoke(cli.cli, ["vacuum", db_path])
     assert 0 == result.exit_code

tests/test_create.py

@@ -6,7 +6,7 @@ import json
 
 
 def test_create_table(fresh_db):
-    assert [] == fresh_db.table_names
+    assert [] == fresh_db.table_names()
     table = fresh_db.create_table(
         "test_table",
         {
@@ -18,7 +18,7 @@ def test_create_table(fresh_db):
             "datetime_col": datetime.datetime,
         },
     )
-    assert ["test_table"] == fresh_db.table_names
+    assert ["test_table"] == fresh_db.table_names()
     assert [
         {"name": "text_col", "type": "TEXT"},
         {"name": "float_col", "type": "FLOAT"},
@@ -44,7 +44,7 @@ def test_create_table(fresh_db):
 )
 def test_create_table_from_example(fresh_db, example, expected_columns):
     fresh_db["people"].insert(example)
-    assert ["people"] == fresh_db.table_names
+    assert ["people"] == fresh_db.table_names()
     assert expected_columns == [
         {"name": col.name, "type": col.type} for col in fresh_db["people"].columns
     ]

tests/test_enable_fts.py

@@ -7,7 +7,7 @@ search_records = [
 def test_enable_fts(fresh_db):
     table = fresh_db["searchable"]
     table.insert_all(search_records)
-    assert ["searchable"] == fresh_db.table_names
+    assert ["searchable"] == fresh_db.table_names()
     table.enable_fts(["text", "country"], fts_version="FTS4")
     assert [
         "searchable",
@@ -16,7 +16,7 @@ def test_enable_fts(fresh_db):
         "searchable_fts_segdir",
         "searchable_fts_docsize",
         "searchable_fts_stat",
-    ] == fresh_db.table_names
+    ] == fresh_db.table_names()
     assert [("tanuki are tricksters", "Japan", "foo")] == table.search("tanuki")
     assert [("racoons are trash pandas", "USA", "bar")] == table.search("usa")
     assert [] == table.search("bar")

tests/test_introspect.py

@@ -2,7 +2,13 @@ from sqlite_utils.db import Index
 
 
 def test_table_names(existing_db):
-    assert ["foo"] == existing_db.table_names
+    assert ["foo"] == existing_db.table_names()
+
+
+def test_table_names_fts4(existing_db):
+    existing_db["woo"].insert({"title": "Hello"})
+    existing_db["woo"].enable_fts(["title"], fts_version="FTS4")
+    assert ["woo_fts"] == existing_db.table_names(fts4=True)
 
 
 def test_tables(existing_db):