From 3149c2eafccf1e1a95e0378a105e8e42b74b28a1 Mon Sep 17 00:00:00 2001 From: Karthikeyan C Date: Mon, 1 Jul 2024 12:32:54 +0530 Subject: [PATCH 1/3] Stored procedures schema and introspection --- Cargo.lock | 1 + crates/configuration/src/introspection.rs | 17 ++ crates/configuration/src/version1.rs | 66 ++++- crates/ndc-sqlserver/Cargo.toml | 1 + crates/ndc-sqlserver/src/connector.rs | 2 +- crates/ndc-sqlserver/src/schema.rs | 262 +++++++++++++++++- crates/ndc-sqlserver/tests/common/database.rs | 6 +- .../tests/configuration_tests.rs | 10 + .../snapshots/schema_tests__get_schema.snap | 73 +++++ .../query-engine/metadata/src/metadata/mod.rs | 5 + .../src/metadata/stored_procedures.rs | 47 ++++ static/chinook-sqlserver.sql | 1 - static/configuration.json | 57 ++++ 13 files changed, 527 insertions(+), 21 deletions(-) create mode 100644 crates/query-engine/metadata/src/metadata/stored_procedures.rs diff --git a/Cargo.lock b/Cargo.lock index fefe7fe5..c4634b38 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1312,6 +1312,7 @@ dependencies = [ "serde", "serde_json", "similar-asserts", + "thiserror", "tiberius", "tokio", "tokio-util", diff --git a/crates/configuration/src/introspection.rs b/crates/configuration/src/introspection.rs index 993a1b70..0f6550cc 100644 --- a/crates/configuration/src/introspection.rs +++ b/crates/configuration/src/introspection.rs @@ -1,6 +1,23 @@ //! Configuration and state for our connector. use serde::Deserialize; +#[derive(Deserialize, Debug)] +pub struct IntrospectStoredProcedureArgument { + pub name: String, + pub r#type: String, + pub is_nullable: bool, + pub max_length: u8, + pub is_output: bool, +} + +#[derive(Deserialize, Debug)] +pub struct IntrospectStoredProcedure { + pub schema: String, + pub name: String, + #[serde(default)] + pub arguments: Vec, +} + #[derive(Deserialize, Debug)] pub struct IntrospectionTable { pub name: String, diff --git a/crates/configuration/src/version1.rs b/crates/configuration/src/version1.rs index 7697b24c..317ee224 100644 --- a/crates/configuration/src/version1.rs +++ b/crates/configuration/src/version1.rs @@ -7,7 +7,11 @@ use crate::secret::Secret; use crate::{uri, ConnectionUri}; use query_engine_metadata::metadata; +use query_engine_metadata::metadata::stored_procedures::{ + StoredProcedureArgumentInfo, StoredProcedureInfo, StoredProcedures, +}; use query_engine_metadata::metadata::{database, Nullable}; + use query_engine_metrics::metrics; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; @@ -17,8 +21,13 @@ use std::collections::BTreeSet; use thiserror::Error; use tiberius::Query; +// TODO(KC): Move the `table_configuration.sql` to the `static` folder present +// in the root of this repo. const TABLE_CONFIGURATION_QUERY: &str = include_str!("table_configuration.sql"); +const STORED_PROCS_CONFIGURATION_QUERY: &str = + include_str!("../../../static/introspect_stored_procedures.sql"); + const TYPES_QUERY: &str = "SELECT name FROM sys.types FOR JSON PATH"; const CURRENT_VERSION: u32 = 1; @@ -192,9 +201,17 @@ pub async fn configure( let type_names: Vec = serde_json::from_str(types_row.get(0).unwrap()).unwrap(); - metadata.comparison_operators = get_comparison_operators(&type_names).await; + metadata.comparison_operators = get_comparison_operators(&type_names); + + metadata.aggregate_functions = get_aggregate_functions(&type_names); - metadata.aggregate_functions = get_aggregate_functions(&type_names).await; + let stored_procedures_row = + select_first_row(&mssql_pool, STORED_PROCS_CONFIGURATION_QUERY).await; + + let stored_procedures: Vec = + serde_json::from_str(stored_procedures_row.get(0).unwrap()).unwrap(); + + metadata.stored_procedures = get_stored_procedures(stored_procedures); Ok(RawConfiguration { version: 1, @@ -208,9 +225,48 @@ struct TypeItem { name: database::ScalarType, } +fn get_stored_procedures( + introspected_stored_procedures: Vec, +) -> query_engine_metadata::metadata::stored_procedures::StoredProcedures { + let mut metadata_stored_procs = BTreeMap::new(); + for stored_procedure in introspected_stored_procedures.into_iter() { + //metadata_stored_procs.insert(stored_procedure.name, quer) + + let metadata_stored_procedure = StoredProcedureInfo { + name: stored_procedure.name.clone(), + schema: stored_procedure.schema, + arguments: stored_procedure + .arguments + .into_iter() + .map(|sp| -> (String, StoredProcedureArgumentInfo) { + // The first character is `@`, so, we skip it. + ( + sp.name.clone(), + StoredProcedureArgumentInfo { + name: sp.name, + r#type: query_engine_metadata::metadata::ScalarType(sp.r#type), + nullable: if sp.is_nullable { + Nullable::Nullable + } else { + Nullable::NonNullable + }, + is_output: sp.is_output, + description: None, + }, + ) + }) + .collect(), + returns: None, + description: None, + }; + metadata_stored_procs.insert(stored_procedure.name, metadata_stored_procedure); + } + StoredProcedures(metadata_stored_procs) +} + // we lookup all types in sys.types, then use our hardcoded ideas about each one to attach // aggregate functions -async fn get_aggregate_functions(type_names: &Vec) -> database::AggregateFunctions { +fn get_aggregate_functions(type_names: &Vec) -> database::AggregateFunctions { let mut aggregate_functions = BTreeMap::new(); for type_name in type_names { @@ -337,7 +393,7 @@ fn get_aggregate_functions_for_type( // we lookup all types in sys.types, then use our hardcoded ideas about each one to attach // comparison operators -async fn get_comparison_operators(type_names: &Vec) -> database::ComparisonOperators { +fn get_comparison_operators(type_names: &Vec) -> database::ComparisonOperators { let mut comparison_operators = BTreeMap::new(); for type_name in type_names { @@ -579,6 +635,8 @@ pub fn occurring_scalar_types(metadata: &metadata::Metadata) -> BTreeSet Result, connector::SchemaError> { - schema::get_schema(configuration).await.map(Into::into) + schema::get_schema(configuration).map(Into::into) } /// Explain a query by creating an execution plan diff --git a/crates/ndc-sqlserver/src/schema.rs b/crates/ndc-sqlserver/src/schema.rs index 40a0a9e1..a5f3ec0d 100644 --- a/crates/ndc-sqlserver/src/schema.rs +++ b/crates/ndc-sqlserver/src/schema.rs @@ -11,20 +11,30 @@ use ndc_sdk::models::TypeRepresentation; use query_engine_metadata::metadata; use ndc_sqlserver_configuration as configuration; +use query_engine_metadata::metadata::stored_procedures::{ + StoredProcedureArgumentInfo, StoredProcedures, +}; +use thiserror::Error; + +#[derive(Error, Debug)] +enum SchemaError { + #[error("Trying to create duplicate object with name: {0}")] + DuplicateObject(String), +} -/// Extract the models::Type representation of a readonly column. -fn column_to_type(column: &metadata::ColumnInfo) -> models::Type { - match &column.nullable { - metadata::Nullable::NonNullable => models::Type::Named { - name: column.r#type.0.clone(), - }, +fn scalar_type_to_type(type_name: String, nullability: &metadata::Nullable) -> models::Type { + match nullability { + metadata::Nullable::NonNullable => models::Type::Named { name: type_name }, metadata::Nullable::Nullable => models::Type::Nullable { - underlying_type: Box::new(models::Type::Named { - name: column.r#type.0.clone(), - }), + underlying_type: Box::new(models::Type::Named { name: type_name }), }, } } + +/// Extract the models::Type representation of a readonly column. +fn column_to_type(column: &metadata::ColumnInfo) -> models::Type { + scalar_type_to_type(column.r#type.0.clone(), &column.nullable) +} /// Gets the schema of the native queries. /// Each native query creates an object named as the name /// of the native query with the fields of the object corresponding @@ -201,11 +211,80 @@ fn get_native_mutations_schema( Ok(native_mutations) } +fn get_stored_procedure_argument( + stored_procedure_arg_info: StoredProcedureArgumentInfo, +) -> ndc_sdk::models::ArgumentInfo { + let argument_type = scalar_type_to_type( + stored_procedure_arg_info.r#type.0, + &stored_procedure_arg_info.nullable, + ); + models::ArgumentInfo { + description: stored_procedure_arg_info.description, + argument_type, + } +} + +fn get_stored_procedures_schema( + stored_procedures: &StoredProcedures, + object_types: &mut BTreeMap, +) -> Result, connector::SchemaError> { + let mut stored_procedures_schema = Vec::new(); + + for (proc_name, proc_info) in stored_procedures.0.iter() { + if let Some(returns) = &proc_info.returns { + let proc_args: BTreeMap = proc_info + .arguments + .iter() + .map(|(arg_name, arg_info)| { + ( + arg_name.clone(), + get_stored_procedure_argument(arg_info.clone()), + ) + }) + .collect(); + let stored_proc_object_type = models::ObjectType { + description: proc_info.description.clone(), + fields: BTreeMap::from_iter(returns.iter().map(|(column_name, column)| { + ( + column_name.clone(), + models::ObjectField { + description: column.description.clone(), + r#type: column_to_type(column), + }, + ) + })), + }; + let object_type_name = format!("{proc_name}_response"); + if object_types + .insert(object_type_name.clone(), stored_proc_object_type) + .is_some() + { + return Err(connector::SchemaError::Other(Box::new( + SchemaError::DuplicateObject(object_type_name), + ))); + }; + + let stored_proc_schema = models::ProcedureInfo { + name: proc_name.to_string(), + description: proc_info.description.clone(), + arguments: proc_args, + result_type: models::Type::Array { + element_type: Box::new(models::Type::Named { + name: object_type_name, + }), + }, + }; + stored_procedures_schema.push(stored_proc_schema); + } + } + Ok(stored_procedures_schema) +} + /// Get the connector's schema. /// /// This function implements the [schema endpoint](https://hasura.github.io/ndc-spec/specification/schema/index.html) /// from the NDC specification. -pub async fn get_schema( +pub fn get_schema( configuration::Configuration { metadata, .. }: &configuration::Configuration, ) -> Result { let mut scalar_types: BTreeMap = @@ -344,7 +423,14 @@ pub async fn get_schema( let mut collections = tables; collections.extend(native_queries); - let procedures = native_mutations; + let mut procedures = Vec::new(); + + procedures.extend(native_mutations); + + let stored_procedures_schema = + get_stored_procedures_schema(&metadata.stored_procedures, &mut object_types)?; + + procedures.extend(stored_procedures_schema); Ok(models::SchemaResponse { collections, @@ -357,6 +443,7 @@ pub async fn get_schema( #[cfg(test)] mod tests { + use ndc_sdk::models::{ObjectField, ObjectType, ProcedureInfo}; use query_engine_metadata::metadata::{ parse_native_query, ColumnInfo, NativeMutationColumnInfo, NativeMutationInfo, @@ -499,4 +586,157 @@ mod tests { assert_eq!(object_types, expected_object_types); } + + mod stored_procedures { + use super::*; + + #[test] + fn test_stored_procedure_without_returns() { + let stored_proc_config = r#" + { + "GetCustomerDetailsWithTotalPurchases": { + "name": "GetCustomerDetailsWithTotalPurchases", + "schema": "dbo", + "arguments": { + "CustomerId": { + "name": "CustomerId", + "type": "int", + "nullable": "nullable", + "isOutput": false, + "description": null + }, + "Phone": { + "name": "Phone", + "type": "varchar", + "nullable": "nullable", + "isOutput": false, + "description": null + } + }, + "returns": null, + "description": null + } + }"#; + let stored_procedures: StoredProcedures = + serde_json::from_str(stored_proc_config).unwrap(); + + let mut object_types = BTreeMap::new(); + + let schema = + get_stored_procedures_schema(&stored_procedures, &mut object_types).unwrap(); + + // Check that we have skipped generating schema for a stored procedure + // without a return type. + assert!(schema.is_empty()); + assert!(object_types.is_empty()); + } + + #[test] + fn test_stored_procedure_with_returns() { + let stored_proc_config = r#" + { + "GetCustomerDetailsWithTotalPurchases": { + "name": "GetCustomerDetailsWithTotalPurchases", + "schema": "dbo", + "arguments": { + "CustomerId": { + "name": "CustomerId", + "type": "int", + "nullable": "nonNullable", + "isOutput": false, + "description": null + }, + "Phone": { + "name": "Phone", + "type": "varchar", + "nullable": "nullable", + "isOutput": false, + "description": null + } + }, + "returns": { + "result": { + "name": "result", + "type": "int", + "description": null, + "nullable": "nonNullable" + } + }, + "description": null + } + }"#; + let stored_procedures: StoredProcedures = + serde_json::from_str(stored_proc_config).unwrap(); + + let mut object_types = BTreeMap::new(); + + let schema = + get_stored_procedures_schema(&stored_procedures, &mut object_types).unwrap(); + + let proc_schema = schema.first().unwrap(); + + let mut expected_args = BTreeMap::new(); + + expected_args.insert( + "CustomerId".to_string(), + models::ArgumentInfo { + description: None, + argument_type: models::Type::Named { + name: "int".to_string(), + }, + }, + ); + + expected_args.insert( + "Phone".to_string(), + models::ArgumentInfo { + description: None, + argument_type: models::Type::Nullable { + underlying_type: Box::new(models::Type::Named { + name: "varchar".to_string(), + }), + }, + }, + ); + + let expected_result_type = models::Type::Array { + element_type: Box::new(models::Type::Named { + name: "GetCustomerDetailsWithTotalPurchases_response".to_string(), + }), + }; + + // Check the `ProcedureInfo` generated. + assert_eq!( + proc_schema, + &ProcedureInfo { + name: "GetCustomerDetailsWithTotalPurchases".to_string(), + description: None, + arguments: expected_args, + result_type: expected_result_type + } + ); + + let mut expected_obj_type_fields = BTreeMap::new(); + + expected_obj_type_fields.insert( + "result".to_string(), + models::ObjectField { + description: None, + r#type: (models::Type::Named { + name: "int".to_string(), + }), + }, + ); + + assert_eq!( + object_types + .get("GetCustomerDetailsWithTotalPurchases_response") + .unwrap(), + &models::ObjectType { + description: None, + fields: expected_obj_type_fields + } + ); + } + } } diff --git a/crates/ndc-sqlserver/tests/common/database.rs b/crates/ndc-sqlserver/tests/common/database.rs index fc986829..1e0657e3 100644 --- a/crates/ndc-sqlserver/tests/common/database.rs +++ b/crates/ndc-sqlserver/tests/common/database.rs @@ -68,10 +68,10 @@ async fn create_database_copy( ) -> MSSQLDatabaseConfig { let mut connection = create_mssql_connection(&connection_config).await; - let create_db_sql = format!("CREATE DATABASE \"{new_db_name}\";"); + let create_db_sql = format!("CREATE DATABASE [{new_db_name}]"); connection - .simple_query(create_db_sql.as_str()) + .execute(create_db_sql.as_str(), &[]) .await .unwrap(); @@ -86,8 +86,6 @@ pub async fn drop_database(db_name: &str, connection_uri: String) -> Result<(), let tcp = TcpStream::connect(config.get_addr()).await.unwrap(); tcp.set_nodelay(true).unwrap(); - println!("Connection config is {config:#?}"); - let mut connection = Client::connect(config, tcp.compat_write()).await.unwrap(); let drop_db_sql = format!("USE master; ALTER DATABASE \"{db_name}\" SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE \"{db_name}\" "); diff --git a/crates/ndc-sqlserver/tests/configuration_tests.rs b/crates/ndc-sqlserver/tests/configuration_tests.rs index d6e8fb9a..02800eca 100644 --- a/crates/ndc-sqlserver/tests/configuration_tests.rs +++ b/crates/ndc-sqlserver/tests/configuration_tests.rs @@ -6,6 +6,7 @@ use configuration::environment::Variable; use ndc_sqlserver_configuration as configuration; use ndc_sqlserver_configuration::secret; +use query_engine_metadata::metadata::stored_procedures::StoredProcedures; use query_engine_metadata::metadata::{NativeMutations, NativeQueries}; use serde::de::DeserializeOwned; use serde_json::from_value; @@ -57,8 +58,17 @@ pub async fn configure_is_idempotent( let native_mutations_config: NativeMutations = read_configuration_as("static/chinook-native-mutations.json").unwrap(); + // Although, the introspection of the database includes the stored procedures + // it doesn't include the return type of the stored procedures, this is because + // stored procedures don't have a return type tied to them. So, we depend on the + // user to provide us with the return type of each stored procedure. So, in this + // case, we include the stored procedures with their return types artificially. + let stored_procedures_config: StoredProcedures = + read_configuration_as("static/chinook-stored-procedures.json").unwrap(); + actual.metadata.native_mutations = native_mutations_config; actual.metadata.native_queries = native_queries_config; + actual.metadata.stored_procedures = stored_procedures_config; let actual_value = serde_json::to_value(actual).expect("serde_json::to_value"); diff --git a/crates/ndc-sqlserver/tests/snapshots/schema_tests__get_schema.snap b/crates/ndc-sqlserver/tests/snapshots/schema_tests__get_schema.snap index 3926a459..ed04fbe2 100644 --- a/crates/ndc-sqlserver/tests/snapshots/schema_tests__get_schema.snap +++ b/crates/ndc-sqlserver/tests/snapshots/schema_tests__get_schema.snap @@ -2984,6 +2984,28 @@ expression: result } } }, + "GetCustomerDetailsWithTotalPurchases_response": { + "fields": { + "CustomerId": { + "type": { + "type": "named", + "name": "int" + } + }, + "Phone": { + "type": { + "type": "named", + "name": "varchar" + } + }, + "TotalPurchases": { + "type": { + "type": "named", + "name": "int" + } + } + } + }, "Invoice": { "fields": { "BillingAddress": { @@ -3145,6 +3167,19 @@ expression: result } } }, + "ReturnOne_response": { + "fields": { + "result": { + "type": { + "type": "nullable", + "underlying_type": { + "type": "named", + "name": "int" + } + } + } + } + }, "Track": { "fields": { "AlbumId": { @@ -3800,6 +3835,44 @@ expression: result "type": "named", "name": "insert_artist_and_return_id_response" } + }, + { + "name": "GetCustomerDetailsWithTotalPurchases", + "arguments": { + "CustomerId": { + "type": { + "type": "named", + "name": "int" + } + }, + "Phone": { + "type": { + "type": "nullable", + "underlying_type": { + "type": "named", + "name": "varchar" + } + } + } + }, + "result_type": { + "type": "array", + "element_type": { + "type": "named", + "name": "GetCustomerDetailsWithTotalPurchases_response" + } + } + }, + { + "name": "ReturnOne", + "arguments": {}, + "result_type": { + "type": "array", + "element_type": { + "type": "named", + "name": "ReturnOne_response" + } + } } ] } diff --git a/crates/query-engine/metadata/src/metadata/mod.rs b/crates/query-engine/metadata/src/metadata/mod.rs index b53d9824..d6c9593e 100644 --- a/crates/query-engine/metadata/src/metadata/mod.rs +++ b/crates/query-engine/metadata/src/metadata/mod.rs @@ -2,6 +2,7 @@ pub mod database; pub mod native_queries; +pub mod stored_procedures; // re-export without modules pub use database::*; @@ -10,6 +11,8 @@ pub use native_queries::*; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; +use self::stored_procedures::StoredProcedures; + /// Metadata information. #[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema, Clone)] #[serde(rename_all = "camelCase")] @@ -24,4 +27,6 @@ pub struct Metadata { pub aggregate_functions: AggregateFunctions, #[serde(default)] pub comparison_operators: ComparisonOperators, + #[serde(default)] + pub stored_procedures: StoredProcedures, } diff --git a/crates/query-engine/metadata/src/metadata/stored_procedures.rs b/crates/query-engine/metadata/src/metadata/stored_procedures.rs new file mode 100644 index 00000000..0352daca --- /dev/null +++ b/crates/query-engine/metadata/src/metadata/stored_procedures.rs @@ -0,0 +1,47 @@ +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; + +use super::{ColumnInfo, Nullable, ScalarType}; + +/// Information about a stored procedure's argument +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct StoredProcedureArgumentInfo { + /// Name of the argument + pub name: String, + /// Type of the argument + pub r#type: ScalarType, + /// Nullability of the argument + pub nullable: Nullable, + /// Indicator, if the argument is an `OUTPUT` argument + /// of the stored procedure. + #[serde(default)] + pub is_output: bool, + #[serde(default)] + pub description: Option, +} + +/// Information about a stored procedure. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct StoredProcedureInfo { + /// Name of the stored procedure + pub name: String, + /// Name of the stored procedure's schema. + pub schema: String, + /// Arguments to the stored procedure + pub arguments: BTreeMap, + #[serde(default)] + /// Columns returned by the stored procedure. + /// This is set as optional because during the introspection, + /// we won't know the return type of the stored procedure. We + /// expect the user to fill this detail manually. + pub returns: Option>, + /// Description of the stored procedure. + pub description: Option, +} + +/// Metadata information of the stored procedures. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +pub struct StoredProcedures(pub BTreeMap); diff --git a/static/chinook-sqlserver.sql b/static/chinook-sqlserver.sql index 16bc7371..aa35880c 100644 --- a/static/chinook-sqlserver.sql +++ b/static/chinook-sqlserver.sql @@ -268,7 +268,6 @@ GO CREATE INDEX [IFK_TrackMediaTypeId] ON [dbo].[Track] ([MediaTypeId]); GO - /******************************************************************************* Populate Tables ********************************************************************************/ diff --git a/static/configuration.json b/static/configuration.json index a2fb4e5e..98f2d36d 100644 --- a/static/configuration.json +++ b/static/configuration.json @@ -843,6 +843,63 @@ "description": null } }, + "storedProcedures": { + "GetCustomerDetailsWithTotalPurchases": { + "name": "GetCustomerDetailsWithTotalPurchases", + "schema": "dbo", + "arguments": { + "CustomerId": { + "name": "CustomerId", + "type": "int", + "nullable": "nullable", + "isOutput": false, + "description": null + }, + "Phone": { + "name": "Phone", + "type": "varchar", + "nullable": "nullable", + "isOutput": false, + "description": null + } + }, + "returns": { + "CustomerId": { + "name": "CustomerId", + "type": "int", + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": "varchar", + "nullable": "nonNullable", + "description": null + }, + "TotalPurchases": { + "name": "TotalPurchases", + "type": "int", + "nullable": "nonNullable", + "description": null + } + }, + "description": null + }, + "ReturnOne": { + "name": "ReturnOne", + "schema": "dbo", + "arguments": {}, + "returns": { + "result": { + "name": "result", + "type": "int", + "description": null, + "nullable": "nullable" + } + }, + "description": null + } + }, "aggregateFunctions": { "bigint": { "APPROX_COUNT_DISTINCT": { From bacd28b6555c9e650dddcc6e99feff130fa3b962 Mon Sep 17 00:00:00 2001 From: Karthikeyan C Date: Mon, 1 Jul 2024 13:30:38 +0530 Subject: [PATCH 2/3] add a comment about adding native mutation types --- crates/configuration/src/version1.rs | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/crates/configuration/src/version1.rs b/crates/configuration/src/version1.rs index 317ee224..1e28a222 100644 --- a/crates/configuration/src/version1.rs +++ b/crates/configuration/src/version1.rs @@ -635,7 +635,20 @@ pub fn occurring_scalar_types(metadata: &metadata::Metadata) -> BTreeSet BTreeSet>() From 4fced7f51518b8d9c26fdaf4fb169da1e01fd407 Mon Sep 17 00:00:00 2001 From: Karthikeyan C Date: Mon, 1 Jul 2024 13:35:19 +0530 Subject: [PATCH 3/3] remove stray comments --- crates/configuration/src/version1.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/crates/configuration/src/version1.rs b/crates/configuration/src/version1.rs index 1e28a222..1cdaee08 100644 --- a/crates/configuration/src/version1.rs +++ b/crates/configuration/src/version1.rs @@ -230,8 +230,6 @@ fn get_stored_procedures( ) -> query_engine_metadata::metadata::stored_procedures::StoredProcedures { let mut metadata_stored_procs = BTreeMap::new(); for stored_procedure in introspected_stored_procedures.into_iter() { - //metadata_stored_procs.insert(stored_procedure.name, quer) - let metadata_stored_procedure = StoredProcedureInfo { name: stored_procedure.name.clone(), schema: stored_procedure.schema, @@ -239,7 +237,6 @@ fn get_stored_procedures( .arguments .into_iter() .map(|sp| -> (String, StoredProcedureArgumentInfo) { - // The first character is `@`, so, we skip it. ( sp.name.clone(), StoredProcedureArgumentInfo {