Meta endpoints (#351)

Author: matthewmturner

.claude/settings.local.json

@@ -20,7 +20,10 @@
       "Bash(RUST_LOG=debug cargo run:*)",
       "Bash(cat:*)",
       "Bash(cargo clippy:*)",
-      "Bash(test:*)"
+      "Bash(find:*)",
+      "WebFetch(domain:arrow.apache.org)",
+      "Bash(timeout 90 cargo test:*)",
+      "Bash(test:*)",
       "WebFetch(domain:github.com)",
       "Bash(ls:*)",
       "Bash(grep:*)"

.github/actions/setup-rust/action.yml

@@ -42,6 +42,6 @@ runs:
     - name: Install Cargo tools
       shell: bash
       run: |
-        cargo install taplo-cli --locked
-        cargo install just
-        cargo install --version 0.8.0 cargo-machete --locked
+        command -v taplo &> /dev/null || cargo install taplo-cli --locked
+        command -v just &> /dev/null || cargo install just
+        command -v cargo-machete &> /dev/null || cargo install --version 0.8.0 cargo-machete --locked

crates/datafusion-app/src/flightsql.rs

@@ -19,7 +19,10 @@ use std::sync::Arc;
 
 use arrow_flight::{
     decode::FlightRecordBatchStream,
-    sql::{client::FlightSqlServiceClient, CommandGetDbSchemas, CommandGetTables},
+    sql::{
+        client::FlightSqlServiceClient, CommandGetDbSchemas, CommandGetTables,
+        CommandGetXdbcTypeInfo,
+    },
     FlightInfo,
 };
 #[cfg(feature = "flightsql")]
@@ -287,6 +290,62 @@ impl FlightSQLContext {
         }
     }
 
+    pub async fn get_table_types_flight_info(&self) -> DFResult<FlightInfo> {
+        let client = Arc::clone(&self.client);
+        let mut guard = client.lock().await;
+        if let Some(client) = guard.as_mut() {
+            client
+                .get_table_types()
+                .await
+                .map_err(|e| DataFusionError::ArrowError(Box::new(e), None))
+        } else {
+            Err(DataFusionError::External(
+                "No FlightSQL client configured.  Add one in `~/.config/dft/config.toml`".into(),
+            ))
+        }
+    }
+
+    pub async fn get_sql_info_flight_info(&self, info: Option<Vec<u32>>) -> DFResult<FlightInfo> {
+        let client = Arc::clone(&self.client);
+        let mut guard = client.lock().await;
+        if let Some(client) = guard.as_mut() {
+            use arrow_flight::sql::SqlInfo;
+            // Convert u32 IDs to SqlInfo enum variants if needed
+            let sql_info_list: Vec<SqlInfo> = info
+                .unwrap_or_default()
+                .into_iter()
+                .filter_map(|id| SqlInfo::try_from(id as i32).ok())
+                .collect();
+            client
+                .get_sql_info(sql_info_list)
+                .await
+                .map_err(|e| DataFusionError::ArrowError(Box::new(e), None))
+        } else {
+            Err(DataFusionError::External(
+                "No FlightSQL client configured.  Add one in `~/.config/dft/config.toml`".into(),
+            ))
+        }
+    }
+
+    pub async fn get_xdbc_type_info_flight_info(
+        &self,
+        data_type: Option<i32>,
+    ) -> DFResult<FlightInfo> {
+        let client = Arc::clone(&self.client);
+        let mut guard = client.lock().await;
+        if let Some(client) = guard.as_mut() {
+            let cmd = CommandGetXdbcTypeInfo { data_type };
+            client
+                .get_xdbc_type_info(cmd)
+                .await
+                .map_err(|e| DataFusionError::ArrowError(Box::new(e), None))
+        } else {
+            Err(DataFusionError::External(
+                "No FlightSQL client configured.  Add one in `~/.config/dft/config.toml`".into(),
+            ))
+        }
+    }
+
     pub async fn do_get(&self, flight_info: FlightInfo) -> DFResult<Vec<FlightRecordBatchStream>> {
         let client = Arc::clone(&self.client);
         let mut guard = client.lock().await;

docs/cli.md

@@ -38,6 +38,17 @@ dft flightsql get-db-schemas --db-schema-filter-pattern "my%"
 # List tables in a schema
 dft flightsql get-tables --catalog mycatalog --db-schema-filter-pattern myschema
 dft flightsql get-tables --table-name-filter-pattern "table" --table-types VIEW
+
+# Get supported table types
+dft flightsql get-table-types
+
+# Get SQL capabilities and server information
+dft flightsql get-sql-info
+dft flightsql get-sql-info --info 1 --info 2  # Query specific info IDs
+
+# Get data type information (XDBC/ODBC type metadata)
+dft flightsql get-xdbc-type-info
+dft flightsql get-xdbc-type-info --data-type 4  # Filter by specific SQL data type
 ```
 
 ## Auth

docs/flightsql_server.md

@@ -16,10 +16,23 @@ dft serve-flightsql --run-ddl
 
 The server implements the FlightSQL protocol, providing:
 
-- SQL query execution
-- Schema fetching (TODO)
-- Prepared statements (TODO)
-- Catalog browsing (TODO)
+### Core Query Execution
+- **SQL query execution** - Execute SQL statements via `CommandStatementQuery`
+- **Prepared statements** - Create, execute, and close prepared statements for improved performance
+  - `ActionCreatePreparedStatement` - Parse and prepare SQL statements
+  - `ActionClosePreparedStatement` - Release prepared statement resources
+  - `CommandPreparedStatementQuery` - Execute prepared statements
+
+### Metadata Discovery
+- **Catalog browsing** - Discover database structure and metadata
+  - `CommandGetCatalogs` - List available catalogs
+  - `CommandGetDbSchemas` - List schemas with optional filtering
+  - `CommandGetTables` - List tables with filtering by catalog, schema, name pattern, and type
+  - `CommandGetTableTypes` - Get supported table types (TABLE, VIEW, etc.)
+
+### Server Capabilities
+- **SQL information** - Query server capabilities and version information via `CommandGetSqlInfo`
+- **Type metadata** - Get XDBC/ODBC type information via `CommandGetXdbcTypeInfo` for understanding supported data types
 
 ## Client Connections (TODO - Test this)
 
@@ -54,10 +67,19 @@ server_metrics_addr = "0.0.0.0:9000"
 ```
 
 Available metrics include:
-- Query execution time
-- Active connections
-- Errors by type
-- Memory usage
+- Query execution time (by endpoint)
+  - `get_flight_info_latency_ms` - Flight info request latency
+  - `do_get_fallback_latency_ms` - Data fetch latency
+  - `get_flight_info_table_types_latency_ms` - Table types metadata latency
+  - `get_flight_info_sql_info_latency_ms` - SQL info metadata latency
+  - `get_flight_info_xdbc_type_info_latency_ms` - Type info metadata latency
+  - `do_action_create_prepared_statement_latency_ms` - Prepared statement creation latency
+  - `do_action_close_prepared_statement_latency_ms` - Prepared statement cleanup latency
+  - `get_flight_info_prepared_statement_latency_ms` - Prepared statement flight info latency
+  - `do_get_prepared_statement_latency_ms` - Prepared statement execution latency
+- Active prepared statements (`prepared_statements_active` gauge)
+- Request counts by endpoint
+- Observability request details (when enabled) stored in `dft.observability_requests` table
 
 ## Configuration
 

src/args.rs

@@ -171,6 +171,20 @@ pub enum FlightSqlCommand {
         #[clap(long)]
         table_types: Option<Vec<String>>,
     },
+    /// Executes `CommandGetTableTypes` and `DoGet` to return supported table types
+    GetTableTypes,
+    /// Executes `CommandGetSqlInfo` and `DoGet` to return server SQL capabilities
+    GetSqlInfo {
+        /// Specific SQL info IDs to retrieve (if not provided, returns all)
+        #[clap(long)]
+        info: Option<Vec<u32>>,
+    },
+    /// Executes `CommandGetXdbcTypeInfo` and `DoGet` to return type information
+    GetXdbcTypeInfo {
+        /// Optional data type to filter by
+        #[clap(long)]
+        data_type: Option<i32>,
+    },
 }
 
 #[derive(Clone, Debug, Subcommand)]

src/cli/mod.rs

@@ -155,6 +155,51 @@ impl CliApp {
                 self.print_any_stream(flight_batch_stream).await;
                 Ok(())
             }
+            FlightSqlCommand::GetTableTypes => {
+                let flight_info = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .get_table_types_flight_info()
+                    .await?;
+                let streams = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .do_get(flight_info)
+                    .await?;
+                let flight_batch_stream = stream::select_all(streams);
+                self.print_any_stream(flight_batch_stream).await;
+                Ok(())
+            }
+            FlightSqlCommand::GetSqlInfo { info } => {
+                let flight_info = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .get_sql_info_flight_info(info)
+                    .await?;
+                let streams = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .do_get(flight_info)
+                    .await?;
+                let flight_batch_stream = stream::select_all(streams);
+                self.print_any_stream(flight_batch_stream).await;
+                Ok(())
+            }
+            FlightSqlCommand::GetXdbcTypeInfo { data_type } => {
+                let flight_info = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .get_xdbc_type_info_flight_info(data_type)
+                    .await?;
+                let streams = self
+                    .app_execution
+                    .flightsql_ctx()
+                    .do_get(flight_info)
+                    .await?;
+                let flight_batch_stream = stream::select_all(streams);
+                self.print_any_stream(flight_batch_stream).await;
+                Ok(())
+            }
         }
     }