sqlit-tui 1.2.4__tar.gz → 1.2.6__tar.gz

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlit-tui
-Version: 1.2.4
+Version: 1.2.6
 Summary: A terminal UI for SQL Server, PostgreSQL, MySQL, SQLite, Oracle, and more
 Project-URL: Homepage, https://github.com/Maxteabag/sqlit
 Project-URL: Repository, https://github.com/Maxteabag/sqlit
@@ -32,6 +32,7 @@ Requires-Dist: adbc-driver-flightsql>=1.0.0; extra == 'all'
 Requires-Dist: clickhouse-connect>=0.7.0; extra == 'all'
 Requires-Dist: duckdb>=1.1.0; extra == 'all'
 Requires-Dist: firebirdsql>=1.3.5; extra == 'all'
+Requires-Dist: google-cloud-bigquery; extra == 'all'
 Requires-Dist: hdbcli>=2.20.0; extra == 'all'
 Requires-Dist: ibm-db>=3.2.0; extra == 'all'
 Requires-Dist: libsql>=0.1.0; extra == 'all'
@@ -46,14 +47,13 @@ Requires-Dist: pymysql>=1.1.0; extra == 'all'
 Requires-Dist: redshift-connector; extra == 'all'
 Requires-Dist: requests>=2.32.4; extra == 'all'
 Requires-Dist: snowflake-connector-python>=3.7.0; extra == 'all'
-Requires-Dist: sqlalchemy-bigquery; extra == 'all'
 Requires-Dist: sshtunnel>=0.4.0; extra == 'all'
 Requires-Dist: teradatasql>=20.0.0; extra == 'all'
 Requires-Dist: trino>=0.329.0; extra == 'all'
 Provides-Extra: athena
 Requires-Dist: pyathena>=3.22.0; extra == 'athena'
 Provides-Extra: bigquery
-Requires-Dist: sqlalchemy-bigquery; extra == 'bigquery'
+Requires-Dist: google-cloud-bigquery; extra == 'bigquery'
 Provides-Extra: clickhouse
 Requires-Dist: clickhouse-connect>=0.7.0; extra == 'clickhouse'
 Provides-Extra: cockroachdb

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/infra/docker/docker-compose.test.yml

@@ -198,6 +198,16 @@ services:
     tmpfs:
       - /var/lib/firebird/data
 
+  bigquery:
+    image: ghcr.io/goccy/bigquery-emulator:latest
+    container_name: sqlit-test-bigquery
+    command:
+      - "--project=${BIGQUERY_PROJECT:-test-project}"
+      - "--dataset=${BIGQUERY_DATASET:-test_sqlit}"
+    ports:
+      - "9050:9050"
+      - "9060:9060"
+
   # SSH server for testing SSH tunnel connections
   # Connects to postgres container on docker network
   ssh:

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/pyproject.toml

@@ -47,7 +47,7 @@ all = [
     "teradatasql>=20.0.0",
     "trino>=0.329.0",
     "presto-python-client>=0.8.4",
-    "sqlalchemy-bigquery",
+    "google-cloud-bigquery",
     "duckdb>=1.1.0",  # min avoids known CVEs
     "clickhouse-connect>=0.7.0",
     "requests>=2.32.4",  # min avoids known CVEs
@@ -71,7 +71,7 @@ hana = ["hdbcli>=2.20.0"]
 teradata = ["teradatasql>=20.0.0"]
 trino = ["trino>=0.329.0"]
 presto = ["presto-python-client>=0.8.4"]
-bigquery = ["sqlalchemy-bigquery"]
+bigquery = ["google-cloud-bigquery"]
 redshift = ["redshift-connector"]
 duckdb = ["duckdb>=1.1.0"]  # min avoids known CVEs
 clickhouse = ["clickhouse-connect>=0.7.0"]

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.4'
-__version_tuple__ = version_tuple = (1, 2, 4)
+__version__ = version = '1.2.6'
+__version_tuple__ = version_tuple = (1, 2, 6)
 
 __commit_id__ = commit_id = None

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/core/binding_contexts.py

@@ -12,6 +12,8 @@ def get_binding_contexts(ctx: InputContext) -> set[str]:
 
     if ctx.focus == "explorer":
         contexts.add("tree")
+    if ctx.tree_visual_mode_active:
+        contexts.add("tree_visual")
     if ctx.tree_filter_active:
         contexts.add("tree_filter")
 

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/core/input_context.py

@@ -16,15 +16,20 @@ class InputContext:
     leader_pending: bool
     leader_menu: str
     tree_filter_active: bool
+    tree_multi_select_active: bool
+    tree_visual_mode_active: bool
     autocomplete_visible: bool
     results_filter_active: bool
     value_view_active: bool
+    value_view_tree_mode: bool
+    value_view_is_json: bool
     query_executing: bool
     modal_open: bool
     has_connection: bool
     current_connection_name: str | None
     tree_node_kind: str | None
     tree_node_connection_name: str | None
+    tree_node_connection_selected: bool
     last_result_is_error: bool
     has_results: bool
     stacked_result_count: int = 0

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/core/keymap.py

@@ -10,6 +10,7 @@ from sqlit.shared.core.debug_events import emit_debug_event
 KEY_DISPLAY_OVERRIDES: dict[str, str] = {
     "question_mark": "?",
     "slash": "/",
+    "asterisk": "*",
     "space": "<space>",
     "escape": "<esc>",
     "enter": "<enter>",
@@ -285,23 +286,37 @@ class DefaultKeymapProvider(KeymapProvider):
             # rye results export menu
             LeaderCommandDef("c", "csv", "Export as CSV", "Export", menu="rye"),
             LeaderCommandDef("j", "json", "Export as JSON", "Export", menu="rye"),
+            # vy value view yank menu (tree mode)
+            LeaderCommandDef("y", "value", "Copy value", "Copy", menu="vy"),
+            LeaderCommandDef("f", "field", "Copy field", "Copy", menu="vy"),
+            LeaderCommandDef("a", "all", "Copy all", "Copy", menu="vy"),
         ]
 
     def _build_action_keys(self) -> list[ActionKeyDef]:
         return [
             # Tree actions
             ActionKeyDef("n", "new_connection", "tree"),
+            ActionKeyDef("v", "enter_tree_visual_mode", "tree"),
+            ActionKeyDef("escape", "exit_tree_visual_mode", "tree_visual"),
+            ActionKeyDef("v", "exit_tree_visual_mode", "tree_visual", primary=False),
+            ActionKeyDef("escape", "clear_connection_selection", "tree"),
             ActionKeyDef("s", "select_table", "tree"),
             ActionKeyDef("f", "refresh_tree", "tree"),
             ActionKeyDef("R", "refresh_tree", "tree", primary=False),
             ActionKeyDef("e", "edit_connection", "tree"),
+            ActionKeyDef("M", "rename_connection_folder", "tree"),
+            ActionKeyDef("d", "delete_connection_folder", "tree"),
+            ActionKeyDef("delete", "delete_connection_folder", "tree", primary=False),
             ActionKeyDef("d", "delete_connection", "tree"),
             ActionKeyDef("delete", "delete_connection", "tree", primary=False),
             ActionKeyDef("D", "duplicate_connection", "tree"),
+            ActionKeyDef("m", "move_connection_to_folder", "tree"),
             ActionKeyDef("x", "disconnect", "tree"),
             ActionKeyDef("z", "collapse_tree", "tree"),
             ActionKeyDef("j", "tree_cursor_down", "tree"),
+            ActionKeyDef("down", "tree_cursor_down", "tree", primary=False),
             ActionKeyDef("k", "tree_cursor_up", "tree"),
+            ActionKeyDef("up", "tree_cursor_up", "tree", primary=False),
             ActionKeyDef("slash", "tree_filter", "tree"),
             ActionKeyDef("escape", "tree_filter_close", "tree_filter"),
             ActionKeyDef("enter", "tree_filter_accept", "tree_filter"),
@@ -364,12 +379,13 @@ class DefaultKeymapProvider(KeymapProvider):
             ActionKeyDef("z", "toggle_result_section", "results"),
             ActionKeyDef("escape", "results_filter_close", "results_filter"),
             ActionKeyDef("enter", "results_filter_accept", "results_filter"),
-            ActionKeyDef("n", "results_filter_next", "results_filter"),
-            ActionKeyDef("N", "results_filter_prev", "results_filter"),
             # Value view
             ActionKeyDef("q", "close_value_view", "value_view"),
             ActionKeyDef("escape", "close_value_view", "value_view"),
             ActionKeyDef("y", "copy_value_view", "value_view"),
+            ActionKeyDef("t", "toggle_value_view_mode", "value_view"),
+            ActionKeyDef("z", "collapse_all_json_nodes", "value_view"),
+            ActionKeyDef("Z", "expand_all_json_nodes", "value_view"),
         ]
 
 

sqlit_tui-1.2.6/sqlit/domains/connections/app/persist_utils.py

@@ -0,0 +1,35 @@
+"""Helpers for safely persisting connections without dropping stored passwords."""
+
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sqlit.domains.connections.app.credentials import CredentialsService
+    from sqlit.domains.connections.domain.config import ConnectionConfig
+
+
+def build_persist_connections(
+    connections: list[ConnectionConfig],
+    credentials_service: CredentialsService,
+) -> list[ConnectionConfig]:
+    """Return a copy of connections with missing passwords filled from storage.
+
+    This prevents saves from clearing stored passwords when the in-memory
+    connection list was loaded without credentials.
+    """
+    persist_connections = copy.deepcopy(connections)
+    for conn in persist_connections:
+        endpoint = conn.tcp_endpoint
+        if endpoint and endpoint.password is None:
+            stored = credentials_service.get_password(conn.name)
+            if stored is not None:
+                endpoint.password = stored
+
+        if conn.tunnel and conn.tunnel.password is None:
+            stored_ssh = credentials_service.get_ssh_password(conn.name)
+            if stored_ssh is not None:
+                conn.tunnel.password = stored_ssh
+
+    return persist_connections

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/domains/connections/domain/config.py

@@ -126,6 +126,7 @@ class ConnectionConfig:
     tunnel: TunnelConfig | None = None
     source: str | None = None
     connection_url: str | None = None
+    folder_path: str = ""
     extra_options: dict[str, str] = field(default_factory=dict)
     options: dict[str, Any] = field(default_factory=dict)
 
@@ -216,6 +217,7 @@ class ConnectionConfig:
             "db_type",
             "source",
             "connection_url",
+            "folder_path",
             "extra_options",
         }
         for key in list(payload.keys()):
@@ -226,6 +228,8 @@ class ConnectionConfig:
             else:
                 payload.pop(key)
 
+        folder_path = normalize_folder_path(payload.get("folder_path", ""))
+
         return cls(
             name=str(payload.get("name", "")),
             db_type=str(payload.get("db_type", "mssql")),
@@ -233,6 +237,7 @@ class ConnectionConfig:
             tunnel=tunnel,
             source=payload.get("source"),
             connection_url=payload.get("connection_url"),
+            folder_path=folder_path,
             extra_options=dict(payload.get("extra_options") or {}),
             options=options,
         )
@@ -299,6 +304,7 @@ class ConnectionConfig:
             "db_type": self.db_type,
             "source": self.source,
             "connection_url": self.connection_url,
+            "folder_path": self.folder_path,
             "extra_options": dict(self.extra_options),
             "options": dict(self.options),
         }
@@ -524,7 +530,7 @@ class ConnectionConfig:
 
 
 SOURCE_EMOJIS: dict[str, str] = {
-    "docker": "🐳 ",
+    "docker": "",
     "azure": "",
 }
 
@@ -533,3 +539,13 @@ def get_source_emoji(source: str | None) -> str:
     if source is None:
         return ""
     return SOURCE_EMOJIS.get(source, "")
+
+
+def normalize_folder_path(path: str | None) -> str:
+    if not path:
+        return ""
+    if not isinstance(path, str):
+        path = str(path)
+    path = path.replace("\\", "/")
+    parts = [part.strip() for part in path.split("/") if part.strip()]
+    return "/".join(parts)

{sqlit_tui-1.2.4 → sqlit_tui-1.2.6}/sqlit/domains/connections/domain/passwords.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from sqlit.domains.connections.domain.config import ConnectionConfig
-from sqlit.domains.connections.providers.metadata import is_file_based
+from sqlit.domains.connections.providers.metadata import is_file_based, requires_auth
 
 
 def needs_db_password(config: ConnectionConfig) -> bool:
@@ -11,6 +11,9 @@ def needs_db_password(config: ConnectionConfig) -> bool:
     if is_file_based(config.db_type):
         return False
 
+    if not requires_auth(config.db_type):
+        return False
+
     auth_type = config.get_option("auth_type")
     if auth_type in ("ad_default", "ad_integrated", "windows"):
         return False

sqlit_tui-1.2.6/sqlit/domains/connections/providers/bigquery/adapter.py

@@ -0,0 +1,377 @@
+"""Google BigQuery adapter using google-cloud-bigquery DB-API."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Iterable
+
+from sqlit.domains.connections.providers.adapters.base import (
+    ColumnInfo,
+    CursorBasedAdapter,
+    IndexInfo,
+    SequenceInfo,
+    TableInfo,
+    TriggerInfo,
+)
+
+if TYPE_CHECKING:
+    from google.cloud import bigquery
+    from google.cloud.bigquery.dbapi import Connection as BigQueryConnection
+    from sqlit.domains.connections.domain.config import ConnectionConfig
+
+
+class BigQueryAdapter(CursorBasedAdapter):
+    """Adapter for Google BigQuery."""
+
+    @property
+    def name(self) -> str:
+        return "BigQuery"
+
+    @property
+    def install_extra(self) -> str:
+        return "bigquery"
+
+    @property
+    def install_package(self) -> str:
+        return "google-cloud-bigquery"
+
+    @property
+    def driver_import_names(self) -> tuple[str, ...]:
+        return ("google.cloud.bigquery", "google.cloud.bigquery.dbapi")
+
+    @property
+    def supports_multiple_databases(self) -> bool:
+        # BigQuery uses datasets as the equivalent of databases
+        return True
+
+    @property
+    def supports_stored_procedures(self) -> bool:
+        return True
+
+    @property
+    def supports_triggers(self) -> bool:
+        return False
+
+    @property
+    def supports_indexes(self) -> bool:
+        return False
+
+    @property
+    def supports_cross_database_queries(self) -> bool:
+        # BigQuery supports cross-dataset queries
+        return True
+
+    def apply_database_override(self, config: ConnectionConfig, database: str) -> ConnectionConfig:
+        """Apply a default dataset for unqualified queries."""
+        if not database:
+            return config
+        return config.with_endpoint(database=database)
+
+    @property
+    def system_databases(self) -> frozenset[str]:
+        return frozenset({"INFORMATION_SCHEMA"})
+
+    @property
+    def default_schema(self) -> str:
+        return ""
+
+    def _resolve_project_id(self, config: ConnectionConfig) -> str:
+        endpoint = config.tcp_endpoint
+        project_id = (endpoint.host if endpoint else "") or config.options.get("bigquery_project", "")
+        if project_id:
+            return project_id
+        return os.environ.get("GOOGLE_CLOUD_PROJECT") or os.environ.get("GCLOUD_PROJECT") or ""
+
+    def _resolve_default_dataset(self, config: ConnectionConfig) -> str | None:
+        endpoint = config.tcp_endpoint
+        if endpoint and endpoint.database:
+            return endpoint.database
+        dataset = config.options.get("bigquery_dataset")
+        return dataset if isinstance(dataset, str) and dataset else None
+
+    def _get_connection_job_config(self, conn: Any) -> Any | None:
+        return getattr(conn, "_sqlit_bq_job_config", None)
+
+    def _get_default_dataset_for_conn(self, conn: Any) -> str | None:
+        dataset = getattr(conn, "_sqlit_bq_default_dataset", None)
+        if isinstance(dataset, str) and dataset:
+            return dataset
+        return None
+
+    def _get_client(self, conn: Any) -> bigquery.Client | None:
+        client = getattr(conn, "client", None)
+        if client is not None:
+            return client
+        client = getattr(conn, "_sqlit_bq_client", None)
+        return client
+
+    def connect(self, config: ConnectionConfig) -> BigQueryConnection:
+        """Connect to Google BigQuery using the DB-API connector."""
+        bigquery = self._import_driver_module(
+            "google.cloud.bigquery",
+            driver_name=self.name,
+            extra_name=self.install_extra,
+            package_name=self.install_package,
+        )
+        dbapi = self._import_driver_module(
+            "google.cloud.bigquery.dbapi",
+            driver_name=self.name,
+            extra_name=self.install_extra,
+            package_name=self.install_package,
+        )
+
+        project_id = self._resolve_project_id(config)
+        location = config.options.get("bigquery_location", "US")
+        default_dataset = self._resolve_default_dataset(config)
+
+        credentials = None
+        client_options = None
+
+        # Check for emulator: either via env var or by detecting a port in config
+        # (BigQuery doesn't normally use TCP, so any port means emulator)
+        emulator_host = os.environ.get("BIGQUERY_EMULATOR_HOST")
+        endpoint = config.tcp_endpoint
+        if not emulator_host and endpoint and endpoint.port:
+            # Any port specified means we're connecting to an emulator
+            # Default to localhost if no explicit host for emulator
+            host = "localhost"
+            emulator_host = f"http://{host}:{endpoint.port}"
+
+        if emulator_host:
+            if not emulator_host.startswith("http"):
+                emulator_host = f"http://{emulator_host}"
+            from google.api_core.client_options import ClientOptions
+            from google.auth.credentials import AnonymousCredentials
+
+            client_options = ClientOptions(api_endpoint=emulator_host)
+            credentials = AnonymousCredentials()
+        else:
+            auth_method = config.options.get("bigquery_auth_method", "default")
+            if auth_method == "service_account":
+                credentials_path = config.options.get("bigquery_credentials_path")
+                if credentials_path:
+                    from google.oauth2 import service_account
+
+                    credentials = service_account.Credentials.from_service_account_file(credentials_path)
+
+        client_kwargs: dict[str, Any] = {}
+        if project_id:
+            client_kwargs["project"] = project_id
+        if location:
+            client_kwargs["location"] = location
+        if credentials:
+            client_kwargs["credentials"] = credentials
+        if client_options:
+            client_kwargs["client_options"] = client_options
+
+        client = bigquery.Client(**client_kwargs)
+
+        job_config = None
+        if default_dataset:
+            if "." in default_dataset:
+                dataset_project, dataset_id = default_dataset.split(".", 1)
+                dataset_ref = bigquery.DatasetReference(dataset_project, dataset_id)
+            elif client.project:
+                dataset_ref = bigquery.DatasetReference(client.project, default_dataset)
+            else:
+                dataset_ref = None
+            if dataset_ref is not None:
+                job_config = bigquery.QueryJobConfig(default_dataset=dataset_ref)
+                client.default_query_job_config = job_config
+
+        conn = dbapi.connect(client=client)
+        setattr(conn, "_sqlit_bq_client", client)
+        if default_dataset:
+            setattr(conn, "_sqlit_bq_default_dataset", default_dataset)
+        if job_config:
+            setattr(conn, "_sqlit_bq_job_config", job_config)
+
+        return conn
+
+    def execute_query(self, conn: Any, query: str, max_rows: int | None = None) -> tuple[list[str], list[tuple], bool]:
+        """Execute a query with optional default dataset configuration."""
+        cursor = conn.cursor()
+        job_config = self._get_connection_job_config(conn)
+        if job_config is not None:
+            cursor.execute(query, job_config=job_config)
+        else:
+            cursor.execute(query)
+
+        if cursor.description:
+            columns = [col[0] for col in cursor.description]
+            if max_rows is not None:
+                rows = cursor.fetchmany(max_rows + 1)
+                truncated = len(rows) > max_rows
+                if truncated:
+                    rows = rows[:max_rows]
+            else:
+                rows = cursor.fetchall()
+                truncated = False
+            return columns, [tuple(row) for row in rows], truncated
+        return [], [], False
+
+    def execute_non_query(self, conn: Any, query: str) -> int:
+        """Execute a non-query statement for BigQuery."""
+        cursor = conn.cursor()
+        job_config = self._get_connection_job_config(conn)
+        if job_config is not None:
+            cursor.execute(query, job_config=job_config)
+        else:
+            cursor.execute(query)
+
+        rowcount = int(getattr(cursor, "rowcount", -1) or -1)
+        commit = getattr(conn, "commit", None)
+        if callable(commit):
+            try:
+                commit()
+            except Exception:
+                pass
+        return rowcount
+
+    def _resolve_dataset(self, conn: Any, database: str | None, schema: str | None) -> str | None:
+        if database:
+            return database
+        if schema:
+            return schema
+        return self._get_default_dataset_for_conn(conn)
+
+    def _iter_datasets(self, client: bigquery.Client) -> Iterable[str]:
+        for dataset in client.list_datasets(project=client.project):
+            dataset_id = getattr(dataset, "dataset_id", None)
+            if isinstance(dataset_id, str) and dataset_id:
+                yield dataset_id
+
+    def _list_tables_for_dataset(
+        self,
+        client: bigquery.Client,
+        dataset_id: str,
+        table_types: set[str],
+    ) -> list[TableInfo]:
+        dataset_ref = dataset_id
+        if "." not in dataset_id and client.project:
+            dataset_ref = f"{client.project}.{dataset_id}"
+        tables: list[TableInfo] = []
+        for table in client.list_tables(dataset_ref):
+            table_type = getattr(table, "table_type", "")
+            if table_type in table_types:
+                tables.append((dataset_id, table.table_id))
+        return tables
+
+    def get_databases(self, conn: Any) -> list[str]:
+        """Get list of datasets from BigQuery."""
+        client = self._get_client(conn)
+        if client is None:
+            return []
+        return list(self._iter_datasets(client))
+
+    def get_tables(self, conn: Any, database: str | None = None) -> list[TableInfo]:
+        """Get list of tables."""
+        client = self._get_client(conn)
+        if client is None:
+            return []
+
+        dataset = self._resolve_dataset(conn, database, None)
+        table_types = {"TABLE"}
+
+        if dataset:
+            return self._list_tables_for_dataset(client, dataset, table_types)
+
+        tables: list[TableInfo] = []
+        for dataset_id in self._iter_datasets(client):
+            tables.extend(self._list_tables_for_dataset(client, dataset_id, table_types))
+        return tables
+
+    def get_views(self, conn: Any, database: str | None = None) -> list[TableInfo]:
+        """Get list of views."""
+        client = self._get_client(conn)
+        if client is None:
+            return []
+
+        dataset = self._resolve_dataset(conn, database, None)
+        table_types = {"VIEW", "MATERIALIZED_VIEW"}
+
+        if dataset:
+            return self._list_tables_for_dataset(client, dataset, table_types)
+
+        views: list[TableInfo] = []
+        for dataset_id in self._iter_datasets(client):
+            views.extend(self._list_tables_for_dataset(client, dataset_id, table_types))
+        return views
+
+    def get_columns(
+        self, conn: Any, table: str, database: str | None = None, schema: str | None = None
+    ) -> list[ColumnInfo]:
+        """Get columns for a table."""
+        client = self._get_client(conn)
+        if client is None:
+            return []
+
+        dataset = self._resolve_dataset(conn, database, schema)
+        if not dataset:
+            return []
+
+        if "." in dataset or not client.project:
+            table_ref = f"{dataset}.{table}"
+        else:
+            table_ref = f"{client.project}.{dataset}.{table}"
+        table_obj = client.get_table(table_ref)
+        return [
+            ColumnInfo(name=field.name, data_type=field.field_type, is_primary_key=False)
+            for field in table_obj.schema
+        ]
+
+    def get_procedures(self, conn: Any, database: str | None = None) -> list[str]:
+        """Get routines from BigQuery."""
+        client = self._get_client(conn)
+        if client is None:
+            return []
+
+        dataset = self._resolve_dataset(conn, database, None)
+        if not dataset:
+            return []
+
+        list_routines = getattr(client, "list_routines", None)
+        if not callable(list_routines):
+            return []
+
+        routine_dataset = dataset
+        if "." not in dataset and client.project:
+            routine_dataset = f"{client.project}.{dataset}"
+        routines = list_routines(routine_dataset)
+        names: list[str] = []
+        for routine in routines:
+            routine_id = getattr(routine, "routine_id", None)
+            if routine_id:
+                names.append(routine_id)
+                continue
+            reference = getattr(routine, "reference", None)
+            if reference and getattr(reference, "routine_id", None):
+                names.append(reference.routine_id)
+        return names
+
+    def get_indexes(self, conn: Any, database: str | None = None) -> list[IndexInfo]:
+        """BigQuery doesn't have traditional indexes."""
+        return []
+
+    def get_triggers(self, conn: Any, database: str | None = None) -> list[TriggerInfo]:
+        """BigQuery doesn't support triggers."""
+        return []
+
+    def get_sequences(self, conn: Any, database: str | None = None) -> list[SequenceInfo]:
+        """BigQuery doesn't support sequences."""
+        return []
+
+    def quote_identifier(self, name: str) -> str:
+        """Quote an identifier for BigQuery."""
+        return f"`{name}`"
+
+    def build_select_query(
+        self, table: str, limit: int, database: str | None = None, schema: str | None = None
+    ) -> str:
+        """Build SELECT query with LIMIT."""
+        dataset = database or schema
+        if dataset:
+            if "." in dataset:
+                return f"SELECT * FROM `{dataset}.{table}` LIMIT {limit}"
+            return f"SELECT * FROM `{dataset}`.`{table}` LIMIT {limit}"
+        return f"SELECT * FROM `{table}` LIMIT {limit}"