diff --git a/Cargo.lock b/Cargo.lock index 6fed1dd26..e29924ced 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2112,6 +2112,9 @@ dependencies = [ [[package]] name = "query-engine-metadata" version = "0.8.0" +dependencies = [ + "ref-cast", +] [[package]] name = "query-engine-sql" @@ -2135,6 +2138,7 @@ dependencies = [ "nonempty", "query-engine-metadata", "query-engine-sql", + "ref-cast", "serde_json", "sqlformat", "thiserror", @@ -2199,6 +2203,26 @@ dependencies = [ "bitflags 2.5.0", ] +[[package]] +name = "ref-cast" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931" +dependencies = [ + "ref-cast-impl", +] + +[[package]] +name = "ref-cast-impl" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.66", +] + [[package]] name = "regex" version = "1.10.5" diff --git a/Cargo.toml b/Cargo.toml index 0beecb1db..9dbf94a0a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -51,6 +51,7 @@ multimap = "0.9" nonempty = "0.10" percent-encoding = "2" prometheus = "0.13" +ref-cast = "1" reqwest = "0.11" schemars = "0.8" serde = "1" diff --git a/benchmarks/component/docker-compose.yaml b/benchmarks/component/docker-compose.yaml index faed0b86c..1597322b2 100644 --- a/benchmarks/component/docker-compose.yaml +++ b/benchmarks/component/docker-compose.yaml @@ -59,7 +59,7 @@ services: OTEL_TRACES_SAMPLER: "always_off" volumes: - type: bind - source: ../../static/postgres/v3-chinook-ndc-metadata + source: ../../static/postgres/v5-configuration target: /etc/connector read_only: true healthcheck: diff --git a/benchmarks/component/start.sh b/benchmarks/component/start.sh index afa026e6c..96ab86dda 100755 --- a/benchmarks/component/start.sh +++ b/benchmarks/component/start.sh @@ -36,7 +36,7 @@ CONNECTION_URI="postgresql://postgres:password@${POSTGRESQL_SOCKET}" \ OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://localhost:4317' \ OTEL_SERVICE_NAME='ndc-postgres' \ cargo run -p ndc-postgres --quiet --release -- \ - serve --configuration='../../static/postgres/v3-chinook-ndc-metadata' \ + serve --configuration='../../static/postgres/v5-configuration' \ >& agent.log & AGENT_PID=$! echo "$AGENT_PID" > ./agent.pid diff --git a/changelog.md b/changelog.md index d8a84a01d..deb3e0345 100644 --- a/changelog.md +++ b/changelog.md @@ -4,6 +4,9 @@ ### Added +- Introduce configuration version "v5". + [#522](https://github.com/hasura/ndc-postgres/pull/522) + ### Changed ### Fixed diff --git a/crates/cli/src/native_operations.rs b/crates/cli/src/native_operations.rs index ddef6f0dc..b3456afe8 100644 --- a/crates/cli/src/native_operations.rs +++ b/crates/cli/src/native_operations.rs @@ -88,6 +88,17 @@ async fn list(context: Context) -> anyhow::Result<()> { println!("- {}", native_operation.0); } } + configuration::ParsedConfiguration::Version5(ref mut configuration) => { + let operations = &configuration.metadata.native_operations; + println!("Native Queries:"); + for native_operation in &operations.queries.0 { + println!("- {}", native_operation.0); + } + println!("Native Mutations:"); + for native_operation in &operations.mutations.0 { + println!("- {}", native_operation.0); + } + } }; Ok(()) } @@ -157,7 +168,70 @@ async fn create( { entry.insert(new_native_operation); } else { - anyhow::bail!("A Native Operation with the name '{}' already exists. To override, use the --override flag.", name); + anyhow::bail!("A Native Operation with the name '{name}' already exists. To override, use the --override flag."); + } + } + } + } + configuration::ParsedConfiguration::Version5(ref mut configuration) => { + let connection_string = configuration.get_connection_uri()?; + + let kind = match kind { + configuration::version4::native_operations::Kind::Query => { + configuration::version5::native_operations::Kind::Query + } + configuration::version4::native_operations::Kind::Mutation => { + configuration::version5::native_operations::Kind::Mutation + } + }; + + let new_native_operation = configuration::version5::native_operations::create( + configuration, + &connection_string, + &operation_path, + &file_contents, + ) + .await?; + + // Add the new native operation to the configuration. + match override_entry { + Override::Yes => match kind { + configuration::version5::native_operations::Kind::Query => { + configuration + .metadata + .native_operations + .queries + .0 + .insert(name, new_native_operation); + } + configuration::version5::native_operations::Kind::Mutation => { + configuration + .metadata + .native_operations + .mutations + .0 + .insert(name, new_native_operation); + } + }, + Override::No => { + // Only insert if vacant. + if let std::collections::btree_map::Entry::Vacant(entry) = match kind { + configuration::version5::native_operations::Kind::Query => configuration + .metadata + .native_operations + .queries + .0 + .entry(name.clone()), + configuration::version5::native_operations::Kind::Mutation => configuration + .metadata + .native_operations + .mutations + .0 + .entry(name.clone()), + } { + entry.insert(new_native_operation); + } else { + anyhow::bail!("A Native Operation with the name '{name}' already exists. To override, use the --override flag."); } } } @@ -224,6 +298,43 @@ async fn delete( } } } + configuration::ParsedConfiguration::Version5(ref mut configuration) => { + // Delete if exists and is of the same type, error if not. + match kind { + Kind::Mutation => { + match configuration + .metadata + .native_operations + .mutations + .0 + .entry(name.clone()) + { + std::collections::btree_map::Entry::Occupied(entry) => { + entry.remove_entry(); + } + std::collections::btree_map::Entry::Vacant(_) => { + anyhow::bail!(error_message_not_exist); + } + } + } + Kind::Query => { + match configuration + .metadata + .native_operations + .queries + .0 + .entry(name.clone()) + { + std::collections::btree_map::Entry::Occupied(entry) => { + entry.remove_entry(); + } + std::collections::btree_map::Entry::Vacant(_) => { + anyhow::bail!(error_message_not_exist); + } + } + } + } + } } // We write the configuration excluding the deleted Native Operation. diff --git a/crates/cli/tests/snapshots/initialize_tests__initialize_version_is_unchanged.snap b/crates/cli/tests/snapshots/initialize_tests__initialize_version_is_unchanged.snap index 1062f6d60..3f4bfb514 100644 --- a/crates/cli/tests/snapshots/initialize_tests__initialize_version_is_unchanged.snap +++ b/crates/cli/tests/snapshots/initialize_tests__initialize_version_is_unchanged.snap @@ -2,4 +2,4 @@ source: crates/cli/tests/initialize_tests.rs expression: version --- -"4" +"5" diff --git a/crates/configuration/src/configuration.rs b/crates/configuration/src/configuration.rs index 56c5967ef..f62e868ab 100644 --- a/crates/configuration/src/configuration.rs +++ b/crates/configuration/src/configuration.rs @@ -12,6 +12,7 @@ use crate::error::{ use crate::values::{IsolationLevel, PoolSettings}; use crate::version3; use crate::version4; +use crate::version5; use crate::VersionTag; use schemars::{gen::SchemaSettings, schema::RootSchema}; @@ -39,11 +40,12 @@ pub const DEFAULT_CONNECTION_URI_VARIABLE: &str = "CONNECTION_URI"; pub enum ParsedConfiguration { Version3(version3::RawConfiguration), Version4(version4::ParsedConfiguration), + Version5(version5::ParsedConfiguration), } impl ParsedConfiguration { pub fn initial() -> Self { - ParsedConfiguration::Version4(version4::ParsedConfiguration::empty()) + ParsedConfiguration::Version5(version5::ParsedConfiguration::empty()) } } @@ -78,6 +80,9 @@ pub async fn introspect( ParsedConfiguration::Version4(config) => Ok(ParsedConfiguration::Version4( version4::introspect(config, environment).await?, )), + ParsedConfiguration::Version5(config) => Ok(ParsedConfiguration::Version5( + version5::introspect(config, environment).await?, + )), } } @@ -85,17 +90,21 @@ pub async fn parse_configuration( configuration_dir: impl AsRef + Send, ) -> Result { // Try parsing each supported version in turn - match version4::parse_configuration(configuration_dir.as_ref()).await { - Err(v4_err) => match version3::parse_configuration(configuration_dir.as_ref()).await { - Err(v3_err) => Err(ParseConfigurationError::UnableToParseAnyVersions( - MultiError(vec![ - ("Trying V3".to_string(), Box::new(v3_err)), - ("Trying V4".to_string(), Box::new(v4_err)), - ]), - )), - Ok(config) => Ok(ParsedConfiguration::Version3(config)), + match version5::parse_configuration(configuration_dir.as_ref()).await { + Err(v5_err) => match version4::parse_configuration(configuration_dir.as_ref()).await { + Err(v4_err) => match version3::parse_configuration(configuration_dir.as_ref()).await { + Err(v3_err) => Err(ParseConfigurationError::UnableToParseAnyVersions( + MultiError(vec![ + ("Trying V3".to_string(), Box::new(v3_err)), + ("Trying V4".to_string(), Box::new(v4_err)), + ("Trying V5".to_string(), Box::new(v5_err)), + ]), + )), + Ok(config) => Ok(ParsedConfiguration::Version3(config)), + }, + Ok(config) => Ok(ParsedConfiguration::Version4(config)), }, - Ok(config) => Ok(ParsedConfiguration::Version4(config)), + Ok(config) => Ok(ParsedConfiguration::Version5(config)), } } @@ -111,6 +120,7 @@ pub fn make_runtime_configuration( match parsed_config { ParsedConfiguration::Version3(c) => version3::make_runtime_configuration(c, environment), ParsedConfiguration::Version4(c) => version4::make_runtime_configuration(c, environment), + ParsedConfiguration::Version5(c) => version5::make_runtime_configuration(c, environment), } } @@ -122,6 +132,7 @@ pub async fn write_parsed_configuration( match parsed_config { ParsedConfiguration::Version3(c) => version3::write_parsed_configuration(c, out_dir).await, ParsedConfiguration::Version4(c) => version4::write_parsed_configuration(c, out_dir).await, + ParsedConfiguration::Version5(c) => version5::write_parsed_configuration(c, out_dir).await, } } @@ -132,8 +143,11 @@ pub async fn write_parsed_configuration( pub fn upgrade_to_latest_version(parsed_config: ParsedConfiguration) -> ParsedConfiguration { match parsed_config { ParsedConfiguration::Version3(v) => { - ParsedConfiguration::Version4(version4::upgrade_from_v3(v)) + ParsedConfiguration::Version5(version5::upgrade_from_v4(version4::upgrade_from_v3(v))) + } + ParsedConfiguration::Version4(v) => { + ParsedConfiguration::Version5(version5::upgrade_from_v4(v)) } - ParsedConfiguration::Version4(_) => parsed_config, + ParsedConfiguration::Version5(_) => parsed_config, } } diff --git a/crates/configuration/src/lib.rs b/crates/configuration/src/lib.rs index 95750cdb7..b2ec4f9ea 100644 --- a/crates/configuration/src/lib.rs +++ b/crates/configuration/src/lib.rs @@ -7,6 +7,7 @@ pub mod metrics; pub mod version3; pub mod version4; +pub mod version5; pub use configuration::{ generate_latest_schema, introspect, make_runtime_configuration, parse_configuration, @@ -21,6 +22,7 @@ pub use metrics::Metrics; pub enum VersionTag { Version3, Version4, + Version5, } #[cfg(test)] diff --git a/crates/configuration/src/metrics.rs b/crates/configuration/src/metrics.rs index 10de6515e..96cce4457 100644 --- a/crates/configuration/src/metrics.rs +++ b/crates/configuration/src/metrics.rs @@ -9,6 +9,7 @@ use crate::VersionTag; pub struct Metrics { configuration_version_3: IntGauge, configuration_version_4: IntGauge, + configuration_version_5: IntGauge, } impl Metrics { @@ -26,9 +27,16 @@ impl Metrics { "Get whether configuration version 4 is used", )?; + let configuration_version_5 = add_int_gauge_metric( + metrics_registry, + "ndc_postgres_configuration_version_5", + "Get whether configuration version 5 is used", + )?; + Ok(Self { configuration_version_3, configuration_version_4, + configuration_version_5, }) } @@ -37,6 +45,7 @@ impl Metrics { match version { VersionTag::Version3 => self.configuration_version_3.set(1), VersionTag::Version4 => self.configuration_version_4.set(1), + VersionTag::Version5 => self.configuration_version_5.set(1), } } } diff --git a/crates/configuration/src/version3/mod.rs b/crates/configuration/src/version3/mod.rs index 9ccd28650..d40a8917a 100644 --- a/crates/configuration/src/version3/mod.rs +++ b/crates/configuration/src/version3/mod.rs @@ -625,7 +625,7 @@ pub fn convert_metadata(metadata: metadata::Metadata) -> query_engine_metadata:: query_engine_metadata::metadata::Metadata { tables: convert_tables(metadata.tables), composite_types: convert_composite_types(composite_types), - native_queries: convert_native_queries(metadata.native_queries), + native_operations: convert_native_queries(metadata.native_queries), scalar_types: convert_scalar_types( scalar_types, metadata.aggregate_functions, @@ -716,14 +716,24 @@ fn convert_aggregate_function( fn convert_native_queries( native_queries: metadata::NativeQueries, -) -> query_engine_metadata::metadata::NativeQueries { - query_engine_metadata::metadata::NativeQueries( - native_queries - .0 - .into_iter() - .map(|(k, v)| (k, convert_native_query_info(v))) - .collect(), - ) +) -> query_engine_metadata::metadata::NativeOperations { + let mut queries = BTreeMap::new(); + let mut mutations = BTreeMap::new(); + + for (name, operation) in native_queries.0 { + let is_procedure = operation.is_procedure; + let info = convert_native_query_info(operation); + if is_procedure { + mutations.insert(name, info); + } else { + queries.insert(name, info); + } + } + + query_engine_metadata::metadata::NativeOperations { + queries: query_engine_metadata::metadata::NativeQueries(queries), + mutations: query_engine_metadata::metadata::NativeQueries(mutations), + } } fn convert_native_query_info( @@ -742,7 +752,6 @@ fn convert_native_query_info( .map(|(k, v)| (k, convert_read_only_column_info(v))) .collect(), description: native_query_info.description, - is_procedure: native_query_info.is_procedure, } } diff --git a/crates/configuration/src/version4/metadata/database.rs b/crates/configuration/src/version4/metadata/database.rs index 65d3cd467..b49e79577 100644 --- a/crates/configuration/src/version4/metadata/database.rs +++ b/crates/configuration/src/version4/metadata/database.rs @@ -2,11 +2,6 @@ // This code was copied from a different place that predated the introduction of clippy to the // project. Therefore we disregard certain clippy lints: -#![allow( - clippy::enum_variant_names, - clippy::upper_case_acronyms, - clippy::wrong_self_convention -)] use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use std::collections::{BTreeMap, BTreeSet}; diff --git a/crates/configuration/src/version4/metadata/native_queries.rs b/crates/configuration/src/version4/metadata/native_queries.rs index 8edd16508..f2c9b55d6 100644 --- a/crates/configuration/src/version4/metadata/native_queries.rs +++ b/crates/configuration/src/version4/metadata/native_queries.rs @@ -2,7 +2,6 @@ // This code was copied from a different place that predated the introduction of clippy to the // project. Therefore we disregard certain clippy lints: -#![allow(clippy::wrong_self_convention)] use super::database::*; use query_engine_sql::sql; diff --git a/crates/configuration/src/version4/mod.rs b/crates/configuration/src/version4/mod.rs index d056e9883..06d01d4da 100644 --- a/crates/configuration/src/version4/mod.rs +++ b/crates/configuration/src/version4/mod.rs @@ -1,10 +1,10 @@ //! Internal Configuration and state for our connector. -mod comparison; +pub mod comparison; pub mod connection_settings; pub mod metadata; pub mod native_operations; -mod options; +pub mod options; mod to_runtime_configuration; mod upgrade_from_v3; diff --git a/crates/configuration/src/version4/to_runtime_configuration.rs b/crates/configuration/src/version4/to_runtime_configuration.rs index 929e6c64d..baace59b6 100644 --- a/crates/configuration/src/version4/to_runtime_configuration.rs +++ b/crates/configuration/src/version4/to_runtime_configuration.rs @@ -1,6 +1,8 @@ //! Convert the parsed configuration metadata to internal engine metadata //! That can be used by the connector at runtime. +use std::collections::BTreeMap; + use super::metadata; use super::ParsedConfiguration; use crate::environment::Environment; @@ -41,7 +43,7 @@ pub fn convert_metadata(metadata: metadata::Metadata) -> query_engine_metadata:: query_engine_metadata::metadata::Metadata { tables: convert_tables(metadata.tables), composite_types: convert_composite_types(metadata.composite_types), - native_queries: convert_native_queries(metadata.native_queries), + native_operations: convert_native_queries(metadata.native_queries), scalar_types: convert_scalar_types(metadata.scalar_types), } } @@ -96,14 +98,24 @@ fn convert_aggregate_function( fn convert_native_queries( native_queries: metadata::NativeQueries, -) -> query_engine_metadata::metadata::NativeQueries { - query_engine_metadata::metadata::NativeQueries( - native_queries - .0 - .into_iter() - .map(|(k, v)| (k, convert_native_query_info(v))) - .collect(), - ) +) -> query_engine_metadata::metadata::NativeOperations { + let mut queries = BTreeMap::new(); + let mut mutations = BTreeMap::new(); + + for (name, operation) in native_queries.0 { + let is_procedure = operation.is_procedure; + let info = convert_native_query_info(operation); + if is_procedure { + mutations.insert(name, info); + } else { + queries.insert(name, info); + } + } + + query_engine_metadata::metadata::NativeOperations { + queries: query_engine_metadata::metadata::NativeQueries(queries), + mutations: query_engine_metadata::metadata::NativeQueries(mutations), + } } fn convert_native_query_info( @@ -122,7 +134,6 @@ fn convert_native_query_info( .map(|(k, v)| (k, convert_read_only_column_info(v))) .collect(), description: native_query_info.description, - is_procedure: native_query_info.is_procedure, } } diff --git a/crates/configuration/src/version5/comparison.rs b/crates/configuration/src/version5/comparison.rs new file mode 100644 index 000000000..e5873456c --- /dev/null +++ b/crates/configuration/src/version5/comparison.rs @@ -0,0 +1,128 @@ +//! Helpers for the comparison operators configuration. + +use super::database::OperatorKind; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +/// Define the names that comparison operators will be exposed as by the automatic introspection. +#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ComparisonOperatorMapping { + /// The name of the operator as defined by the database + pub operator_name: String, + /// The name the operator will appear under in the exposed API + pub exposed_name: String, + /// Equal, In or Custom. + pub operator_kind: OperatorKind, +} + +impl ComparisonOperatorMapping { + /// The default comparison operator mappings apply the aliases that are used in graphql-engine v2. + pub fn default_mappings() -> Vec { + vec![ + // Common mappings + ComparisonOperatorMapping { + operator_name: "=".to_string(), + exposed_name: "_eq".to_string(), + operator_kind: OperatorKind::Equal, + }, + ComparisonOperatorMapping { + operator_name: "<=".to_string(), + exposed_name: "_lte".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: ">".to_string(), + exposed_name: "_gt".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: ">=".to_string(), + exposed_name: "_gte".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "<".to_string(), + exposed_name: "_lt".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "!=".to_string(), + exposed_name: "_neq".to_string(), + operator_kind: OperatorKind::Custom, + }, + // Preferred by CockroachDB + ComparisonOperatorMapping { + operator_name: "LIKE".to_string(), + exposed_name: "_like".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "NOT LIKE".to_string(), + exposed_name: "_nlike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "ILIKE".to_string(), + exposed_name: "_ilike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "NOT ILIKE".to_string(), + exposed_name: "_nilike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "SIMILAR TO".to_string(), + exposed_name: "_similar".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "NOT SIMILAR TO".to_string(), + exposed_name: "_nsimilar".to_string(), + operator_kind: OperatorKind::Custom, + }, + // Preferred by Postgres + ComparisonOperatorMapping { + operator_name: "~~".to_string(), + exposed_name: "_like".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "!~~".to_string(), + exposed_name: "_nlike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "~~*".to_string(), + exposed_name: "_ilike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "!~~*".to_string(), + exposed_name: "_nilike".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "~".to_string(), + exposed_name: "_regex".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "!~".to_string(), + exposed_name: "_nregex".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "~*".to_string(), + exposed_name: "_iregex".to_string(), + operator_kind: OperatorKind::Custom, + }, + ComparisonOperatorMapping { + operator_name: "!~*".to_string(), + exposed_name: "_niregex".to_string(), + operator_kind: OperatorKind::Custom, + }, + ] + } +} diff --git a/crates/configuration/src/version5/connection_settings.rs b/crates/configuration/src/version5/connection_settings.rs new file mode 100644 index 000000000..4ecd3662c --- /dev/null +++ b/crates/configuration/src/version5/connection_settings.rs @@ -0,0 +1,33 @@ +//! Database connection settings. + +use crate::values::{ConnectionUri, IsolationLevel, PoolSettings, Secret}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +pub const DEFAULT_CONNECTION_URI_VARIABLE: &str = "CONNECTION_URI"; + +/// Database connection settings. +#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct DatabaseConnectionSettings { + /// Connection string for a Postgres-compatible database. + pub connection_uri: ConnectionUri, + /// Connection pool settings. + #[serde(default)] + pub pool_settings: PoolSettings, + /// Query isolation level. + #[serde(default)] + pub isolation_level: IsolationLevel, +} + +impl DatabaseConnectionSettings { + pub fn empty() -> Self { + Self { + connection_uri: ConnectionUri(Secret::FromEnvironment { + variable: DEFAULT_CONNECTION_URI_VARIABLE.into(), + }), + pool_settings: PoolSettings::default(), + isolation_level: IsolationLevel::default(), + } + } +} diff --git a/crates/configuration/src/version5/introspection.sql b/crates/configuration/src/version5/introspection.sql new file mode 100644 index 000000000..374186b46 --- /dev/null +++ b/crates/configuration/src/version5/introspection.sql @@ -0,0 +1,1904 @@ +-- This query introspects the relations and types defined in the connected +-- database using the system catalog tables in the `pg_catalog` namespace. +-- +-- The data model of these tables is quite involved and carries with it decades +-- of legacy. Supporting notes on this are kept in 'introspection-notes.md'. +-- +-- When debugging in 'psql', uncomment the lines below to be able to run the +-- query with arguments set. + +-- DEALLOCATE ALL; -- Or use 'DEALLOCATE configuration' between reloads +-- PREPARE configuration(varchar[], varchar[], varchar[], jsonb, varchar[], jsonb, varchar[]) AS + +WITH + -- The overall structure of this query is a CTE (i.e. 'WITH .. SELECT') + -- statement which define projections of the catalog tables into forms that are + -- more convenient to work with: + -- + -- * We project only the columns that we need for constructing the ndc instance + -- schema and serving queries, and we try apply consistent naming. + -- + -- * We resolve references (oid's) to names. + -- + -- * We avoid aggregations over sub-selects and lateral joins since those have + -- proven brittle across postgres variants by experience. Instead we use + -- regular joins over tables that have been grouped by the join key to ensure + -- the 1:1 correspondance. + -- + -- One benefit of using a CTE is that it's easy to experiment with the query, + -- as you can query each of the WITH-bound sub-queries independently in the + -- main statement. + + -- Schemas are recorded in `pg_namespace`, see + -- https://www.postgresql.org/docs/current/catalog-pg-namespace.html for its + -- schema. + schemas_for_table_collections AS + ( + SELECT + ns.oid::regnamespace AS schema_id, + ns.nspname AS schema_name + FROM pg_namespace AS ns + WHERE + -- Various schemas are patently uninteresting: + NOT (ns.nspname = ANY ($1)) + ), + + -- These are the schemas of which tables will be unqualified + unqualified_schemas_for_tables AS + ( + SELECT DISTINCT + ns.oid::regnamespace as schema_id + FROM + UNNEST($2) AS t(schema_name) + INNER JOIN + pg_namespace + AS ns + ON (ns.nspname = schema_name) + ), + + -- These are the schemas of which types and procedures will be + -- exported unqualified. + unqualified_schemas_for_types_and_procedures AS + ( + SELECT DISTINCT + ns.oid::regnamespace as schema_id + FROM + UNNEST($3) AS t(schema_name) + INNER JOIN + pg_namespace + AS ns + ON (ns.nspname = schema_name) + ), + + -- Tables and views etc. are recorded in `pg_class`, see + -- https://www.postgresql.org/docs/current/catalog-pg-class.html for its + -- schema. + relations AS + ( + SELECT + cl.oid::regclass AS relation_id + FROM + pg_class cl + + -- We only want to know about relations that don't live in uninteresting schemas. + INNER JOIN + schemas_for_table_collections + ON (schemas_for_table_collections.schema_id = cl.relnamespace) + WHERE relkind IN + -- Lots of different types of relations exist, but we're only interested in + -- the ones that can be queried. + ( + 'r', -- = ordinary table + 'v', -- = view + 'm', -- = materialized view + 'f', -- = foreign table + 'p' -- = partitioned table + -- i = index, + -- S = sequence, + -- t = TOAST table, + -- c = composite type, + -- I = partitioned index + ) + ), + + -- This relation collects the various names we want to call relations by, and + -- how it should appear in the schema. + -- + -- All intermediate processing of relations uses exclusively 'regclass' + -- identifiers. We only tack on names when we generate the final json output. + relation_names AS + ( + SELECT + cl.oid::regclass AS relation_id, + + CASE + -- Note: This does not deal with schema names (or type names) containing spaces. + WHEN unqualified.schema_id IS NOT NULL + THEN cl.relname + ELSE schemas.nspname || '_' || cl.relname + END + AS + name_in_ndc_schema, + cl.relname AS relation_name, + schemas.nspname as schema_name + FROM + pg_class AS cl + + -- Filter, so we only include types we can understand + INNER JOIN + relations + ON + (cl.oid = relations.relation_id) + + -- Collect schema names. We _could_ instead just do + -- 'schema_id::regnamespace::text', but that would produce a proper, + -- quoted identifier. + INNER JOIN + pg_namespace AS schemas + ON (cl.relnamespace = schemas.oid) + + -- Tack on whether we want to qualify the name in the ndc schema or not + LEFT OUTER JOIN + unqualified_schemas_for_tables + AS unqualified + ON (cl.relnamespace = unqualified.schema_id) + ), + + -- Columns are recorded in `pg_attribute`. An 'attribute' is the generic term + -- for the parts that together make up a relation in general, and only in the + -- case of a table do we actually call them 'columns'. See + -- https://www.postgresql.org/docs/current/catalog-pg-attribute.html for its + -- schema. + columns AS + ( + SELECT + att.attrelid AS relation_id, + att.attname AS column_name, + att.attnum AS column_number, + att.atttypid AS type_id, + CASE WHEN att.attnotnull THEN 'nonNullable' ELSE 'nullable' END + AS nullable, + CASE WHEN att.atthasdef THEN 'hasDefault' ELSE 'noDefault' END + AS has_default, + CASE WHEN att.attidentity = 'd' THEN 'identityByDefault' + WHEN att.attidentity = 'a' THEN 'identityAlways' + ELSE 'notIdentity' + END + AS is_identity, + CASE WHEN attgenerated_exists + THEN CASE WHEN attgenerated::text = 's' THEN 'stored' ELSE 'notGenerated' END + ELSE 'notGenerated' + END as is_generated + FROM + pg_catalog.pg_attribute AS att + CROSS JOIN (SELECT current_setting('server_version_num')::int >= 120000) AS attgenerated(attgenerated_exists) + WHERE + -- We only include columns that are actually part of the table currently. + NOT att.attisdropped -- This table also records historic columns. + AND att.attnum > 0 -- attnum <= 0 are special system-defined columns. + ), + + -- Comments on database objects are recorded in `pg_description`. See + -- 'https://www.postgresql.org/docs/current/catalog-pg-description.html' for its schema. + -- + -- The modelling has some non-obvious use of indirection, which smells a bit + -- of Russel's paradox: 'classoid' is a 'pg_class.oid' value, which indicates + -- which _other_ pg_catalog table you need to consult in order to find the + -- object with oid 'objoid'. + -- + -- As an example, the comment of a table or view column will always have + -- + -- (classoid = 1259) + -- + -- since the 'pg_class.oid' 1259 refers to the 'pg_class' table _itself_ + -- (remember that, since 'pg_class' records all tables (and other relations) + -- that exist in the database, it also has a record of itself). + -- + -- Rather than using literal numerical oids in this query we use the special + -- built-in datatype 'regclass' which resolves names to oids automatically. + -- See https://www.postgresql.org/docs/current/datatype-oid.html + column_comments AS + ( + SELECT + col.relation_id, + col.column_name, + comm.description + FROM + ( + SELECT + objoid::regclass AS relation_id, + objsubid AS column_number, + description + FROM + pg_description + WHERE + classoid = 'pg_catalog.pg_class'::regclass + ) AS comm + INNER JOIN + columns + AS col + USING (relation_id, column_number) + ), + + table_comments AS + ( + SELECT + objoid::regclass AS relation_id, + description + FROM + pg_description + WHERE + classoid = 'pg_catalog.pg_class'::regclass + AND objsubid = 0 + ), + + type_comments AS + ( + SELECT + objoid::regtype AS type_id, + description + FROM + pg_description + WHERE + classoid = 'pg_catalog.pg_type'::regclass + AND objsubid = 0 + ), + + -- Composite types, including those defined implicitly through a table and + -- explicitly via `CREATE TYPE`. + composite_types AS + ( + SELECT + t.oid::regtype AS type_id, + t.typrelid::regclass AS relation_id + FROM + pg_type t + -- We only want to know about composite types that don't live in uninteresting schemas. + INNER JOIN + schemas_for_table_collections + ON (schemas_for_table_collections.schema_id = t.typnamespace) + WHERE typtype = 'c' + ), + + -- This relation collects the various names we want to call composite types + -- by, and how it should appear in the schema. + -- + -- All intermediate processing of types uses exclusively 'regtype' + -- identifiers. We only tack on names when we generate the final json output. + composite_type_names AS + ( + SELECT + t.oid::regtype AS type_id, + + CASE + -- Note: This does not deal with schema names (or type names) containing spaces. + WHEN unqualified.schema_id IS NOT NULL + THEN t.typname + ELSE schemas.nspname || '_' || t.typname + END + AS + name_in_ndc_schema, + t.typname AS type_name, + schemas.nspname as schema_name + FROM + pg_type AS t + + -- Filter, so we only include types we can understand + INNER JOIN + composite_types + ON + (t.oid = composite_types.type_id) + + -- Collect schema names. We _could_ instead just do + -- 'schema_id::regnamespace::text', but that would produce a proper, + -- quoted identifier. + INNER JOIN + pg_namespace AS schemas + ON (t.typnamespace = schemas.oid) + + -- Tack on whether we want to qualify the name in the ndc schema or not + LEFT OUTER JOIN + unqualified_schemas_for_tables + AS unqualified + ON (t.typnamespace = unqualified.schema_id) + ), + + -- Composite types, except those which are also tables. + -- We collect these separately at the top level because we need to be able to + -- talk about them but also know that they are not tables that you can query. + exclusively_composite_types AS + ( + WITH + exclusively_composite_type_ids AS + ( + SELECT relation_id FROM composite_types + EXCEPT + SELECT relation_id FROM relations + ) + SELECT + * + FROM composite_types + NATURAL INNER JOIN exclusively_composite_type_ids + ), + + -- Types are recorded in 'pg_type', see + -- https://www.postgresql.org/docs/current/catalog-pg-type.html for its + -- schema. + scalar_types AS + ( + SELECT + t.oid::regtype AS type_id + FROM + pg_catalog.pg_type AS t + WHERE + -- We currently filter out pseudo (polymorphic) types, because our schema + -- can only deal with monomorphic types. + -- + -- We also filter out composite (record) types and arrays. We would like + -- to support those properly, which requires support in the schema and + -- query execution. If we export them as opaque scalar types, adding + -- proper support later becomes a breaking change, which we'd like to + -- avoid. + -- + -- We intentionally do not filter out domain types, see the relation + -- `domain_types` below. + t.typtype NOT IN + ( + -- Interesting t.typtype 'types of types': + -- 'b' for base type + 'c', -- for composite type + -- 'd', for domain (a predicate-restricted version of a type) + -- 'e' for enum + 'p' -- for pseudo-type (anyelement etc) + -- 'r' for range + -- 'm' for multi-range + ) + AND NOT + ( + -- Exclude arrays (see 'array_types' below). + t.typelem != 0 -- whether you can subscript into the type + AND typcategory = 'A' -- The parsers considers this type an array for + -- the purpose of selecting preferred implicit casts. + ) + -- Ignore types that are (primarily) for internal postgres use. + -- This is a good candidate for a configuration option. + AND oid NOT IN + ( + SELECT oid + FROM pg_catalog.pg_type + WHERE + typname IN + ( + 'aclitem', + 'cid', + 'gidx', + 'name', + 'oid', + 'pg_dependencies', + 'pg_lsn', + 'pg_mcv_list', + 'pg_ndistinct', + 'pg_node_tree', + 'regclass', + 'regcollation', + 'regconfig', + 'regdictionary', + 'regnamespace', + 'regoper', + 'regoperator', + 'regproc', + 'regprocedure', + 'regrole', + 'regtype', + 'tid', + 'xid', + 'xid8' + ) + AND typnamespace = 'pg_catalog'::regnamespace + ) + ), + + -- This relation collects the various names we want to call scalar types by + -- (schema, name of the type itself, and how it should appear in the schema. + -- + -- All intermediate processing of types uses exclusively 'regtype' + -- identifiers. We only tack on names when we generate the final json output. + scalar_type_names AS + ( + SELECT + t.oid::regtype AS type_id, + + CASE + -- Note: This does not deal with schema names (or type names) containing spaces. + WHEN unqualified.schema_id IS NOT NULL + THEN t.typname + ELSE schemas.nspname || '_' || t.typname + END + AS + name_in_ndc_schema, + t.typname AS type_name, + schemas.nspname as schema_name + FROM + pg_type AS t + + -- Filter, so we only include types we can understand + INNER JOIN + scalar_types + ON + (t.oid = scalar_types.type_id) + + -- Collect schema names. We _could_ instead just do + -- 'schema_id::regnamespace::text', but that would produce a proper, + -- quoted identifier. + INNER JOIN + pg_namespace AS schemas + ON (t.typnamespace = schemas.oid) + + -- Tack on whether we want to qualify the name in the ndc schema or not + LEFT OUTER JOIN + unqualified_schemas_for_types_and_procedures + AS unqualified + ON (t.typnamespace = unqualified.schema_id) + ), + -- Domain types are scalar types that have been adorned with a CHECK + -- expression that any instance of the type must satisfy. + -- + -- While the `scalar_types` relation above does pick up on domain types as + -- well we also need to keep track of them separately in order to be able to + -- infer comparison operators and aggregation functions. + -- + -- Domain types are created using the `CREATE DOMAIN` statement (see + -- https://www.postgresql.org/docs/current/sql-createdomain.html). + domain_types AS + ( + SELECT + t.oid::regtype AS type_id, + t.typbasetype::regtype AS base_type + FROM + pg_catalog.pg_type AS t + WHERE + t.typtype = 'd' + ), + + -- Enum types are scalar types that consist of a finite, enumerated set of + -- labelled values. See + -- https://www.postgresql.org/docs/current/datatype-enum.html + -- + -- The catalog table `pg_catalog.pg_enum` records the enum types defined in + -- the database. See https://www.postgresql.org/docs/current/catalog-pg-enum.html + -- + -- Enum types support certain comparisons and aggregations, but these are not + -- registered in any of the catalog tables. Therefore we need some amount of + -- special case handling for enum types. + -- + -- Furthermore we are interested in collecting the labels for each enum type + -- to reflect in the NDC schema. + enum_types AS + ( + SELECT + t.oid::regtype AS type_id, + array_agg(e.enumlabel ORDER BY e.enumsortorder) AS enum_labels + FROM + pg_catalog.pg_type AS t + INNER JOIN + pg_enum + AS e + ON (e.enumtypid = t.oid) + GROUP BY (t.oid, t.typnamespace, t.typname) + ), + + array_types AS + ( + SELECT + t.oid::regtype AS type_id, + et.type_id as element_type_id, + et.element_type_kind + FROM + pg_catalog.pg_type AS t + INNER JOIN + -- Postgres does not distinguish nested arrays at the type level, so we + -- can already tell what the element type is. + ( + SELECT + type_id, + 'scalarType' AS element_type_kind + FROM scalar_types + UNION + SELECT + type_id, + 'compositeType' AS element_type_kind + FROM composite_types + ) + AS et + ON (et.type_id = t.typelem) + WHERE + -- See 'scalar_types' above + t.typtype = 'b' + -- What makes a type an 'array' type in postgres is a surprisingly + -- nuanced question. + -- + -- Ideally, we should identify the types we consider array types for + -- ndc purposes as those which postgres calls 'true array types', since + -- those are the ones you can query as arrays (i.e., call 'unnest' on) + -- and which ought reasonably to display as arrays, see + -- introspection-notes.md. + -- + -- There might be other types which will display as arrays (e.g., when + -- serializing to json), but we shouldn't recognize those as arrays + -- in the schema, because we cannot expect to be able to exploit that + -- structure when querying. + -- + -- The check for whether a type is a 'true array type' is not portable + -- across Postgres and CockroachDB. + -- Here we're interested in censoring to avoid future breaking changes, + -- so we're content to censor a bit too much rather than too little. + -- + -- The best check I could come up with that works for the builtin types + -- and the PostGIS extension is this: + AND t.typelem != 0 -- whether you can subscript into the type + AND typcategory = 'A' -- The parsers considers this type an array for + -- the purpose of selecting preferred implicit casts. + ), + + type_names AS + ( + SELECT * FROM scalar_type_names + UNION + SELECT * FROM composite_type_names + ), + + implicit_casts AS + ( + SELECT + t_from.type_id as from_type, + t_to.type_id as to_type + FROM + pg_cast + INNER JOIN + scalar_types + AS t_from + ON (t_from.type_id = pg_cast.castsource) + INNER JOIN + scalar_types + AS t_to + ON (t_to.type_id = pg_cast.casttarget) + WHERE + pg_cast.castcontext = 'i' + AND t_from.type_id != t_to.type_id + + -- This is a good candidate for a configurable option. + AND (t_from.type_id, t_to.type_id) NOT IN + ( + -- Ignore other casts that are unlikely to ever be relevant. + -- Note that these list **does not** take schemas into account. + SELECT f.oid, t.oid + FROM pg_type f + CROSS JOIN pg_type t + WHERE + (f.typname, t.typname) IN + ( + ('bytea', 'geography'), + ('bytea', 'geometry'), + ('geography', 'bytea'), + ('geometry', 'bytea'), + ('geometry', 'text'), + ('text', 'geometry'), + ('text', 'bpchar'), + ('varchar', 'bpchar') + ) + ) + UNION + -- Any domain type may be implicitly cast to its base type, even though these casts + -- are not declared in `pg_cast`. + SELECT + domain_types.type_id as from_type, + domain_types.base_type as to_type + FROM + domain_types + ), + + implicit_casts_closure AS + ( + WITH + RECURSIVE transitive_closure(from_type, to_type, cast_chain_length, cast_chain, cast_chain_arr) AS + ( + SELECT + *, + 1 AS cast_chain_length, + from_type || ' -> ' || to_type AS cast_chain, + array[from_type, to_type] AS cast_chain_arr + FROM + implicit_casts + UNION + SELECT + base.from_type, + closure.to_type, + closure.cast_chain_length + 1 AS cast_chain_length, + base.from_type || ' -> ' || closure.cast_chain AS cast_chain, + array[base.from_type] || closure.cast_chain_arr AS cast_chain_arr + FROM + implicit_casts + AS base + INNER JOIN + transitive_closure + AS closure + ON (base.to_type = closure.from_type) + WHERE + -- Don't allow cycles + NOT (base.from_type = ANY(closure.cast_chain_arr)) + -- As a safety, let's not consider cast chains longer than 5. + AND closure.cast_chain_length <= 5 + ) + SELECT + from_type, + to_type, + cast_chain_length, + cast_chain + FROM + transitive_closure + ), + + -- Enum types support the aggregates 'min' and 'max'. However, these are not + -- registered as such in `pg_proc`, and so we have to make them them up + -- ourselves. + enum_aggregates AS + ( + SELECT + proc.proname AS proc_name, + e.type_id AS argument_type, + e.type_id AS return_type + FROM + (VALUES + ('min'), + ('max') + ) + AS proc(proname), + enum_types e + ), + + -- Aggregate functions are recorded across 'pg_proc' and 'pg_aggregate', see + -- https://www.postgresql.org/docs/current/catalog-pg-proc.html and + -- https://www.postgresql.org/docs/current/catalog-pg-aggregate.html for + -- their schema. + declared_aggregates AS + ( + SELECT + proc.oid::regprocedure AS proc_id, + proc.proname AS proc_name, + proc.pronamespace AS schema_id, + arg_type.type_id as argument_type, + ret_type.type_id as return_type + -- Columns that will likely be of interest soon: + -- proc.proargnames AS argument_names, + + FROM + pg_catalog.pg_proc AS proc + + INNER JOIN + -- Until the schema is made part of our model of types we only consider + -- types defined in the public schema. + unqualified_schemas_for_types_and_procedures + AS q + ON (q.schema_id = proc.pronamespace) + + -- fetch the argument type name, discarding any unsupported types + INNER JOIN scalar_types AS arg_type + ON (arg_type.type_id = proc.proargtypes[0]) + + -- fetch the return type name, discarding any unsupported types + INNER JOIN scalar_types AS ret_type + ON (ret_type.type_id = proc.prorettype) + + -- restrict our scope to only aggregation functions + INNER JOIN pg_aggregate AS aggregate + ON (aggregate.aggfnoid = proc.oid) + + WHERE + -- We are only interested in functions: + -- * which take a single input argument + -- * which are aggregation functions + -- * which don't take any 'direct' (i.e., non-aggregation) arguments + proc.pronargs = 1 + AND aggregate.aggnumdirectargs = 0 + + ), + aggregates AS + ( + SELECT + proc_name, + return_type, + argument_type + FROM + declared_aggregates + UNION + SELECT + proc_name, + return_type, + argument_type + FROM enum_aggregates + ), + + aggregates_cast_extended AS + ( + WITH + type_combinations AS + ( + SELECT + agg.proc_name AS proc_name, + agg.return_type AS return_type, + cast1.from_type AS argument_type, + cast1.cast_chain_length AS argument_cast_chain_length, + cast1.cast_chain AS argument_cast_chain + FROM + aggregates + AS agg + INNER JOIN + implicit_casts_closure + AS cast1 + ON (cast1.to_type = agg.argument_type) + UNION + SELECT + agg.proc_name AS proc_name, + agg.return_type AS return_type, + agg.argument_type AS argument_type, + 0 AS argument_cast_chain_length, + '' AS argument_cast_chain + FROM + aggregates + AS agg + ), + + preferred_combinations AS + ( + SELECT + *, + -- CockroachDB does not observe ORDER BY of nested expressions, + -- So we cannot use the DISTINCT ON idiom to remove duplicates. + -- Therefore we resort to filtering by ordered ROW_NUMBER(). + ROW_NUMBER() + OVER + ( + PARTITION BY + proc_name, argument_type + ORDER BY + -- Prefer least cast argument + argument_cast_chain_length ASC, + -- Arbitrary desperation: Lexical ordering + return_type ASC + ) + AS row_number + FROM + type_combinations + ) + SELECT + proc_name, + argument_type, + argument_cast_chain, + return_type + FROM + preferred_combinations + WHERE + row_number = 1 + ), + + -- This relation captures the type IDs of exactly the types that may + -- positively occur given the collections that are tracked. + -- This is used to filter the resulting metadata such that only the types + -- that may actually occur should appear. + live_types AS + ( + WITH + + liveness_implicators(antecedent, consequent) AS + ( + -- A composite type being live implies the types of its fields being live. + SELECT DISTINCT + composite_types.type_id AS antecedent, + columns.type_id AS consequent + FROM + composite_types + INNER JOIN + columns + USING (relation_id) + + UNION + + -- * An array type being live implies its element type being live. + SELECT + type_id AS antecedent, + element_type_id AS consequent + FROM + array_types + + UNION + + -- * A scalar type being live implies the return types of its aggregation + -- functions being live. + SELECT DISTINCT + argument_type AS antecedent, + return_type AS consequent + FROM + aggregates_cast_extended + ), + + live_types_root_set(type_id) AS + ( + -- * Tables (considered as composite types) + SELECT + type_id + FROM composite_types + INNER JOIN + relations + USING (relation_id) + + UNION + + -- * Native queries fields (given by query parameter) + SELECT + type_id + FROM + unnest($7) AS field_type(name_in_ndc_schema) + INNER JOIN + type_names + USING (name_in_ndc_schema) + ), + + transitive_closure AS + ( + WITH RECURSIVE transitive_closure(type_id) AS + ( + SELECT + * + FROM + live_types_root_set + UNION + SELECT + liveness_implicators.consequent AS type_id + FROM + liveness_implicators + INNER JOIN + transitive_closure + ON (liveness_implicators.antecedent = transitive_closure.type_id) + ) + SELECT type_id from transitive_closure + ) + SELECT + type_id + FROM + transitive_closure + ), + + column_types_json AS + ( + SELECT + scalar_types.type_id, + jsonb_build_object( + 'scalarType', + name_in_ndc_schema + ) + AS result + FROM + scalar_types + INNER JOIN + scalar_type_names + ON (scalar_types.type_id = scalar_type_names.type_id) + UNION + SELECT + array_types.type_id, + jsonb_build_object( + 'arrayType', + jsonb_build_object( + element_type_kind, + name_in_ndc_schema + ) + ) + AS result + FROM + array_types + INNER JOIN + type_names + ON (array_types.element_type_id = type_names.type_id) + UNION + SELECT + composite_types.type_id, + jsonb_build_object( + 'compositeType', + name_in_ndc_schema + ) + AS result + FROM + composite_types + INNER JOIN + type_names + ON (composite_types.type_id = type_names.type_id) + ), + + composite_type_fields_json AS + ( + SELECT + c.relation_id, + jsonb_object_agg + ( + c.column_name, + jsonb_build_object + ( + 'fieldName', + c.column_name, + 'type', + t.result, + 'description', + comm.description + ) + ) + AS result + FROM columns + AS c + LEFT OUTER JOIN column_types_json + AS t + ON (c.type_id = t.type_id) + LEFT OUTER JOIN column_comments + AS comm + USING (relation_id, column_name) + GROUP BY relation_id + HAVING + -- All columns must have a supported type. + bool_and(NOT t.result IS NULL) + ), + + composite_types_json AS + ( + WITH + composite_types_definitions AS + ( + SELECT + names.name_in_ndc_schema, + jsonb_build_object + ( + 'typeName', + names.type_name, + 'schemaName', + names.schema_name, + 'fields', + fields.result, + 'description', + comm.description + ) + AS result + FROM + exclusively_composite_types + AS ct + INNER JOIN + live_types + USING (type_id) + INNER JOIN + composite_type_names + AS names + ON (ct.type_id = names.type_id) + INNER JOIN + composite_type_fields_json + AS fields + USING (relation_id) + LEFT OUTER JOIN + type_comments + AS comm + ON (ct.type_id = comm.type_id) + ) + SELECT + jsonb_object_agg + ( + name_in_ndc_schema, + result + ) + AS result + FROM + composite_types_definitions + ), + + -- Comparison procedures are any entries in 'pg_proc' that happen to be + -- binary functions that return booleans. We also require, for the sake of + -- simplicity, that these functions be non-variadic (i.e. no default values). + -- Within this CTE, we attempt to generate a table of comparison procedures + -- to match the shape of the 'comparison_operators'. + comparison_procedures AS + ( + SELECT + proc.proname AS operator_name, + proc.proargtypes[0] as argument1_type, + proc.proargtypes[1] as argument2_type, + false AS is_infix + FROM + pg_catalog.pg_proc AS proc + INNER JOIN scalar_types + AS ret_type + ON (ret_type.type_id = proc.prorettype) + INNER JOIN + -- Until the schema is made part of our model of types we only consider + -- types defined in the public schema. + unqualified_schemas_for_types_and_procedures + AS q + ON (q.schema_id = proc.pronamespace) + WHERE + ret_type.type_id = 'pg_catalog.bool'::regtype + -- We check that we only consider procedures which take two regular + -- arguments. + AND cardinality(proc.proargtypes) = 2 + AND proc.prokind = 'f' + AND proc.provariadic = 0 + AND proc.pronargdefaults = 0 + -- Include only procedures that are explicitly selected. + -- This is controlled by the + -- 'introspectPrefixFunctionComparisonOperators' configuration option. + AND proc.proname = ANY ($5) + ), + + -- Operators are recorded across 'pg_proc', pg_operator, and 'pg_aggregate', see + -- https://www.postgresql.org/docs/current/catalog-pg-proc.html, + -- https://www.postgresql.org/docs/current/catalog-pg-operator.html and + -- https://www.postgresql.org/docs/current/catalog-pg-aggregate.html for + -- their schema. + -- + -- In PostgreSQL, operators and aggregation functions each relate to a `pg_proc` + -- procedure. On CockroachDB, however, they are independent. + comparison_infix_operators AS + ( + SELECT + op.oprname AS operator_name, + t1.type_id AS argument1_type, + t2.type_id AS argument2_type, + true AS is_infix + FROM + pg_operator + AS op + INNER JOIN + scalar_types + AS t1 + ON (op.oprleft = t1.type_id) + INNER JOIN + scalar_types + AS t2 + ON (op.oprright = t2.type_id) + INNER JOIN + scalar_types + AS t_res + ON (op.oprresult = t_res.type_id) + INNER JOIN + -- Until the schema is made part of our model of operators we only consider + -- those defined in the public schema. + unqualified_schemas_for_types_and_procedures + AS q + ON (q.schema_id = op.oprnamespace) + WHERE + t_res.type_id = 'pg_catalog.bool'::regtype + ORDER BY op.oprname + ), + + -- Enum types are totally ordered and support the conventional comparison operators. + -- They are defined implicitly (i.e., not registered in `pg_proc` or + -- `pg_operator`) so we have to make up some definitions for them. + enum_comparison_operators AS + ( + SELECT + op.oprname AS operator_name, + e.type_id AS argument1_type, + e.type_id AS argument2_type, + true AS is_infix + FROM + (VALUES + ('='), + ('!='), + ('<='), + ('>'), + ('>='), + ('<') + ) + AS op(oprname), + enum_types e + ), + + -- Here, we reunite our binary infix procedures and our binary prefix + -- procedures under the umbrella of 'comparison_operators'. We do this + -- here so that we can treat them uniformly form this point on. + -- Specifically, we generate all the various type coercion permutations + -- for both in 'comparison_operators_cast_extended'. + comparison_operators AS + ( + SELECT * FROM comparison_infix_operators + UNION + SELECT * FROM comparison_procedures + UNION + SELECT * FROM enum_comparison_operators + ), + + -- Some comparison operators are not defined explicitly for every type they would be + -- valid for, relying instead on implicit casts to extend the types they can apply to. + -- + -- Examples: + -- + -- Postgres only defines 'like' for 'text', not for 'varchar'. But there's + -- an implicit cast for varchar->text. + -- + -- CockroachDB does not define any comparison operators for 'float4', but does + -- for 'float8', along with an implict cast for float4->float8. + -- + -- Curiously, Cockroach _also_ goes on to define (e.g.) '!=' on both of + -- '(int8,int8)' _and_ '(int8,float8)' choosing not to rely on casts in this case. + -- + -- As such, we can expect to have to deal with two sources of overloading: From + -- multiple definitions for different types and from implicit casts. + -- + -- However, the NDC API is very 'argument1'-centric in the sense that its + -- notion of a scalar type is defined in part by the set of comparison + -- operators that take a value of this type as their first argument. + -- + -- A consequence of this is that, in a boolean filter expression the type of + -- the first argument of a comparison operator is given by the context it + -- appears in. In English we can equivalently say that "on this field of type + -- T we want to perform one of T's comparison operators." + -- + -- Under this framing, in order to make as many comparisons available as + -- possible, we need to extend the set of comparsion operators by the + -- implicit casts available on their first argument. + -- + -- For example consider hypothetically: + -- + -- A function 'like': + -- like(varchar, varchar) -> bool + -- + -- .. and implicit casts: + -- varchar -> name + -- name -> varchar + -- + -- Extending the definition of 'like' with implit casts on argument1 gives the set: + -- + -- like(varchar, varchar) -> bool + -- like(name, varchar) -> bool + -- + -- Which means that each of 'varchar' and 'name' can get 'like' operator. + -- + -- Of course we would also want to accept as many types as possible for the + -- second argument. However, we hit a bottleneck if we try the same thing to argument 2. + -- + -- Extending argument2 gives us: + -- + -- like(varchar, varchar) -> bool + -- like(varchar, name) -> bool + -- like(name, varchar) -> bool + -- like(name, name) -> bool + -- + -- It is now not given which single variant of 'like' to pick for each of + -- 'varchar' and 'name'. + -- + -- To avoid this problem for now we apply the limitation of only + -- cast-extending by the first argument. + -- + -- Other solutions are possible, such as including the argument type names in + -- the exposed name of the operator. Or requiring the user provide more + -- information to drive the application of cast extension. + -- + -- Note that since NDC configuration introspection is only a sort of + -- conventional convenience it is still possible to manually expose whatever + -- comparison function is required by manually adding a metadata entry for + -- it. + -- + -- Note also that since the various infix comparison operators on text-like + -- types are only defined on 'text', (and the same for numerical types only + -- on float8) a non-intuitive consequence of the above limitation is that + -- e.g. the equality comparison operator for e.g. 'char' ends up being + -- '_eq(char, text) -> bool'. + comparison_operators_cast_extended AS + ( + WITH + type_combinations AS + ( + SELECT + op.operator_name, + cast1.from_type as argument1_type, + op.argument2_type, + op.is_infix, + cast1.cast_chain_length as argument1_cast_chain_length, + cast1.cast_chain AS argument1_cast_chain, + 0 as argument2_cast_chain_length, + '' AS argument2_cast_chain + FROM + comparison_operators + AS op + INNER JOIN + implicit_casts_closure + AS cast1 + ON (cast1.to_type = op.argument1_type) + UNION + SELECT + op.operator_name, + op.argument1_type, + cast2.from_type as argument2_type, + op.is_infix, + 0 as argument1_cast_chain_length, + '' AS argument1_cast_chain, + cast2.cast_chain_length as argument2_cast_chain_length, + cast2.cast_chain AS argument2_cast_chain + FROM + comparison_operators + AS op + INNER JOIN + implicit_casts_closure + AS cast2 + ON (cast2.to_type = op.argument2_type) + UNION + SELECT + op.operator_name, + cast1.from_type as argument1_type, + cast2.from_type as argument2_type, + op.is_infix, + cast1.cast_chain_length as argument1_cast_chain_length, + cast1.cast_chain AS argument1_cast_chain, + cast2.cast_chain_length as argument2_cast_chain_length, + cast2.cast_chain AS argument2_cast_chain + FROM + comparison_operators + AS op + INNER JOIN + implicit_casts_closure + AS cast1 + ON (cast1.to_type = op.argument1_type) + INNER JOIN + implicit_casts_closure + AS cast2 + ON (cast2.to_type = op.argument2_type) + UNION + SELECT + op.operator_name, + op.argument1_type, + op.argument2_type, + op.is_infix, + 0 as argument1_cast_chain_length, + '' AS argument1_cast_chain, + 0 as argument2_cast_chain_length, + '' AS argument2_cast_chain + FROM + comparison_operators + AS op + ), + + preferred_combinations AS + ( + SELECT + *, + -- CockroachDB does not observe ORDER BY of nested expressions, + -- So we cannot use the DISTINCT ON idiom to remove duplicates. + -- Therefore we resort to filtering by ordered ROW_NUMBER(). + ROW_NUMBER() + OVER + ( + PARTITION BY + operator_name, argument1_type + ORDER BY + -- In case of ambiguities: + + -- 1. Prefer directly defined versions first which uses the same + -- type. + (argument1_cast_chain_length = 0 AND argument2_cast_chain_length = 0) + AND (argument1_type = argument2_type) DESC, + + -- 2. Prefer directly defined versions first which use different + -- types. + (argument1_cast_chain_length = 0 AND argument2_cast_chain_length = 0) DESC, + + -- 3. If argument1 was casted, prefer any version on the same type + -- P → Q = ¬P ∨ Q + (argument1_cast_chain_length = 0) OR (argument1_type = argument2_type) DESC, + + -- 4. Prefer uncast argument2. + argument2_cast_chain_length = 0 DESC, + + -- 5. Prefer least cast arguments + argument1_cast_chain_length + argument2_cast_chain_length ASC, + + -- 6. Arbitrary desperation: Lexical ordering + argument2_type ASC + ) + AS row_number + FROM + type_combinations + ) + SELECT + operator_name, + argument1_type, + argument2_type, + is_infix, + argument1_cast_chain, + argument1_cast_chain_length, + argument2_cast_chain, + argument2_cast_chain_length, + row_number + FROM + preferred_combinations + WHERE + row_number = 1 + ), + + -- The names that comparison operators are exposed under is configurable. + operator_mappings AS + ( + SELECT + v ->> 'operatorName' AS operator_name, + v ->> 'exposedName' AS exposed_name, + v ->> 'operatorKind' AS operator_kind + FROM + jsonb_array_elements($4) AS v + ), + + -- Constraints are recorded in 'pg_constraint', see + -- https://www.postgresql.org/docs/current/catalog-pg-constraint.html for its + -- schema. + -- + -- This form captures both uniqueness constraints and foreign key + -- constraints. The 'constraint_type' column determines which columns will be + -- non-null. + constraints AS + ( + WITH + -- The columns that make up a constraint are recorded in + -- pg_constraint(conkey, confkey), keyed by column number (attnum). + -- 'constraint_columns' and 'constraint_referenced_columns' dereference + -- these to column names. + -- + -- This involves unnesting, joining 'columns', and re-constructing the + -- array. + constraint_columns AS + ( + SELECT + c_unnest.constraint_id, + array_agg(col.column_name) as key_columns + FROM + ( + SELECT + c.oid as constraint_id, + c.conrelid as relation_id, + unnest(c.conkey) as column_number + FROM + pg_catalog.pg_constraint as c + ) AS c_unnest + INNER JOIN + columns col + USING (relation_id, column_number) + GROUP BY c_unnest.constraint_id + ), + constraint_referenced_columns AS + ( + SELECT + c_unnest.constraint_id, + array_agg(col.column_name) as referenced_columns + FROM + ( + SELECT + c.oid as constraint_id, + c.confrelid as relation_id, + unnest(c.confkey) as column_number + FROM + pg_catalog.pg_constraint as c + ) AS c_unnest + INNER JOIN + columns col + USING (relation_id, column_number) + GROUP BY c_unnest.constraint_id + ) + SELECT + c.oid as constraint_id, + c.connamespace as schema_id, + c.conname as constraint_name, + c.conrelid as relation_id, + c.contype as constraint_type, + con_cols.key_columns, + + -- These will be null for non-foreign- keys + c.confrelid as referenced_relation_id, + con_fcols.referenced_columns + FROM + pg_catalog.pg_constraint AS c + LEFT OUTER JOIN + constraint_columns as con_cols + ON (con_cols.constraint_id = c.oid) + LEFT OUTER JOIN + constraint_referenced_columns as con_fcols + ON (con_fcols.constraint_id = c.oid) + ), + uniqueness_constraints AS + ( + SELECT + constraint_id, + schema_id, + constraint_name, + relation_id, + key_columns + FROM + constraints AS c + WHERE + c.constraint_type in + ( + 'u', -- For uniqueness constraints + 'p' -- For primary keys + ) + ), + foreign_key_constraints AS + ( + SELECT + constraint_id, + schema_id, + constraint_name, + relation_id, + key_columns, + referenced_relation_id, + referenced_columns + FROM + constraints AS c + WHERE + c.constraint_type = 'f' -- For foreign-key constraints + ), + + base_type_representations AS + ( + SELECT + type_names.type_id AS type_id, + value AS representation + FROM + jsonb_each($6) + INNER JOIN + type_names + ON (key = name_in_ndc_schema) + ), + + enum_type_representations AS + ( + SELECT + enum_types.type_id, + jsonb_build_object( + 'enum', enum_types.enum_labels + ) + AS representation + FROM + enum_types + ), + + domain_type_representations AS + ( + SELECT + domain_types.type_id, + representation + FROM + domain_types + + INNER JOIN + base_type_representations + ON (domain_types.base_type = base_type_representations.type_id) + ), + + type_representations_json AS + ( + SELECT + type_representations.type_id, + type_representations.representation + AS result + FROM + ( + SELECT * FROM base_type_representations + UNION + SELECT * FROM domain_type_representations + UNION + SELECT * FROM enum_type_representations + ) + AS type_representations + ), + + comparison_functions_json AS + ( + -- Comparison Operators + WITH + comparison_infix_operators_mapped AS + ( + SELECT + map.exposed_name, + op.operator_name, + map.operator_kind, + op.argument1_type, + op.argument2_type, + op.argument1_cast_chain, + op.argument1_cast_chain_length, + op.argument2_cast_chain, + op.argument2_cast_chain_length, + op.is_infix -- always 't' + FROM + comparison_operators_cast_extended + AS op + INNER JOIN + operator_mappings + AS map + USING (operator_name) + WHERE + op.is_infix = 't' + ), + + comparison_prefix_operators AS + ( + SELECT + operator_name as exposed_name, + operator_name, + 'custom' as operator_kind, + argument1_type, + argument2_type, + argument1_cast_chain, + argument1_cast_chain_length, + argument2_cast_chain, + argument2_cast_chain_length, + is_infix -- always 'f' + FROM + comparison_operators_cast_extended + WHERE + is_infix = 'f' + ), + + -- We need to include `in` as a comparison operator in the schema, and + -- since it is syntax, it is not introspectable. Instead, we will check + -- if the scalar type defines an equals operator and if yes, we will + -- insert the `_in` operator as well. + comparison_operators_in AS + ( + SELECT + '_in' AS exposed_name, + 'IN' AS operator_name, + 'in' AS operator_kind, + type_id AS argument1_type, + type_id AS argument2_type, + '' AS argument1_cast_chain, + 0 AS argument1_cast_chain_length, + '' AS argument2_cast_chain, + 0 AS argument2_cast_chain_length, + true AS is_infix + FROM + scalar_types + ), + + comparison_operators_processed AS + ( + SELECT * FROM comparison_infix_operators_mapped + UNION + SELECT * FROM comparison_prefix_operators + UNION + SELECT * FROM comparison_operators_in + ), + + comparison_operators_by_first_arg AS + ( + SELECT + op.argument1_type, + jsonb_object_agg( + op.exposed_name, + jsonb_build_object( + 'operatorName', op.operator_name, + 'operatorKind', op.operator_kind, + 'argumentType', argument2_type_names.name_in_ndc_schema, + 'isInfix', op.is_infix, + + -- The below columns serve to aid with debugging + -- the selection of implicit casts. They do not + -- appear in the final metadata + 'argument1_cast_chain', + op.argument1_cast_chain, + 'argument2_cast_chain', + op.argument2_cast_chain + ) + ) + AS result + FROM + comparison_operators_processed + AS op + INNER JOIN + scalar_type_names + AS argument2_type_names + ON (op.argument2_type = argument2_type_names.type_id) + INNER JOIN + live_types + ON (live_types.type_id = argument2_type_names.type_id) + GROUP BY op.argument1_type + ) + SELECT + op.argument1_type as type_id, + op.result + FROM + comparison_operators_by_first_arg + AS op + ), + + -- Aggregation functions + aggregate_functions_json AS + ( + WITH + aggregate_by_argument_type AS + ( + SELECT + agg.proc_name, + agg.argument_type, + agg.argument_cast_chain, + return_type_names.name_in_ndc_schema as return_type_name + FROM + aggregates_cast_extended AS agg + INNER JOIN + scalar_type_names + AS return_type_names + ON (agg.return_type = return_type_names.type_id) + ORDER BY argument_type, proc_name, return_type + ) + SELECT + agg.argument_type as type_id, + jsonb_object_agg( + -- Since we are _not_ grouping by a key we need 'agg' to be ordered + -- and distinct to get deterministic results. + -- I.e. both functions 'f: A -> B' and 'f: A -> C' can coexist, but we + -- can only chose one with our current scheme + agg.proc_name, + jsonb_build_object( + 'returnType', + return_type_name, + 'argument_cast_chain', + argument_cast_chain + ) + ) AS result + FROM + aggregate_by_argument_type + AS agg + GROUP BY agg.argument_type + ), + + scalar_types_json AS + ( + WITH + scalar_type_definition AS + ( + SELECT + names.name_in_ndc_schema, + jsonb_build_object + ( + 'typeName', type_name, + 'schemaName', schema_name, + 'aggregateFunctions', coalesce(aggregates.result, '{}'::jsonb), + 'comparisonOperators', coalesce(comparisons.result, '{}'::jsonb), + 'typeRepresentation', representation.result + ) + AS result + FROM + scalar_type_names + AS names + INNER JOIN + live_types + USING (type_id) + LEFT OUTER JOIN + aggregate_functions_json + AS aggregates + USING (type_id) + LEFT OUTER JOIN + comparison_functions_json + AS comparisons + USING (type_id) + LEFT OUTER JOIN + type_representations_json + AS representation + USING (type_id) + ) + + SELECT + jsonb_object_agg + ( + name_in_ndc_schema, + result + ) + AS result + FROM + scalar_type_definition + ), + + tables_json AS + ( + WITH + + uniqueness_constraints_json AS + ( + SELECT + con.relation_id, + jsonb_object_agg( + con.constraint_name, + to_jsonb(con.key_columns) + ) + AS result + FROM uniqueness_constraints + AS con + GROUP BY relation_id + ), + + foreign_key_constraints_json AS + ( + WITH + column_mapping_unzipped AS + ( + -- We need to unnest both the key_columns and referenced_columns, + -- which essentially works like 'unzip'. + -- The result is one row per column appearing in the constraint, + -- which we can then re-group and aggregate as json. + SELECT + relation_id, + constraint_name, + unnest(key_columns) as key_column, + referenced_relation_id, + unnest(referenced_columns) as referenced_column + FROM + foreign_key_constraints + ), + + column_mapping_json AS + ( + SELECT + con.relation_id, + con.constraint_name, + con.referenced_relation_id, + -- The column mapping is an object '{: }' + json_object_agg( + con.key_column, + con.referenced_column + ) AS result + FROM + column_mapping_unzipped + AS con + GROUP BY + (relation_id, constraint_name, referenced_relation_id) + ) + + -- These take on the form: + -- { + -- : + -- { + -- foreign_table: + -- , + -- column_mapping: + -- { + -- : + -- } + -- } + -- } + SELECT + column_mapping_json.relation_id, + jsonb_object_agg( + column_mapping_json.constraint_name, + jsonb_build_object( + 'foreignSchema', + foreign_relation.schema_name, + 'foreignTable', + foreign_relation.relation_name, + 'columnMapping', + column_mapping_json.result + ) + ) + AS result + FROM + column_mapping_json + INNER JOIN + relation_names + AS foreign_relation + ON (foreign_relation.relation_id = column_mapping_json.referenced_relation_id) + GROUP BY column_mapping_json.relation_id + ), + + columns_json AS + ( + SELECT + c.relation_id, + jsonb_object_agg( + c.column_name, + jsonb_build_object( + 'name', + c.column_name, + 'type', + t.result, + 'nullable', + c.nullable, + 'hasDefault', + c.has_default, + 'isIdentity', + c.is_identity, + 'isGenerated', + c.is_generated, + 'description', + comm.description + ) + ) + AS result + FROM columns + AS c + LEFT OUTER JOIN column_types_json + AS t + USING (type_id) + LEFT OUTER JOIN column_comments + AS comm + USING (relation_id, column_name) + GROUP BY relation_id + HAVING + -- All columns must have a supported type for us to list this table. + bool_and(NOT t.result IS NULL) + ) + -- Tables and views + SELECT + jsonb_object_agg( + rel.name_in_ndc_schema, + jsonb_build_object( + 'schemaName', + rel.schema_name, + 'tableName', + rel.relation_name, + 'description', + comm.description, + 'columns', + columns_json.result, + 'uniquenessConstraints', + coalesce(uniqueness_constraints_json.result, '{}'::jsonb), + 'foreignRelations', + coalesce(foreign_key_constraints_json.result, '{}'::jsonb) + ) + ) + AS result + FROM + relation_names + AS rel + + LEFT OUTER JOIN + table_comments + AS comm + USING (relation_id) + + -- Columns + INNER JOIN + columns_json + USING (relation_id) + + -- Uniqueness constraints + LEFT OUTER JOIN + uniqueness_constraints_json + USING (relation_id) + + -- Foreign-key constraints. + LEFT OUTER JOIN + foreign_key_constraints_json + USING (relation_id) + ) + +SELECT + coalesce(tables_json.result, '{}'::jsonb) AS "Tables", + coalesce(scalar_types_json.result, '{}'::jsonb) AS "ScalarTypes", + coalesce(composite_types_json.result, '{}'::jsonb) AS "CompositeTypes" +FROM scalar_types_json +CROSS JOIN composite_types_json +CROSS JOIN tables_json +; + +-- Uncomment the following lines to just run the configuration query with reasonable default arguments +-- +-- EXECUTE configuration( +-- '{"information_schema", "tiger", "pg_catalog", "topology"}'::varchar[], +-- '{"public"}'::varchar[], +-- '{"public", "pg_catalog", "tiger"}'::varchar[], +-- '[ +-- {"operatorName": "=", "exposedName": "_eq", "operatorKind": "equal"}, +-- {"operatorName": "!=", "exposedName": "_neq", "operatorKind": "custom"}, +-- {"operatorName": "<=", "exposedName": "_lte", "operatorKind": "custom"}, +-- {"operatorName": ">", "exposedName": "_gt", "operatorKind": "custom"}, +-- {"operatorName": ">=", "exposedName": "_gte", "operatorKind": "custom"}, +-- {"operatorName": "<", "exposedName": "_lt", "operatorKind": "custom"}, +-- {"operatorName": "~~", "exposedName": "_like", "operatorKind": "custom"}, +-- {"operatorName": "!~~", "exposedName": "_nlike", "operatorKind": "custom"}, +-- {"operatorName": "~~*", "exposedName": "_ilike", "operatorKind": "custom"}, +-- {"operatorName": "!~~*", "exposedName": "_nilike", "operatorKind": "custom"}, +-- {"operatorName": "~", "exposedName": "_regex", "operatorKind": "custom"}, +-- {"operatorName": "!~", "exposedName": "_nregex", "operatorKind": "custom"}, +-- {"operatorName": "~*", "exposedName": "_iregex", "operatorKind": "custom"}, +-- {"operatorName": "!~*", "exposedName": "_niregex", "operatorKind": "custom"} +-- ]'::jsonb, +-- '{box_above,box_below, st_covers, st_coveredby}'::varchar[], +-- '{"int4": "integer"}'::jsonb, +-- '{bool}'::varchar[] +-- ); diff --git a/crates/configuration/src/version5/metadata/database.rs b/crates/configuration/src/version5/metadata/database.rs new file mode 100644 index 000000000..1897c0c8d --- /dev/null +++ b/crates/configuration/src/version5/metadata/database.rs @@ -0,0 +1,316 @@ +//! Metadata information regarding the database and tracked information. + +// This code was copied from a different place that predated the introduction of clippy to the +// project. Therefore we disregard certain clippy lints: +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; + +/// A name of a Scalar Type, as it appears in the NDC scheme. +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema)] +pub struct ScalarTypeName(pub String); + +/// The name of a Composite Type, as it appears in the NDC schema +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema)] +pub struct CompositeTypeName(pub String); + +/// The type of values that a column, field, or argument may take. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum Type { + ScalarType(ScalarTypeName), + CompositeType(CompositeTypeName), + ArrayType(Box), +} + +/// Information about types. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct Types { + pub scalar: ScalarTypes, + pub composite: CompositeTypes, +} + +/// Map of all known/occurring scalar types. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ScalarTypes(pub BTreeMap); + +/// Information about a scalar type. A scalar type is completely characterized by its name and the +/// operations you can do on it. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ScalarType { + pub type_name: String, + pub schema_name: String, + pub description: Option, + pub aggregate_functions: BTreeMap, + pub comparison_operators: BTreeMap, + pub type_representation: Option, +} + +/// Map of all known composite types. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct CompositeTypes(pub BTreeMap); + +/// Information about a composite type. These are very similar to tables, but with the crucial +/// difference that composite types do not support constraints (such as NOT NULL). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct CompositeType { + pub type_name: String, + pub schema_name: String, + pub fields: BTreeMap, + #[serde(default)] + pub description: Option, +} + +/// Information about a composite type field. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct FieldInfo { + pub field_name: String, + pub r#type: Type, + #[serde(default)] + pub description: Option, +} + +/// Represents a postgres binary comparison operator +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ComparisonOperator { + pub operator_name: String, + pub operator_kind: OperatorKind, + pub argument_type: ScalarTypeName, + + #[serde(default = "default_true")] + pub is_infix: bool, +} + +/// Is it a built-in operator, or a custom operator. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum OperatorKind { + Equal, + In, + Custom, +} + +/// This is quite unfortunate: https://github.com/serde-rs/serde/issues/368 +/// TL;DR: we can't set default literals for serde, so if we want 'is_infix' to +/// default to 'true', we have to set its default as a function that returns 'true'. +fn default_true() -> bool { + true +} + +/// Mapping from a "table" name to its information. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct TablesInfo(pub BTreeMap); + +/// Information about a database table (or any other kind of relation). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct TableInfo { + pub schema_name: String, + pub table_name: String, + pub columns: BTreeMap, + #[serde(default)] + pub uniqueness_constraints: UniquenessConstraints, + #[serde(default)] + pub foreign_relations: ForeignRelations, + #[serde(default)] + pub description: Option, +} + +/// Can this column contain null values +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum Nullable { + #[default] + Nullable, + NonNullable, +} + +/// Does this column have a default value. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum HasDefault { + #[default] + NoDefault, + HasDefault, +} + +/// Is this column an identity column. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum IsIdentity { + #[default] + NotIdentity, + IdentityByDefault, + IdentityAlways, +} + +/// Is this column a generated column. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum IsGenerated { + #[default] + NotGenerated, + Stored, +} + +/// Information about a database column. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ColumnInfo { + pub name: String, + pub r#type: Type, + #[serde(default)] + pub nullable: Nullable, + #[serde(skip_serializing_if = "does_not_have_default")] + #[serde(default)] + pub has_default: HasDefault, + #[serde(skip_serializing_if = "is_not_identity")] + #[serde(default)] + pub is_identity: IsIdentity, + #[serde(skip_serializing_if = "is_not_generated")] + #[serde(default)] + pub is_generated: IsGenerated, + #[serde(default)] + pub description: Option, +} + +fn does_not_have_default(has_default: &HasDefault) -> bool { + matches!(has_default, HasDefault::NoDefault) +} + +fn is_not_identity(is_identity: &IsIdentity) -> bool { + matches!(is_identity, IsIdentity::NotIdentity) +} + +fn is_not_generated(is_generated: &IsGenerated) -> bool { + matches!(is_generated, IsGenerated::NotGenerated) +} + +/// A mapping from the name of a unique constraint to its value. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct UniquenessConstraints(pub BTreeMap); + +/// The set of columns that make up a uniqueness constraint. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct UniquenessConstraint(pub BTreeSet); + +/// A mapping from the name of a foreign key constraint to its value. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ForeignRelations(pub BTreeMap); + +/// A foreign key constraint. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ForeignRelation { + #[serde(skip_serializing_if = "Option::is_none")] + pub foreign_schema: Option, + pub foreign_table: String, + pub column_mapping: BTreeMap, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct AggregateFunction { + pub return_type: ScalarTypeName, +} + +/// The type representations that guide introspection. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct TypeRepresentations(pub BTreeMap); + +/// Type representation of a scalar type. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum TypeRepresentation { + /// JSON booleans + Boolean, + /// Any JSON string + String, + /// float4 + Float32, + /// float8 + Float64, + /// int2 + Int16, + /// int4 + Int32, + /// int8 as integer + Int64, + /// int8 as string + Int64AsString, + /// numeric + BigDecimal, + /// numeric as string + BigDecimalAsString, + + /// timestamp + Timestamp, + /// timestamp with timezone + Timestamptz, + /// time + Time, + /// time with timezone + Timetz, + /// date + Date, + /// uuid + UUID, + /// geography + Geography, + /// geometry + Geometry, + /// Any JSON number + Number, + /// Any JSON number, with no decimal part + Integer, + /// An arbitrary json. + Json, + /// One of the specified string values + Enum(Vec), +} + +// tests + +#[cfg(test)] +mod tests { + use std::collections::BTreeMap; + + use super::TypeRepresentation; + + #[test] + fn parse_type_representations() { + assert_eq!( + serde_json::from_str::>( + r#"{"int4": "integer", "card_suit": {"enum": ["hearts", "clubs", "diamonds", "spades"]}}"# + ) + .unwrap(), + + [( + "int4".to_string(), + TypeRepresentation::Integer + ), ( + "card_suit".to_string(), + TypeRepresentation::Enum(vec![ + "hearts".into(), + "clubs".into(), + "diamonds".into(), + "spades".into() + ]) + )] + .into() + + ); + } +} diff --git a/crates/configuration/src/version5/metadata/mod.rs b/crates/configuration/src/version5/metadata/mod.rs new file mode 100644 index 000000000..75500f5d3 --- /dev/null +++ b/crates/configuration/src/version5/metadata/mod.rs @@ -0,0 +1,24 @@ +//! Metadata information regarding the database and tracked information. + +pub mod database; +pub mod mutations; +pub mod native_operations; + +// re-export without modules +pub use database::*; +pub use native_operations::*; + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +/// Metadata information. +#[derive(Clone, PartialEq, Eq, Debug, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct Metadata { + #[serde(default)] + pub tables: TablesInfo, + #[serde(default)] + pub types: Types, + #[serde(default)] + pub native_operations: NativeOperations, +} diff --git a/crates/configuration/src/version5/metadata/mutations.rs b/crates/configuration/src/version5/metadata/mutations.rs new file mode 100644 index 000000000..a5208a671 --- /dev/null +++ b/crates/configuration/src/version5/metadata/mutations.rs @@ -0,0 +1,12 @@ +//! Generated mutations-related metadata information. + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +/// Which version of the generated mutations will be included in the schema +#[derive(Debug, PartialEq, Eq, Clone, Copy, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub enum MutationsVersion { + V1, + V2, +} diff --git a/crates/configuration/src/version5/metadata/native_operations.rs b/crates/configuration/src/version5/metadata/native_operations.rs new file mode 100644 index 000000000..fac88eb5c --- /dev/null +++ b/crates/configuration/src/version5/metadata/native_operations.rs @@ -0,0 +1,375 @@ +//! Metadata information regarding native queries. + +// This code was copied from a different place that predated the introduction of clippy to the +// project. Therefore we disregard certain clippy lints: +use super::database::*; + +use query_engine_sql::sql; + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::fs; + +// Types + +/// Metadata information of Native Operations. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct NativeOperations { + /// Native Queries. + pub queries: NativeQueries, + /// Native Mutations. + pub mutations: NativeQueries, +} + +/// Metadata information of Native Operations. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct NativeQueries(pub BTreeMap); + +/// Information about a Native Operation +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct NativeQueryInfo { + /// SQL expression to use for the Native Operation. + /// We can interpolate values using `{{variable_name}}` syntax, + /// such as `SELECT * FROM authors WHERE name = {{author_name}}` + pub sql: NativeQuerySqlEither, + /// Columns returned by the Native Operation + pub columns: BTreeMap, + #[serde(default)] + /// Names and types of arguments that can be passed to this Native Operation + pub arguments: BTreeMap, + #[serde(default)] + pub description: Option, +} + +/// Information about a native query column. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ReadOnlyColumnInfo { + pub name: String, + pub r#type: Type, + #[serde(default)] + pub nullable: Nullable, + #[serde(default)] + pub description: Option, +} + +/// This type contains information that still needs to be resolved. +/// After deserializing, we expect the value to be "external", +/// and after a subsequent step where we read from files, +/// they should all be converted to NativeQuerySql. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[serde(from = "NativeQuerySqlExternal")] +#[serde(into = "NativeQuerySqlExternal")] +pub enum NativeQuerySqlEither { + NativeQuerySql(NativeQuerySql), + NativeQuerySqlExternal(NativeQuerySqlExternal), +} + +impl NativeQuerySqlEither { + /// Extract the actual native query sql from this type. + /// If this happens before reading a file, it will fail with an error. + pub fn sql(self) -> Result { + match self { + NativeQuerySqlEither::NativeQuerySql( + NativeQuerySql::Inline { sql } | NativeQuerySql::FromFile { sql, .. }, + ) => Ok(sql), + NativeQuerySqlEither::NativeQuerySqlExternal( + NativeQuerySqlExternal::Inline { inline } + | NativeQuerySqlExternal::InlineUntagged(inline), + ) => Ok(inline), + NativeQuerySqlEither::NativeQuerySqlExternal(NativeQuerySqlExternal::File { + .. + }) => Err("not all native query sql files were read during parsing".to_string()), + } + } +} + +impl From for NativeQuerySqlEither { + /// We use this to deserialize. + fn from(value: NativeQuerySqlExternal) -> Self { + NativeQuerySqlEither::NativeQuerySqlExternal(value) + } +} + +impl From for NativeQuerySqlExternal { + /// We use this to serialize. + fn from(value: NativeQuerySqlEither) -> Self { + match value { + NativeQuerySqlEither::NativeQuerySqlExternal(value) => value, + NativeQuerySqlEither::NativeQuerySql(value) => value.into(), + } + } +} + +/// A Native Operation SQL after file resolution. +/// This is the underlying type of the `NativeQuerySqlEither` variant with the same name +/// that is expected in the metadata when translating requests. A subsequent phase after de-serializing +/// Should convert NativeQuerySqlExternal values to values of this type. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum NativeQuerySql { + FromFile { + file: std::path::PathBuf, + sql: NativeQueryParts, + }, + Inline { + sql: NativeQueryParts, + }, +} + +impl NativeQuerySql { + /// Extract the native query sql expression. + pub fn sql(self) -> NativeQueryParts { + match self { + NativeQuerySql::Inline { sql } | NativeQuerySql::FromFile { sql, .. } => sql, + } + } +} + +// We use this type as an intermediate representation for serialization/deserialization +// of native query sql location/expression. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +#[serde(untagged)] +/// Native Operation SQL location. +pub enum NativeQuerySqlExternal { + /// Refer to an external Native Operation SQL file. + File { + /// Relative path to a sql file. + file: std::path::PathBuf, + }, + /// Inline Native Operation SQL string. + Inline { + /// An inline Native Operation SQL string. + inline: NativeQueryParts, + }, + InlineUntagged( + /// An inline Native Operation SQL string. + NativeQueryParts, + ), +} + +impl NativeQuerySqlEither { + /// Convert an external native query sql type to NativeQuerySql, + /// including reading files from disk. + pub fn from_external( + &self, + absolute_configuration_directory: &std::path::Path, + ) -> Result { + match self { + // unexpected we get this, but ok. + NativeQuerySqlEither::NativeQuerySql(value) => Ok(value.clone()), + NativeQuerySqlEither::NativeQuerySqlExternal(external) => match external { + NativeQuerySqlExternal::File { file } => { + parse_native_query_from_file(absolute_configuration_directory, file) + } + NativeQuerySqlExternal::Inline { inline } + | NativeQuerySqlExternal::InlineUntagged(inline) => Ok(NativeQuerySql::Inline { + sql: inline.clone(), + }), + }, + } + } +} + +impl From for NativeQuerySqlExternal { + /// used for deserialization. + fn from(value: NativeQuerySql) -> Self { + match value { + NativeQuerySql::Inline { sql } => NativeQuerySqlExternal::Inline { inline: sql }, + NativeQuerySql::FromFile { file, .. } => NativeQuerySqlExternal::File { file }, + } + } +} + +impl JsonSchema for NativeQuerySqlEither { + fn schema_name() -> String { + "NativeQuerySql".to_string() + } + + fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema { + NativeQuerySqlExternal::json_schema(gen) + } +} + +/// A part of a Native Operation text, either raw text or a parameter. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum NativeQueryPart { + /// A raw text part + Text(String), + /// A parameter + Parameter(String), +} + +/// A Native Operation SQL parts after parsing. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(from = "String")] +#[serde(into = "String")] +pub struct NativeQueryParts(pub Vec); + +impl From for NativeQueryParts { + /// Used for de-serialization. + fn from(value: String) -> Self { + parse_native_query(&value) + } +} + +impl From for String { + /// Used for serialization. + fn from(value: NativeQueryParts) -> Self { + let mut sql: String = String::new(); + for part in &value.0 { + match part { + NativeQueryPart::Text(text) => sql.push_str(text.as_str()), + NativeQueryPart::Parameter(param) => { + sql.push_str(format!("{{{{{param}}}}}").as_str()); + } + } + } + sql + } +} + +impl NativeQueryParts { + pub fn to_sql(&self) -> sql::string::SQL { + let mut sql = sql::string::SQL::new(); + + for part in &self.0 { + match part { + NativeQueryPart::Text(text) => sql.append_syntax(text), + NativeQueryPart::Parameter(param) => { + sql.append_param(sql::string::Param::Variable(param.to_string())); + } + } + } + + sql + } +} + +impl JsonSchema for NativeQueryParts { + fn schema_name() -> String { + "InlineNativeQuerySql".to_string() + } + + fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema { + String::json_schema(gen) + } +} + +// Parsing + +/// Read a file a parse it into native query parts. +pub fn parse_native_query_from_file( + absolute_configuration_directory: &std::path::Path, + file: &std::path::Path, +) -> Result { + let contents: String = match fs::read_to_string(absolute_configuration_directory.join(file)) { + Ok(ok) => Ok(ok), + Err(err) => Err(format!("{}: {}", file.display(), err)), + }?; + let sql = parse_native_query(&contents); + Ok(NativeQuerySql::FromFile { + file: file.to_path_buf(), + sql, + }) +} + +/// Parse a native query into parts where variables have the syntax `{{}}`. +pub fn parse_native_query(string: &str) -> NativeQueryParts { + let vec: Vec> = string + .split("{{") + .map(|part| match part.split_once("}}") { + None => vec![NativeQueryPart::Text(part.to_string())], + Some((var, text)) => { + if text.is_empty() { + vec![NativeQueryPart::Parameter(var.to_string())] + } else { + vec![ + NativeQueryPart::Parameter(var.to_string()), + NativeQueryPart::Text(text.to_string()), + ] + } + } + }) + .collect(); + NativeQueryParts(vec.concat()) +} + +// tests + +#[cfg(test)] +mod tests { + use super::{parse_native_query, NativeQueryPart, NativeQueryParts, NativeQuerySqlExternal}; + + #[test] + fn no_parameters() { + assert_eq!( + parse_native_query("select 1"), + NativeQueryParts(vec![NativeQueryPart::Text("select 1".to_string())]) + ); + } + + #[test] + fn one_parameter() { + assert_eq!( + parse_native_query("select * from t where {{name}} = name"), + NativeQueryParts(vec![ + NativeQueryPart::Text("select * from t where ".to_string()), + NativeQueryPart::Parameter("name".to_string()), + NativeQueryPart::Text(" = name".to_string()), + ]) + ); + } + + #[test] + fn multiple_parameters() { + assert_eq!( + parse_native_query("select * from t where id = {{id}} and {{name}} = {{other_name}}"), + NativeQueryParts(vec![ + NativeQueryPart::Text("select * from t where id = ".to_string()), + NativeQueryPart::Parameter("id".to_string()), + NativeQueryPart::Text(" and ".to_string()), + NativeQueryPart::Parameter("name".to_string()), + NativeQueryPart::Text(" = ".to_string()), + NativeQueryPart::Parameter("other_name".to_string()), + ]) + ); + } + + #[test] + fn one_parameter_and_curly_text() { + assert_eq!( + parse_native_query("select * from t where {{name}} = '{name}'"), + NativeQueryParts(vec![ + NativeQueryPart::Text("select * from t where ".to_string()), + NativeQueryPart::Parameter("name".to_string()), + NativeQueryPart::Text(" = '{name}'".to_string()), + ]) + ); + } + + #[test] + fn parse_inline_untagged() { + assert_eq!( + serde_json::from_str::(r#""select 1""#).unwrap(), + NativeQuerySqlExternal::InlineUntagged(NativeQueryParts(vec![NativeQueryPart::Text( + "select 1".to_string() + )])) + ); + } + + #[test] + fn parse_inline_tagged() { + assert_eq!( + serde_json::from_str::(r#"{ "inline": "select 1" }"#).unwrap(), + NativeQuerySqlExternal::Inline { + inline: NativeQueryParts(vec![NativeQueryPart::Text("select 1".to_string())]) + } + ); + } +} diff --git a/crates/configuration/src/version5/mod.rs b/crates/configuration/src/version5/mod.rs new file mode 100644 index 000000000..2de3f8a7d --- /dev/null +++ b/crates/configuration/src/version5/mod.rs @@ -0,0 +1,300 @@ +//! Internal Configuration and state for our connector. + +mod comparison; +pub mod connection_settings; +pub mod metadata; +pub mod native_operations; +mod options; +mod to_runtime_configuration; +mod upgrade_from_v4; + +use std::borrow::Cow; +use std::collections::HashSet; +use std::path::Path; +pub use to_runtime_configuration::make_runtime_configuration; +pub use upgrade_from_v4::upgrade_from_v4; + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use sqlx::postgres::PgConnection; +use sqlx::{Connection, Executor, Row}; +use tokio::fs; +use tracing::{info_span, Instrument}; + +use metadata::database; + +use crate::environment::Environment; +use crate::error::{ParseConfigurationError, WriteParsedConfigurationError}; +use crate::values::{ConnectionUri, Secret}; + +const CONFIGURATION_FILENAME: &str = "configuration.json"; +const CONFIGURATION_JSONSCHEMA_FILENAME: &str = "schema.json"; +const CONFIGURATION_QUERY: &str = include_str!("introspection.sql"); + +/// Initial configuration, just enough to connect to a database and elaborate a full +/// 'Configuration'. +#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct ParsedConfiguration { + pub version: Version, + /// Jsonschema of the configuration format. + #[serde(rename = "$schema")] + #[serde(default)] + pub schema: Option, + /// Database connection settings. + #[serde(default = "connection_settings::DatabaseConnectionSettings::empty")] + pub connection_settings: connection_settings::DatabaseConnectionSettings, + /// Connector metadata. + #[serde(default)] + pub metadata: metadata::Metadata, + /// Database introspection options. + #[serde(default)] + pub introspection_options: options::IntrospectionOptions, + /// Which version of the generated mutation procedures to include in the schema response + #[serde(default)] + pub mutations_version: Option, +} + +#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, JsonSchema)] +pub enum Version { + #[serde(rename = "5")] + This, +} + +impl ParsedConfiguration { + pub fn empty() -> Self { + Self { + version: Version::This, + schema: Some(CONFIGURATION_JSONSCHEMA_FILENAME.to_string()), + connection_settings: connection_settings::DatabaseConnectionSettings::empty(), + metadata: metadata::Metadata::default(), + introspection_options: options::IntrospectionOptions::default(), + // we'll change this to `Some(MutationsVersions::V1)` when we + // want to "release" this behaviour + mutations_version: None, + } + } + + /// Extract the connection uri from the configuration + ENV if needed. + pub fn get_connection_uri(&self) -> Result { + let connection_uri = self.connection_settings.connection_uri.clone(); + + match connection_uri.0 { + super::values::Secret::Plain(connection_string) => Ok(connection_string), + super::values::Secret::FromEnvironment { variable } => { + Ok(std::env::var(variable.to_string())?) + } + } + } +} + +fn get_type_ndc_name(r#type: &metadata::Type) -> &str { + match r#type { + metadata::Type::CompositeType(ct) => ct.0.as_str(), + metadata::Type::ScalarType(t) => t.0.as_str(), + metadata::Type::ArrayType(arr_ty) => get_type_ndc_name(arr_ty), + } +} + +/// In order to ensure that our schema ends up including exactly the relevant types we need to +/// inform the introspection query of the types that may appear in native queries, such that they +/// may be included. +fn native_operations_field_types(native_operations: &metadata::NativeOperations) -> Vec { + let mut result: HashSet<&str> = HashSet::new(); + + for operations in [&native_operations.queries, &native_operations.mutations] { + for native_query in operations.0.values() { + for argument in native_query.arguments.values() { + result.insert(get_type_ndc_name(&argument.r#type)); + } + + for column in native_query.columns.values() { + result.insert(get_type_ndc_name(&column.r#type)); + } + } + } + + result + .iter() + .map(|t| (*t).to_string()) + .collect::>() +} + +/// Construct the NDC metadata configuration by introspecting the database. +pub async fn introspect( + args: ParsedConfiguration, + environment: impl Environment, +) -> anyhow::Result { + let uri = match &args.connection_settings.connection_uri { + ConnectionUri(Secret::Plain(value)) => Cow::Borrowed(value), + ConnectionUri(Secret::FromEnvironment { variable }) => { + Cow::Owned(environment.read(variable)?) + } + }; + + let mut connection = PgConnection::connect(&uri) + .instrument(info_span!("Connect to database")) + .await?; + + let query = sqlx::query(CONFIGURATION_QUERY) + .bind(&args.introspection_options.excluded_schemas) + .bind(&args.introspection_options.unqualified_schemas_for_tables) + .bind( + &args + .introspection_options + .unqualified_schemas_for_types_and_procedures, + ) + .bind(serde_json::to_value( + &args.introspection_options.comparison_operator_mapping, + )?) + .bind( + &args + .introspection_options + .introspect_prefix_function_comparison_operators, + ) + .bind(serde_json::to_value( + &args.introspection_options.type_representations, + )?) + .bind(native_operations_field_types( + &args.metadata.native_operations, + )); + + let row = connection + .fetch_one(query) + .instrument(info_span!("Run introspection query")) + .await?; + + let (tables, scalar_types, composite_types) = async { + let tables: metadata::TablesInfo = serde_json::from_value(row.get(0))?; + let scalar_types: metadata::ScalarTypes = serde_json::from_value(row.get(1))?; + let composite_types: metadata::CompositeTypes = serde_json::from_value(row.get(2))?; + + // We need to specify the concrete return type explicitly so that rustc knows that it can + // be sent across an async boundary. + // (last verified with rustc 1.72.1) + Ok::<_, anyhow::Error>((tables, scalar_types, composite_types)) + } + .instrument(info_span!("Decode introspection result")) + .await?; + + Ok(ParsedConfiguration { + version: Version::This, + schema: args.schema, + connection_settings: args.connection_settings, + metadata: metadata::Metadata { + tables, + types: metadata::Types { + scalar: scalar_types, + composite: composite_types, + }, + native_operations: args.metadata.native_operations, + }, + introspection_options: args.introspection_options, + mutations_version: args.mutations_version, + }) +} + +/// Parse the configuration format from a directory. +pub async fn parse_configuration( + configuration_dir: impl AsRef, +) -> Result { + let configuration_file = configuration_dir.as_ref().join(CONFIGURATION_FILENAME); + + let configuration_file_contents = + fs::read_to_string(&configuration_file) + .await + .map_err(|err| { + ParseConfigurationError::IoErrorButStringified(format!( + "{}: {}", + &configuration_file.display(), + err + )) + })?; + + let mut parsed_config: ParsedConfiguration = serde_json::from_str(&configuration_file_contents) + .map_err(|error| ParseConfigurationError::ParseError { + file_path: configuration_file.clone(), + line: error.line(), + column: error.column(), + message: error.to_string(), + })?; + // look for native query sql file references and read from disk. + for operations in [ + &mut parsed_config.metadata.native_operations.queries, + &mut parsed_config.metadata.native_operations.mutations, + ] { + for native_query_sql in operations.0.values_mut() { + native_query_sql.sql = metadata::NativeQuerySqlEither::NativeQuerySql( + native_query_sql + .sql + .from_external(configuration_dir.as_ref()) + .map_err(ParseConfigurationError::IoErrorButStringified)?, + ); + } + } + + Ok(parsed_config) +} + +/// Write the parsed configuration into a directory on disk. +pub async fn write_parsed_configuration( + parsed_config: ParsedConfiguration, + out_dir: impl AsRef, +) -> Result<(), WriteParsedConfigurationError> { + let configuration_file = out_dir.as_ref().to_owned().join(CONFIGURATION_FILENAME); + fs::create_dir_all(out_dir.as_ref()).await?; + + // create the configuration file + fs::write( + configuration_file, + serde_json::to_string_pretty(&parsed_config) + .map_err(|e| WriteParsedConfigurationError::IoError(e.into()))? + + "\n", + ) + .await?; + + // look for native query sql file references and write them to disk. + for operations in [ + &parsed_config.metadata.native_operations.queries, + &parsed_config.metadata.native_operations.mutations, + ] { + for native_query_sql in operations.0.values() { + if let metadata::NativeQuerySqlEither::NativeQuerySql( + metadata::NativeQuerySql::FromFile { file, sql }, + ) = &native_query_sql.sql + { + if file.is_absolute() || file.starts_with("..") { + Err( + WriteParsedConfigurationError::WritingOutsideDestinationDir { + dir: out_dir.as_ref().to_owned(), + file: file.clone(), + }, + )?; + }; + + let native_query_file = out_dir.as_ref().to_owned().join(file); + if let Some(native_query_sql_dir) = native_query_file.parent() { + fs::create_dir_all(native_query_sql_dir).await?; + }; + fs::write(native_query_file, String::from(sql.clone())).await?; + }; + } + } + + // create the jsonschema file + let configuration_jsonschema_file_path = out_dir + .as_ref() + .to_owned() + .join(CONFIGURATION_JSONSCHEMA_FILENAME); + + let output = schemars::schema_for!(ParsedConfiguration); + fs::write( + &configuration_jsonschema_file_path, + serde_json::to_string_pretty(&output) + .map_err(|e| WriteParsedConfigurationError::IoError(e.into()))? + + "\n", + ) + .await?; + + Ok(()) +} diff --git a/crates/configuration/src/version5/native_operations.rs b/crates/configuration/src/version5/native_operations.rs new file mode 100644 index 000000000..74a104cfd --- /dev/null +++ b/crates/configuration/src/version5/native_operations.rs @@ -0,0 +1,220 @@ +//! Infer information about a Native Operation from a Native Operation SQL string. + +use std::collections::{BTreeMap, BTreeSet}; +use std::path::Path; + +use query_engine_sql::sql; + +use sqlx::Connection; +use sqlx::Executor; +use sqlx::{Column, PgConnection}; + +use super::metadata; +use tracing::{info_span, Instrument}; + +/// Query or Mutation. +#[derive(Clone, Debug, clap::ValueEnum)] +pub enum Kind { + Query, + Mutation, +} + +/// Take a SQL file containing a Native Operation, check against the database that it is valid, +/// and add it to the configuration if it is. +pub async fn create( + configuration: &super::ParsedConfiguration, + connection_string: &str, + operation_path: &Path, + operation_file_contents: &str, +) -> anyhow::Result { + // Connect to the db. + let mut connection = sqlx::PgConnection::connect(connection_string).await?; + + // Create an entry for a Native Operation and insert it into the configuration. + + // Read the SQL file and parse it. + let sql = super::metadata::parse_native_query(operation_file_contents).to_sql(); + + // Prepare the SQL against the DB. + let result = connection.describe(&sql.sql).await?; + + // Extract the arguments and columns information into data structures. + let mut arguments_to_oids = std::collections::BTreeMap::new(); + let mut columns_to_oids = std::collections::BTreeMap::new(); + + let Some(sqlx::Either::Left(ref result_parameters)) = result.parameters else { + anyhow::bail!("Internal error: sqlx params should always be a vector.") + }; + + if result_parameters.len() != sql.params.len() { + anyhow::bail!( + "Internal error: Parameters of native query and sql statement are not aligned." + ) + } + + // Fill the arguments list. + for (result_param, sql_param) in result_parameters.iter().zip(sql.params.iter()) { + let sql::string::Param::Variable(param_name) = sql_param else { + anyhow::bail!("Internal error: Native operation parameter was not a variable.") + }; + + let the_oid = result_param + .oid() + .ok_or(anyhow::anyhow!( + "Internal error: All sqlx TypeInfos should have an oid." + ))? + .0; + + arguments_to_oids.insert(param_name, i64::from(the_oid)); + } + + // Fill the columns list. + for (index, column) in result.columns.iter().enumerate() { + let the_oid = column + .type_info() + .oid() + .ok_or(anyhow::anyhow!( + "Internal error: All sqlx TypeInfos should have an oid." + ))? + .0; + let is_nullable = result.nullable(index).unwrap_or( + // If we don't know, we assume it is nullable. + true, + ); + + columns_to_oids.insert(column.name().to_string(), (i64::from(the_oid), is_nullable)); + } + + let mut oids: BTreeSet = arguments_to_oids.values().copied().collect(); + oids.extend::>(columns_to_oids.values().copied().map(|x| x.0).collect()); + let oids_vec: Vec<_> = oids.into_iter().collect(); + let oids_map = oids_to_typenames(configuration, connection_string, &oids_vec).await?; + + let mut arguments = BTreeMap::new(); + for (name, oid) in arguments_to_oids { + arguments.insert( + name.clone(), + metadata::ReadOnlyColumnInfo { + name: name.clone(), + r#type: metadata::Type::ScalarType(metadata::ScalarTypeName( + oids_map + .get(&oid) + .ok_or_else(|| anyhow::anyhow!("Internal error: oid not found in map."))? + .0 + .clone(), + )), + description: None, + // we don't have this information, so we assume not nullable. + nullable: metadata::Nullable::NonNullable, + }, + ); + } + let mut columns = BTreeMap::new(); + for (name, (oid, is_nullable)) in columns_to_oids { + columns.insert( + name.clone(), + metadata::ReadOnlyColumnInfo { + name: name.clone(), + r#type: metadata::Type::ScalarType(metadata::ScalarTypeName( + oids_map + .get(&oid) + .ok_or_else(|| anyhow::anyhow!("Internal error: oid not found in map."))? + .0 + .clone(), + )), + description: None, + nullable: if is_nullable { + metadata::Nullable::Nullable + } else { + metadata::Nullable::NonNullable + }, + }, + ); + } + + let new_native_operation = metadata::NativeQueryInfo { + sql: metadata::NativeQuerySqlEither::NativeQuerySqlExternal( + metadata::NativeQuerySqlExternal::File { + file: operation_path.to_path_buf(), + }, + ), + arguments, + columns, + description: None, + }; + + Ok(new_native_operation) +} + +/// Given a vector of OIDs, ask postgres to provide the equivalent type names. +pub async fn oids_to_typenames( + configuration: &super::ParsedConfiguration, + connection_string: &str, + oids: &Vec, +) -> Result, sqlx::Error> { + let mut connection = PgConnection::connect(connection_string) + .instrument(info_span!("Connect to database")) + .await?; + + let rows: Vec = sqlx::query_as(OID_QUERY) + .bind(oids) + .fetch_all(&mut connection) + .instrument(info_span!("Run oid lookup query")) + .await?; + + let mut oids_map: BTreeMap = BTreeMap::new(); + + // Reverse lookup the schema.typename and find the ndc type name, + // if we find all we can just add the nq and call it a day. + for row in rows { + let schema_name: String = row.schema_name; + let type_name: String = row.type_name; + let oid: i64 = row.oid.into(); + + let mut found = false; + for (scalar_type_name, info) in &configuration.metadata.types.scalar.0 { + if info.schema_name == schema_name && info.type_name == type_name { + oids_map.insert(oid, scalar_type_name.clone()); + found = true; + continue; + } + } + + // If we don't find it we generate a name which is either schema_typename + // or just typename depending if the schema is in the unqualified list or not, + // then add the nq and run the introspection. + if !found { + if configuration + .introspection_options + .unqualified_schemas_for_types_and_procedures + .contains(&schema_name) + { + oids_map.insert(oid, metadata::ScalarTypeName(type_name)); + } else { + oids_map.insert( + oid, + metadata::ScalarTypeName(format!("{schema_name}_{type_name}")), + ); + } + } + } + + Ok(oids_map) +} + +const OID_QUERY: &str = " +SELECT + typnamespace::regnamespace::text as schema_name, + typname as type_name, + oid::integer +FROM pg_type +WHERE oid in (SELECT unnest($1)) +"; + +/// Representation of a result row returned from the oid lookup query. +#[derive(Debug, sqlx::FromRow)] +struct OidQueryRow { + schema_name: String, + type_name: String, + oid: i32, +} diff --git a/crates/configuration/src/version5/options.rs b/crates/configuration/src/version5/options.rs new file mode 100644 index 000000000..b11b34678 --- /dev/null +++ b/crates/configuration/src/version5/options.rs @@ -0,0 +1,295 @@ +//! The part of the configuration that dictates how the rest is generated. + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +use super::comparison::ComparisonOperatorMapping; +use super::database::{ScalarTypeName, TypeRepresentation, TypeRepresentations}; + +/// Options which only influence how the configuration is updated. +#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, JsonSchema)] +#[serde(rename_all = "camelCase")] +pub struct IntrospectionOptions { + /// Schemas which are excluded from introspection. The default setting will exclude the + /// internal schemas of Postgres, Citus, Cockroach, and the PostGIS extension. + #[serde(default = "default_excluded_schemas")] + pub excluded_schemas: Vec, + /// The names of Tables and Views in these schemas will be returned unqualified. + /// The default setting will set the `public` schema as unqualified. + #[serde(default = "default_unqualified_schemas_for_tables")] + pub unqualified_schemas_for_tables: Vec, + /// The types and procedures in these schemas will be returned unqualified. + #[serde(default = "default_unqualified_schemas_for_types_and_procedures")] + pub unqualified_schemas_for_types_and_procedures: Vec, + /// The mapping of comparison operator names to apply when updating the configuration + #[serde(default = "ComparisonOperatorMapping::default_mappings")] + pub comparison_operator_mapping: Vec, + /// Which prefix functions (i.e., non-infix operators) to generate introspection metadata for. + /// + /// This list will accept any boolean-returning function taking two concrete scalar types as + /// arguments. + /// + /// The default includes comparisons for various build-in types as well as those of PostGIS. + #[serde(default = "default_introspect_prefix_function_comparison_operators")] + pub introspect_prefix_function_comparison_operators: Vec, + + /// The type representations to pick for base scalar types. + #[serde(default = "default_base_type_representations")] + pub type_representations: TypeRepresentations, +} + +impl Default for IntrospectionOptions { + fn default() -> IntrospectionOptions { + IntrospectionOptions { + excluded_schemas: default_excluded_schemas(), + unqualified_schemas_for_tables: default_unqualified_schemas_for_tables(), + unqualified_schemas_for_types_and_procedures: + default_unqualified_schemas_for_types_and_procedures(), + comparison_operator_mapping: ComparisonOperatorMapping::default_mappings(), + introspect_prefix_function_comparison_operators: + default_introspect_prefix_function_comparison_operators(), + type_representations: default_base_type_representations(), + } + } +} + +fn default_excluded_schemas() -> Vec { + vec![ + // From Postgres itself + "information_schema".to_string(), + "pg_catalog".to_string(), + // From PostGIS + "tiger".to_string(), + // From CockroachDB + "crdb_internal".to_string(), + // From Citus + "columnar".to_string(), + "columnar_internal".to_string(), + ] +} + +/// Collection names of tables in these schemas will be appear as unqualified. +fn default_unqualified_schemas_for_tables() -> Vec { + vec!["public".to_string()] +} + +/// Types, operators and procedures from these schemas will appear unqualified in the configuration. +fn default_unqualified_schemas_for_types_and_procedures() -> Vec { + vec![ + "public".to_string(), + "pg_catalog".to_string(), + "tiger".to_string(), + ] +} + +fn default_introspect_prefix_function_comparison_operators() -> Vec { + vec![ + "box_above".to_string(), + "box_below".to_string(), + "box_contain".to_string(), + "box_contain_pt".to_string(), + "box_contained".to_string(), + "box_left".to_string(), + "box_overabove".to_string(), + "box_overbelow".to_string(), + "box_overlap".to_string(), + "box_overleft".to_string(), + "box_overright".to_string(), + "box_right".to_string(), + "box_same".to_string(), + "circle_above".to_string(), + "circle_below".to_string(), + "circle_contain".to_string(), + "circle_contain_pt".to_string(), + "circle_contained".to_string(), + "circle_left".to_string(), + "circle_overabove".to_string(), + "circle_overbelow".to_string(), + "circle_overlap".to_string(), + "circle_overleft".to_string(), + "circle_overright".to_string(), + "circle_right".to_string(), + "circle_same".to_string(), + "contains_2d".to_string(), + "equals".to_string(), + "geography_overlaps".to_string(), + "geometry_above".to_string(), + "geometry_below".to_string(), + "geometry_contained_3d".to_string(), + "geometry_contains".to_string(), + "geometry_contains_3d".to_string(), + "geometry_contains_nd".to_string(), + "geometry_left".to_string(), + "geometry_overabove".to_string(), + "geometry_overbelow".to_string(), + "geometry_overlaps".to_string(), + "geometry_overlaps_3d".to_string(), + "geometry_overlaps_nd".to_string(), + "geometry_overleft".to_string(), + "geometry_overright".to_string(), + "geometry_right".to_string(), + "geometry_same".to_string(), + "geometry_same_3d".to_string(), + "geometry_same_nd".to_string(), + "geometry_within".to_string(), + "geometry_within_nd".to_string(), + "inet_same_family".to_string(), + "inter_lb".to_string(), + "inter_sb".to_string(), + "inter_sl".to_string(), + "is_contained_2d".to_string(), + "ishorizontal".to_string(), + "isparallel".to_string(), + "isperp".to_string(), + "isvertical".to_string(), + "jsonb_contained".to_string(), + "jsonb_contains".to_string(), + "jsonb_exists".to_string(), + "jsonb_path_exists_opr".to_string(), + "jsonb_path_match_opr".to_string(), + "line_intersect".to_string(), + "line_parallel".to_string(), + "line_perp".to_string(), + "lseg_intersect".to_string(), + "lseg_parallel".to_string(), + "lseg_perp".to_string(), + "network_overlap".to_string(), + "network_sub".to_string(), + "network_sup".to_string(), + "on_pb".to_string(), + "on_pl".to_string(), + "on_ppath".to_string(), + "on_ps".to_string(), + "on_sb".to_string(), + "on_sl".to_string(), + "overlaps_2d".to_string(), + "path_contain_pt".to_string(), + "path_inter".to_string(), + "point_above".to_string(), + "point_below".to_string(), + "point_horiz".to_string(), + "point_left".to_string(), + "point_right".to_string(), + "point_vert".to_string(), + "poly_above".to_string(), + "poly_below".to_string(), + "poly_contain".to_string(), + "poly_contain_pt".to_string(), + "poly_contained".to_string(), + "poly_left".to_string(), + "poly_overabove".to_string(), + "poly_overbelow".to_string(), + "poly_overlap".to_string(), + "poly_overleft".to_string(), + "poly_overright".to_string(), + "poly_right".to_string(), + "poly_same".to_string(), + "pt_contained_poly".to_string(), + "st_3dintersects".to_string(), + "st_contains".to_string(), + "st_containsproperly".to_string(), + "st_coveredby".to_string(), + "st_covers".to_string(), + "st_crosses".to_string(), + "st_disjoint".to_string(), + "st_equals".to_string(), + "st_intersects".to_string(), + "st_isvalid".to_string(), + "st_orderingequals".to_string(), + "st_overlaps".to_string(), + "st_relatematch".to_string(), + "st_touches".to_string(), + "st_within".to_string(), + "starts_with".to_string(), + "ts_match_qv".to_string(), + "ts_match_tq".to_string(), + "ts_match_tt".to_string(), + "ts_match_vq".to_string(), + "tsq_mcontained".to_string(), + "tsq_mcontains".to_string(), + "xmlexists".to_string(), + "xmlvalidate".to_string(), + "xpath_exists".to_string(), + ] +} + +fn default_base_type_representations() -> TypeRepresentations { + TypeRepresentations( + [ + // Bit strings: + // https://www.postgresql.org/docs/current/datatype-bit.html + // https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-BIT-STRINGS + // + // We hint these to String, meaning a sequence of '0' and '1' chars, but more choices are + // possible. + ( + ScalarTypeName("bit".to_string()), + TypeRepresentation::String, + ), + ( + ScalarTypeName("bool".to_string()), + TypeRepresentation::Boolean, + ), + ( + ScalarTypeName("bpchar".to_string()), + TypeRepresentation::String, + ), + ( + ScalarTypeName("char".to_string()), + TypeRepresentation::String, + ), + (ScalarTypeName("date".to_string()), TypeRepresentation::Date), + ( + ScalarTypeName("float4".to_string()), + TypeRepresentation::Float32, + ), + ( + ScalarTypeName("float8".to_string()), + TypeRepresentation::Float64, + ), + ( + ScalarTypeName("int2".to_string()), + TypeRepresentation::Int16, + ), + ( + ScalarTypeName("int4".to_string()), + TypeRepresentation::Int32, + ), + ( + ScalarTypeName("int8".to_string()), + // ndc-spec defines that Int64 has the json representation of a string. + // This is not what we do now and is a breaking change. + // This will need to be changed in the future. In the meantime, we report + // The type representation to be json. + TypeRepresentation::Int64AsString, + ), + ( + ScalarTypeName("numeric".to_string()), + TypeRepresentation::BigDecimalAsString, + ), + ( + ScalarTypeName("text".to_string()), + TypeRepresentation::String, + ), + (ScalarTypeName("time".to_string()), TypeRepresentation::Time), + ( + ScalarTypeName("timestamp".to_string()), + TypeRepresentation::Timestamp, + ), + ( + ScalarTypeName("timestamptz".to_string()), + TypeRepresentation::Timestamptz, + ), + ( + ScalarTypeName("timetz".to_string()), + TypeRepresentation::Timetz, + ), + (ScalarTypeName("uuid".to_string()), TypeRepresentation::UUID), + ( + ScalarTypeName("varchar".to_string()), + TypeRepresentation::String, + ), + ] + .into(), + ) +} diff --git a/crates/configuration/src/version5/to_runtime_configuration.rs b/crates/configuration/src/version5/to_runtime_configuration.rs new file mode 100644 index 000000000..c327cc277 --- /dev/null +++ b/crates/configuration/src/version5/to_runtime_configuration.rs @@ -0,0 +1,512 @@ +//! Convert the parsed configuration metadata to internal engine metadata +//! That can be used by the connector at runtime. + +use std::collections::BTreeMap; + +use super::metadata; +use super::ParsedConfiguration; +use crate::environment::Environment; +use crate::error::MakeRuntimeConfigurationError; +use crate::values::{ConnectionUri, Secret}; +use crate::VersionTag; + +/// Convert the parsed configuration metadata to internal engine metadata +/// That can be used by the connector at runtime. +pub fn make_runtime_configuration( + parsed_config: ParsedConfiguration, + environment: impl Environment, +) -> Result { + let connection_uri = match parsed_config.connection_settings.connection_uri { + ConnectionUri(Secret::Plain(uri)) => Ok(uri), + ConnectionUri(Secret::FromEnvironment { variable }) => { + environment.read(&variable).map_err(|error| { + MakeRuntimeConfigurationError::MissingEnvironmentVariable { + file_path: "configuration.json".into(), + message: error.to_string(), + } + }) + } + }?; + Ok(crate::Configuration { + metadata: convert_metadata(parsed_config.metadata), + pool_settings: parsed_config.connection_settings.pool_settings, + connection_uri, + isolation_level: parsed_config.connection_settings.isolation_level, + mutations_version: convert_mutations_version(parsed_config.mutations_version), + configuration_version_tag: VersionTag::Version4, + }) +} + +/// Convert the metadata specified in the parsed configuration to an engine metadata. +/// This function is used by tests as well +pub fn convert_metadata(metadata: metadata::Metadata) -> query_engine_metadata::metadata::Metadata { + query_engine_metadata::metadata::Metadata { + tables: convert_tables(metadata.tables), + scalar_types: convert_scalar_types(metadata.types.scalar), + composite_types: convert_composite_types(metadata.types.composite), + native_operations: convert_native_operations(metadata.native_operations), + } +} + +fn convert_scalar_types( + scalar_types: metadata::ScalarTypes, +) -> query_engine_metadata::metadata::ScalarTypes { + query_engine_metadata::metadata::ScalarTypes( + scalar_types + .0 + .into_iter() + .map(|(scalar_type_name, scalar_type)| { + ( + convert_scalar_type_name(scalar_type_name), + query_engine_metadata::metadata::ScalarType { + type_name: scalar_type.type_name, + schema_name: Some(scalar_type.schema_name), + description: scalar_type.description, + aggregate_functions: scalar_type + .aggregate_functions + .into_iter() + .map(|(k, v)| (k, convert_aggregate_function(v))) + .collect(), + comparison_operators: scalar_type + .comparison_operators + .into_iter() + .map(|(k, v)| (k, convert_comparison_operator(v))) + .collect(), + type_representation: scalar_type + .type_representation + .map(convert_type_representation), + }, + ) + }) + .collect(), + ) +} + +fn convert_scalar_type_name( + scalar_type_name: metadata::ScalarTypeName, +) -> query_engine_metadata::metadata::ScalarTypeName { + query_engine_metadata::metadata::ScalarTypeName(scalar_type_name.0) +} + +fn convert_aggregate_function( + aggregate_function: metadata::AggregateFunction, +) -> query_engine_metadata::metadata::AggregateFunction { + query_engine_metadata::metadata::AggregateFunction { + return_type: convert_scalar_type_name(aggregate_function.return_type), + } +} + +fn convert_native_operations( + native_operations: metadata::NativeOperations, +) -> query_engine_metadata::metadata::NativeOperations { + let mut queries = BTreeMap::new(); + let mut mutations = BTreeMap::new(); + + for (name, query) in native_operations.queries.0 { + queries.insert(name, convert_native_query_info(query)); + } + for (name, mutation) in native_operations.mutations.0 { + mutations.insert(name, convert_native_query_info(mutation)); + } + + query_engine_metadata::metadata::NativeOperations { + queries: query_engine_metadata::metadata::NativeQueries(queries), + mutations: query_engine_metadata::metadata::NativeQueries(mutations), + } +} + +fn convert_native_query_info( + native_query_info: metadata::NativeQueryInfo, +) -> query_engine_metadata::metadata::NativeQueryInfo { + query_engine_metadata::metadata::NativeQueryInfo { + sql: convert_native_query_sql_either(native_query_info.sql), + columns: native_query_info + .columns + .into_iter() + .map(|(k, v)| (k, convert_read_only_column_info(v))) + .collect(), + arguments: native_query_info + .arguments + .into_iter() + .map(|(k, v)| (k, convert_read_only_column_info(v))) + .collect(), + description: native_query_info.description, + } +} + +fn convert_read_only_column_info( + read_only_column_info: metadata::ReadOnlyColumnInfo, +) -> query_engine_metadata::metadata::ReadOnlyColumnInfo { + query_engine_metadata::metadata::ReadOnlyColumnInfo { + name: read_only_column_info.name, + r#type: convert_type(read_only_column_info.r#type), + nullable: convert_nullable(&read_only_column_info.nullable), + description: read_only_column_info.description, + } +} + +fn convert_nullable(nullable: &metadata::Nullable) -> query_engine_metadata::metadata::Nullable { + match nullable { + metadata::Nullable::Nullable => query_engine_metadata::metadata::Nullable::Nullable, + metadata::Nullable::NonNullable => query_engine_metadata::metadata::Nullable::NonNullable, + } +} + +fn convert_type(r#type: metadata::Type) -> query_engine_metadata::metadata::Type { + match r#type { + metadata::Type::ScalarType(t) => { + query_engine_metadata::metadata::Type::ScalarType(convert_scalar_type_name(t)) + } + metadata::Type::CompositeType(t) => query_engine_metadata::metadata::Type::CompositeType( + query_engine_metadata::metadata::CompositeTypeName(t.0), + ), + metadata::Type::ArrayType(t) => { + query_engine_metadata::metadata::Type::ArrayType(Box::new(convert_type(*t))) + } + } +} + +fn convert_native_query_sql_either( + sql: metadata::NativeQuerySqlEither, +) -> query_engine_metadata::metadata::NativeQuerySqlEither { + match sql { + metadata::NativeQuerySqlEither::NativeQuerySql(internal_sql) => { + query_engine_metadata::metadata::NativeQuerySqlEither::NativeQuerySql( + convert_native_query_sql_internal(internal_sql), + ) + } + metadata::NativeQuerySqlEither::NativeQuerySqlExternal(external_sql) => { + query_engine_metadata::metadata::NativeQuerySqlEither::NativeQuerySqlExternal( + convert_native_query_sql_external(external_sql), + ) + } + } +} + +fn convert_native_query_sql_internal( + internal_sql: metadata::NativeQuerySql, +) -> query_engine_metadata::metadata::NativeQuerySql { + match internal_sql { + metadata::NativeQuerySql::FromFile { file, sql } => { + query_engine_metadata::metadata::NativeQuerySql::FromFile { + file, + sql: convert_native_query_parts(sql), + } + } + metadata::NativeQuerySql::Inline { sql } => { + query_engine_metadata::metadata::NativeQuerySql::Inline { + sql: convert_native_query_parts(sql), + } + } + } +} + +fn convert_native_query_sql_external( + external_sql: metadata::NativeQuerySqlExternal, +) -> query_engine_metadata::metadata::NativeQuerySqlExternal { + match external_sql { + metadata::NativeQuerySqlExternal::File { file } => { + query_engine_metadata::metadata::NativeQuerySqlExternal::File { file } + } + metadata::NativeQuerySqlExternal::Inline { inline } => { + query_engine_metadata::metadata::NativeQuerySqlExternal::Inline { + inline: convert_native_query_parts(inline), + } + } + metadata::NativeQuerySqlExternal::InlineUntagged(parts) => { + query_engine_metadata::metadata::NativeQuerySqlExternal::InlineUntagged( + convert_native_query_parts(parts), + ) + } + } +} + +fn convert_native_query_parts( + inline: metadata::NativeQueryParts, +) -> query_engine_metadata::metadata::NativeQueryParts { + query_engine_metadata::metadata::NativeQueryParts( + inline + .0 + .into_iter() + .map(convert_native_query_part) + .collect(), + ) +} + +fn convert_native_query_part( + native_query_part: metadata::NativeQueryPart, +) -> query_engine_metadata::metadata::NativeQueryPart { + match native_query_part { + metadata::NativeQueryPart::Text(t) => { + query_engine_metadata::metadata::NativeQueryPart::Text(t) + } + metadata::NativeQueryPart::Parameter(p) => { + query_engine_metadata::metadata::NativeQueryPart::Parameter(p) + } + } +} + +fn convert_type_representation( + type_representation: metadata::TypeRepresentation, +) -> query_engine_metadata::metadata::TypeRepresentation { + match type_representation { + metadata::TypeRepresentation::Boolean => { + query_engine_metadata::metadata::TypeRepresentation::Boolean + } + metadata::TypeRepresentation::String => { + query_engine_metadata::metadata::TypeRepresentation::String + } + metadata::TypeRepresentation::Float32 => { + query_engine_metadata::metadata::TypeRepresentation::Float32 + } + metadata::TypeRepresentation::Float64 => { + query_engine_metadata::metadata::TypeRepresentation::Float64 + } + metadata::TypeRepresentation::Int16 => { + query_engine_metadata::metadata::TypeRepresentation::Int16 + } + metadata::TypeRepresentation::Int32 => { + query_engine_metadata::metadata::TypeRepresentation::Int32 + } + metadata::TypeRepresentation::Int64 => { + query_engine_metadata::metadata::TypeRepresentation::Int64 + } + metadata::TypeRepresentation::Int64AsString => { + query_engine_metadata::metadata::TypeRepresentation::Int64AsString + } + metadata::TypeRepresentation::BigDecimal => { + query_engine_metadata::metadata::TypeRepresentation::BigDecimal + } + metadata::TypeRepresentation::BigDecimalAsString => { + query_engine_metadata::metadata::TypeRepresentation::BigDecimalAsString + } + metadata::TypeRepresentation::Timestamp => { + query_engine_metadata::metadata::TypeRepresentation::Timestamp + } + metadata::TypeRepresentation::Timestamptz => { + query_engine_metadata::metadata::TypeRepresentation::Timestamptz + } + metadata::TypeRepresentation::Time => { + query_engine_metadata::metadata::TypeRepresentation::Time + } + metadata::TypeRepresentation::Timetz => { + query_engine_metadata::metadata::TypeRepresentation::Timetz + } + metadata::TypeRepresentation::Date => { + query_engine_metadata::metadata::TypeRepresentation::Date + } + metadata::TypeRepresentation::UUID => { + query_engine_metadata::metadata::TypeRepresentation::UUID + } + metadata::TypeRepresentation::Geography => { + query_engine_metadata::metadata::TypeRepresentation::Geography + } + metadata::TypeRepresentation::Geometry => { + query_engine_metadata::metadata::TypeRepresentation::Geometry + } + // This is deprecated in ndc-spec + metadata::TypeRepresentation::Number + | metadata::TypeRepresentation::Integer + | metadata::TypeRepresentation::Json => { + query_engine_metadata::metadata::TypeRepresentation::Json + } + metadata::TypeRepresentation::Enum(v) => { + query_engine_metadata::metadata::TypeRepresentation::Enum(v) + } + } +} + +fn convert_comparison_operator( + comparison_operator: metadata::ComparisonOperator, +) -> query_engine_metadata::metadata::ComparisonOperator { + query_engine_metadata::metadata::ComparisonOperator { + operator_name: comparison_operator.operator_name, + operator_kind: convert_operator_kind(&comparison_operator.operator_kind), + argument_type: convert_scalar_type_name(comparison_operator.argument_type), + is_infix: comparison_operator.is_infix, + } +} + +fn convert_operator_kind( + operator_kind: &metadata::OperatorKind, +) -> query_engine_metadata::metadata::OperatorKind { + match operator_kind { + metadata::OperatorKind::Equal => query_engine_metadata::metadata::OperatorKind::Equal, + metadata::OperatorKind::In => query_engine_metadata::metadata::OperatorKind::In, + metadata::OperatorKind::Custom => query_engine_metadata::metadata::OperatorKind::Custom, + } +} + +fn convert_composite_types( + composite_types: metadata::CompositeTypes, +) -> query_engine_metadata::metadata::CompositeTypes { + query_engine_metadata::metadata::CompositeTypes( + composite_types + .0 + .into_iter() + .map(|(k, composite_type)| { + ( + query_engine_metadata::metadata::CompositeTypeName(k), + convert_composite_type(composite_type), + ) + }) + .collect(), + ) +} + +fn convert_composite_type( + composite_type: metadata::CompositeType, +) -> query_engine_metadata::metadata::CompositeType { + query_engine_metadata::metadata::CompositeType { + type_name: composite_type.type_name, + schema_name: Some(composite_type.schema_name), + fields: composite_type + .fields + .into_iter() + .map(|(k, field)| (k, convert_composite_type_field_info(field))) + .collect(), + description: composite_type.description, + } +} + +fn convert_composite_type_field_info( + field: metadata::FieldInfo, +) -> query_engine_metadata::metadata::FieldInfo { + query_engine_metadata::metadata::FieldInfo { + field_name: field.field_name, + r#type: convert_type(field.r#type), + description: field.description, + } +} + +pub fn convert_tables(tables: metadata::TablesInfo) -> query_engine_metadata::metadata::TablesInfo { + query_engine_metadata::metadata::TablesInfo( + tables + .0 + .into_iter() + .map(|(k, table_info)| (k, convert_table_info(table_info))) + .collect(), + ) +} + +fn convert_table_info( + table_info: metadata::TableInfo, +) -> query_engine_metadata::metadata::TableInfo { + query_engine_metadata::metadata::TableInfo { + schema_name: table_info.schema_name, + table_name: table_info.table_name, + columns: table_info + .columns + .into_iter() + .map(|(k, column_info)| (k, convert_column_info(column_info))) + .collect(), + uniqueness_constraints: convert_uniqueness_constraints(table_info.uniqueness_constraints), + foreign_relations: convert_foreign_relations(table_info.foreign_relations), + description: table_info.description, + } +} + +fn convert_foreign_relations( + foreign_relations: metadata::ForeignRelations, +) -> query_engine_metadata::metadata::ForeignRelations { + query_engine_metadata::metadata::ForeignRelations( + foreign_relations + .0 + .into_iter() + .map(|(k, foreign_relation)| (k, convert_foreign_relation(foreign_relation))) + .collect(), + ) +} + +fn convert_foreign_relation( + foreign_relation: metadata::ForeignRelation, +) -> query_engine_metadata::metadata::ForeignRelation { + query_engine_metadata::metadata::ForeignRelation { + foreign_schema: foreign_relation.foreign_schema, + foreign_table: foreign_relation.foreign_table, + column_mapping: foreign_relation.column_mapping, + } +} + +fn convert_uniqueness_constraints( + uniqueness_constraints: metadata::UniquenessConstraints, +) -> query_engine_metadata::metadata::UniquenessConstraints { + query_engine_metadata::metadata::UniquenessConstraints( + uniqueness_constraints + .0 + .into_iter() + .map(|(k, uniqueness_constraint)| { + (k, convert_uniqueness_constraint(uniqueness_constraint)) + }) + .collect(), + ) +} + +fn convert_uniqueness_constraint( + uniqueness_constraint: metadata::UniquenessConstraint, +) -> query_engine_metadata::metadata::UniquenessConstraint { + query_engine_metadata::metadata::UniquenessConstraint(uniqueness_constraint.0) +} + +fn convert_column_info( + column_info: metadata::ColumnInfo, +) -> query_engine_metadata::metadata::ColumnInfo { + query_engine_metadata::metadata::ColumnInfo { + name: column_info.name, + r#type: convert_type(column_info.r#type), + nullable: convert_nullable(&column_info.nullable), + has_default: convert_has_default(&column_info.has_default), + is_identity: convert_is_identity(&column_info.is_identity), + is_generated: convert_is_generated(&column_info.is_generated), + description: column_info.description, + } +} + +fn convert_is_generated( + is_generated: &metadata::IsGenerated, +) -> query_engine_metadata::metadata::IsGenerated { + match is_generated { + metadata::IsGenerated::NotGenerated => { + query_engine_metadata::metadata::IsGenerated::NotGenerated + } + metadata::IsGenerated::Stored => query_engine_metadata::metadata::IsGenerated::Stored, + } +} + +fn convert_is_identity( + is_identity: &metadata::IsIdentity, +) -> query_engine_metadata::metadata::IsIdentity { + match is_identity { + metadata::IsIdentity::NotIdentity => { + query_engine_metadata::metadata::IsIdentity::NotIdentity + } + metadata::IsIdentity::IdentityByDefault => { + query_engine_metadata::metadata::IsIdentity::IdentityByDefault + } + metadata::IsIdentity::IdentityAlways => { + query_engine_metadata::metadata::IsIdentity::IdentityAlways + } + } +} + +fn convert_has_default( + has_default: &metadata::HasDefault, +) -> query_engine_metadata::metadata::HasDefault { + match has_default { + metadata::HasDefault::NoDefault => query_engine_metadata::metadata::HasDefault::NoDefault, + metadata::HasDefault::HasDefault => query_engine_metadata::metadata::HasDefault::HasDefault, + } +} + +fn convert_mutations_version( + mutations_version_opt: Option, +) -> Option { + mutations_version_opt.map(|mutations_version| match mutations_version { + metadata::mutations::MutationsVersion::V1 => { + query_engine_metadata::metadata::mutations::MutationsVersion::V1 + } + metadata::mutations::MutationsVersion::V2 => { + query_engine_metadata::metadata::mutations::MutationsVersion::V2 + } + }) +} diff --git a/crates/configuration/src/version5/upgrade_from_v4.rs b/crates/configuration/src/version5/upgrade_from_v4.rs new file mode 100644 index 000000000..b433b62e4 --- /dev/null +++ b/crates/configuration/src/version5/upgrade_from_v4.rs @@ -0,0 +1,617 @@ +#![allow(clippy::needless_pass_by_value)] + +use std::collections::BTreeMap; + +use super::comparison; +use super::connection_settings; +use super::metadata; +use super::options; +use super::ParsedConfiguration; +use crate::version4; + +pub fn upgrade_from_v4(v: version4::ParsedConfiguration) -> super::ParsedConfiguration { + let version4::ParsedConfiguration { + version: _, + schema, + connection_settings, + metadata, + introspection_options, + mutations_version, + } = v; + + ParsedConfiguration { + version: super::Version::This, + schema, + connection_settings: upgrade_connection_settings(connection_settings), + introspection_options: ugrade_introspection_options(introspection_options), + metadata: upgrade_metadata(metadata), + mutations_version: mutations_version.map(upgrade_mutations_version), + } +} + +fn ugrade_introspection_options( + introspection_options: version4::options::IntrospectionOptions, +) -> options::IntrospectionOptions { + let version4::options::IntrospectionOptions { + excluded_schemas, + unqualified_schemas_for_tables, + unqualified_schemas_for_types_and_procedures, + comparison_operator_mapping, + introspect_prefix_function_comparison_operators, + type_representations, + } = introspection_options; + + options::IntrospectionOptions { + excluded_schemas, + unqualified_schemas_for_tables, + unqualified_schemas_for_types_and_procedures, + comparison_operator_mapping: comparison_operator_mapping + .into_iter() + .map(upgrade_comparison_operator_mapping) + .collect(), + introspect_prefix_function_comparison_operators, + type_representations: upgrade_type_representations(&type_representations), + } +} + +fn upgrade_comparison_operator_mapping( + comparison_operator_mapping: version4::comparison::ComparisonOperatorMapping, +) -> comparison::ComparisonOperatorMapping { + let version4::comparison::ComparisonOperatorMapping { + operator_name, + exposed_name, + operator_kind, + } = comparison_operator_mapping; + + comparison::ComparisonOperatorMapping { + operator_name, + exposed_name, + operator_kind: upgrade_operator_kind(operator_kind), + } +} + +fn upgrade_operator_kind( + operator_kind: version4::metadata::OperatorKind, +) -> metadata::OperatorKind { + match operator_kind { + version4::metadata::OperatorKind::Equal => metadata::OperatorKind::Equal, + version4::metadata::OperatorKind::In => metadata::OperatorKind::In, + version4::metadata::OperatorKind::Custom => metadata::OperatorKind::Custom, + } +} + +fn upgrade_mutations_version( + mutations_version: version4::metadata::mutations::MutationsVersion, +) -> metadata::mutations::MutationsVersion { + match mutations_version { + version4::metadata::mutations::MutationsVersion::V1 => { + metadata::mutations::MutationsVersion::V1 + } + version4::metadata::mutations::MutationsVersion::V2 => { + metadata::mutations::MutationsVersion::V2 + } + } +} + +fn upgrade_connection_settings( + connection_settings: version4::connection_settings::DatabaseConnectionSettings, +) -> connection_settings::DatabaseConnectionSettings { + let version4::connection_settings::DatabaseConnectionSettings { + connection_uri, + pool_settings, + isolation_level, + } = connection_settings; + + connection_settings::DatabaseConnectionSettings { + connection_uri, + pool_settings, + isolation_level, + } +} + +fn upgrade_metadata(metadata: version4::metadata::Metadata) -> metadata::Metadata { + let version4::metadata::Metadata { + tables, + scalar_types, + composite_types, + native_queries, + } = metadata; + + let upgraded_scalar_types = upgrade_scalar_types(scalar_types); + + let upgraded_composite_types = upgrade_composite_types(composite_types); + + let upgraded_tables = upgrade_tables(tables); + + let upgraded_native_operations = upgrade_native_queries(native_queries); + + metadata::Metadata { + tables: upgraded_tables, + types: metadata::Types { + scalar: upgraded_scalar_types, + composite: upgraded_composite_types, + }, + native_operations: upgraded_native_operations, + } +} + +fn upgrade_native_queries( + native_queries: version4::metadata::NativeQueries, +) -> metadata::NativeOperations { + let version4::metadata::NativeQueries(native_queries_map) = native_queries; + + let mut queries = BTreeMap::new(); + let mut mutations = BTreeMap::new(); + + for (name, native_query_info) in native_queries_map { + let is_procedure = native_query_info.is_procedure; + let operation = upgrade_native_query_info(native_query_info); + if is_procedure { + mutations.insert(name, operation); + } else { + queries.insert(name, operation); + } + } + + metadata::NativeOperations { + queries: metadata::NativeQueries(queries), + mutations: metadata::NativeQueries(mutations), + } +} + +fn upgrade_native_query_info( + native_query_info: version4::metadata::NativeQueryInfo, +) -> metadata::NativeQueryInfo { + let version4::metadata::NativeQueryInfo { + sql, + columns, + arguments, + description, + is_procedure: _, + } = native_query_info; + + metadata::NativeQueryInfo { + sql: upgrade_native_query_sql_either(sql), + columns: columns + .into_iter() + .map(|(name, read_only_column_info)| { + (name, upgrade_read_only_column_info(read_only_column_info)) + }) + .collect(), + arguments: arguments + .into_iter() + .map(|(name, read_only_column_info)| { + (name, upgrade_read_only_column_info(read_only_column_info)) + }) + .collect(), + description, + } +} + +fn upgrade_read_only_column_info( + read_only_column_info: version4::metadata::ReadOnlyColumnInfo, +) -> metadata::ReadOnlyColumnInfo { + let version4::metadata::ReadOnlyColumnInfo { + name, + r#type, + nullable, + description, + } = read_only_column_info; + + let upgraded_type = upgrade_type(r#type); + + metadata::ReadOnlyColumnInfo { + name, + r#type: upgraded_type, + nullable: upgrade_nullable(nullable), + description, + } +} + +fn upgrade_nullable(nullable: version4::metadata::Nullable) -> metadata::Nullable { + match nullable { + version4::metadata::Nullable::Nullable => metadata::Nullable::Nullable, + version4::metadata::Nullable::NonNullable => metadata::Nullable::NonNullable, + } +} + +fn upgrade_type(r#type: version4::metadata::Type) -> metadata::Type { + match r#type { + version4::metadata::Type::ScalarType(scalar_type) => { + metadata::Type::ScalarType(upgrade_scalar_type_name(scalar_type)) + } + version4::metadata::Type::CompositeType(composite_type) => { + metadata::Type::CompositeType(upgrade_composite_type_name(composite_type)) + } + version4::metadata::Type::ArrayType(array_type) => { + metadata::Type::ArrayType(Box::new(upgrade_type(*array_type))) + } + } +} + +fn upgrade_composite_type_name( + composite_type: version4::metadata::CompositeTypeName, +) -> metadata::CompositeTypeName { + let version4::metadata::CompositeTypeName(name) = composite_type; + metadata::CompositeTypeName(name) +} + +fn upgrade_scalar_type_name( + scalar_type: version4::metadata::ScalarTypeName, +) -> metadata::ScalarTypeName { + let version4::metadata::ScalarTypeName(name) = scalar_type; + metadata::ScalarTypeName(name) +} + +fn upgrade_native_query_sql_either( + sql: version4::metadata::NativeQuerySqlEither, +) -> metadata::NativeQuerySqlEither { + match sql { + version4::metadata::NativeQuerySqlEither::NativeQuerySql(native_query_sql) => { + metadata::NativeQuerySqlEither::NativeQuerySql(upgrade_native_query_sql( + native_query_sql, + )) + } + version4::metadata::NativeQuerySqlEither::NativeQuerySqlExternal( + native_query_sql_external, + ) => metadata::NativeQuerySqlEither::NativeQuerySqlExternal( + upgrade_native_query_sql_external(native_query_sql_external), + ), + } +} + +fn upgrade_native_query_sql_external( + native_query_sql_external: version4::metadata::NativeQuerySqlExternal, +) -> metadata::NativeQuerySqlExternal { + match native_query_sql_external { + version4::metadata::NativeQuerySqlExternal::File { file } => { + metadata::NativeQuerySqlExternal::File { file } + } + version4::metadata::NativeQuerySqlExternal::Inline { inline } => { + metadata::NativeQuerySqlExternal::Inline { + inline: upgrade_native_query_parts(inline), + } + } + version4::metadata::NativeQuerySqlExternal::InlineUntagged(native_query_parts) => { + metadata::NativeQuerySqlExternal::InlineUntagged(upgrade_native_query_parts( + native_query_parts, + )) + } + } +} + +fn upgrade_native_query_parts( + native_query_parts: version4::metadata::NativeQueryParts, +) -> metadata::NativeQueryParts { + metadata::NativeQueryParts( + native_query_parts + .0 + .into_iter() + .map(upgrade_native_query_part) + .collect(), + ) +} + +fn upgrade_native_query_part( + native_query_part: version4::metadata::NativeQueryPart, +) -> metadata::NativeQueryPart { + match native_query_part { + version4::metadata::NativeQueryPart::Text(text) => metadata::NativeQueryPart::Text(text), + version4::metadata::NativeQueryPart::Parameter(parameter) => { + metadata::NativeQueryPart::Parameter(parameter) + } + } +} + +fn upgrade_native_query_sql( + native_query_sql: version4::metadata::NativeQuerySql, +) -> metadata::NativeQuerySql { + match native_query_sql { + version4::metadata::NativeQuerySql::FromFile { file, sql } => { + metadata::NativeQuerySql::FromFile { + file, + sql: upgrade_native_query_parts(sql), + } + } + version4::metadata::NativeQuerySql::Inline { sql } => metadata::NativeQuerySql::Inline { + sql: upgrade_native_query_parts(sql), + }, + } +} + +fn upgrade_composite_types( + composite_types: version4::metadata::CompositeTypes, +) -> metadata::CompositeTypes { + metadata::CompositeTypes( + composite_types + .0 + .into_iter() + .map(|(name, composite_type)| (name, upgrade_composite_type(composite_type))) + .collect(), + ) +} + +fn upgrade_composite_type( + composite_type: version4::metadata::CompositeType, +) -> metadata::CompositeType { + let version4::metadata::CompositeType { + type_name, + schema_name, + fields, + description, + } = composite_type; + + metadata::CompositeType { + schema_name, + type_name, + fields: fields + .into_iter() + .map(|(name, field_info)| (name, upgrade_field_info(field_info))) + .collect(), + description, + } +} + +fn upgrade_field_info(field_info: version4::metadata::FieldInfo) -> metadata::FieldInfo { + let version4::metadata::FieldInfo { + field_name, + r#type, + description, + } = field_info; + + metadata::FieldInfo { + field_name, + r#type: upgrade_type(r#type), + description, + } +} + +fn upgrade_scalar_types(scalar_types: version4::metadata::ScalarTypes) -> metadata::ScalarTypes { + metadata::ScalarTypes( + scalar_types + .0 + .into_iter() + .map(|(scalar_type_name, scalar_type)| { + ( + metadata::ScalarTypeName(scalar_type_name.0), + metadata::ScalarType { + schema_name: scalar_type.schema_name.clone(), + type_name: scalar_type.type_name.clone(), + description: scalar_type.description.clone(), + aggregate_functions: scalar_type + .aggregate_functions + .into_iter() + .map(|(name, aggregate_function)| { + (name, upgrade_aggregate_function(aggregate_function)) + }) + .collect(), + comparison_operators: scalar_type + .comparison_operators + .into_iter() + .map(|(name, comparison_operator)| { + (name, upgrade_comparison_operator(comparison_operator)) + }) + .collect(), + type_representation: scalar_type + .type_representation + .map(upgrade_type_representation), + }, + ) + }) + .collect(), + ) +} + +fn upgrade_type_representations( + type_representations: &version4::metadata::TypeRepresentations, +) -> metadata::TypeRepresentations { + metadata::TypeRepresentations( + type_representations + .0 + .iter() + .map(|(key, type_representation)| { + ( + upgrade_scalar_type_name(key.clone()), + upgrade_type_representation(type_representation.clone()), + ) + }) + .collect(), + ) +} + +fn upgrade_type_representation( + type_representation: version4::metadata::TypeRepresentation, +) -> metadata::TypeRepresentation { + match type_representation { + version4::metadata::TypeRepresentation::Boolean => metadata::TypeRepresentation::Boolean, + version4::metadata::TypeRepresentation::String => metadata::TypeRepresentation::String, + version4::metadata::TypeRepresentation::Float32 => metadata::TypeRepresentation::Float32, + version4::metadata::TypeRepresentation::Float64 => metadata::TypeRepresentation::Float64, + version4::metadata::TypeRepresentation::Int16 => metadata::TypeRepresentation::Int16, + version4::metadata::TypeRepresentation::Int32 => metadata::TypeRepresentation::Int32, + version4::metadata::TypeRepresentation::Int64 => metadata::TypeRepresentation::Int64, + version4::metadata::TypeRepresentation::Int64AsString => { + metadata::TypeRepresentation::Int64AsString + } + version4::metadata::TypeRepresentation::BigDecimal => { + metadata::TypeRepresentation::BigDecimal + } + version4::metadata::TypeRepresentation::BigDecimalAsString => { + metadata::TypeRepresentation::BigDecimalAsString + } + version4::metadata::TypeRepresentation::Timestamp => { + metadata::TypeRepresentation::Timestamp + } + version4::metadata::TypeRepresentation::Timestamptz => { + metadata::TypeRepresentation::Timestamptz + } + version4::metadata::TypeRepresentation::Time => metadata::TypeRepresentation::Time, + version4::metadata::TypeRepresentation::Timetz => metadata::TypeRepresentation::Timetz, + version4::metadata::TypeRepresentation::Date => metadata::TypeRepresentation::Date, + version4::metadata::TypeRepresentation::UUID => metadata::TypeRepresentation::UUID, + version4::metadata::TypeRepresentation::Geography => { + metadata::TypeRepresentation::Geography + } + version4::metadata::TypeRepresentation::Geometry => metadata::TypeRepresentation::Geometry, + version4::metadata::TypeRepresentation::Number => metadata::TypeRepresentation::Number, + version4::metadata::TypeRepresentation::Integer => metadata::TypeRepresentation::Integer, + version4::metadata::TypeRepresentation::Json => metadata::TypeRepresentation::Json, + version4::metadata::TypeRepresentation::Enum(enum_alternatives) => { + metadata::TypeRepresentation::Enum(enum_alternatives) + } + } +} + +fn upgrade_comparison_operator( + comparison_operator: version4::metadata::ComparisonOperator, +) -> metadata::ComparisonOperator { + let version4::metadata::ComparisonOperator { + operator_name, + operator_kind, + argument_type, + is_infix, + } = comparison_operator; + metadata::ComparisonOperator { + operator_name, + operator_kind: upgrade_operator_kind(operator_kind), + argument_type: upgrade_scalar_type_name(argument_type), + is_infix, + } +} + +fn upgrade_aggregate_function( + aggregate_function: version4::metadata::AggregateFunction, +) -> metadata::AggregateFunction { + let version4::metadata::AggregateFunction { return_type } = aggregate_function; + + metadata::AggregateFunction { + return_type: upgrade_scalar_type_name(return_type), + } +} + +fn upgrade_tables(tables: version4::metadata::TablesInfo) -> metadata::TablesInfo { + metadata::TablesInfo( + tables + .0 + .into_iter() + .map(|(name, table_info)| (name, upgrade_table_info(table_info))) + .collect(), + ) +} + +fn upgrade_table_info(table_info: version4::metadata::TableInfo) -> metadata::TableInfo { + let version4::metadata::TableInfo { + schema_name, + table_name, + columns, + uniqueness_constraints, + foreign_relations, + description, + } = table_info; + metadata::TableInfo { + schema_name, + table_name, + columns: columns + .into_iter() + .map(|(name, column_info)| (name, upgrade_column_info(column_info))) + .collect(), + uniqueness_constraints: upgrade_uniqueness_constraints(uniqueness_constraints), + foreign_relations: upgrade_foreign_relations(foreign_relations), + description, + } +} + +fn upgrade_foreign_relations( + foreign_relations: version4::metadata::ForeignRelations, +) -> metadata::ForeignRelations { + metadata::ForeignRelations( + foreign_relations + .0 + .into_iter() + .map(|(name, foreign_relation)| (name, upgrade_foreign_relation(foreign_relation))) + .collect(), + ) +} + +fn upgrade_foreign_relation( + foreign_relation: version4::metadata::ForeignRelation, +) -> metadata::ForeignRelation { + let version4::metadata::ForeignRelation { + foreign_schema, + foreign_table, + column_mapping, + } = foreign_relation; + metadata::ForeignRelation { + foreign_schema, + foreign_table, + column_mapping, + } +} + +fn upgrade_uniqueness_constraints( + uniqueness_constraints: version4::metadata::UniquenessConstraints, +) -> metadata::UniquenessConstraints { + metadata::UniquenessConstraints( + uniqueness_constraints + .0 + .into_iter() + .map(|(name, uniqueness_constraint)| { + (name, upgrade_uniqueness_constraint(uniqueness_constraint)) + }) + .collect(), + ) +} + +fn upgrade_uniqueness_constraint( + uniqueness_constraint: version4::metadata::UniquenessConstraint, +) -> metadata::UniquenessConstraint { + metadata::UniquenessConstraint(uniqueness_constraint.0) +} + +fn upgrade_column_info(column_info: version4::metadata::ColumnInfo) -> metadata::ColumnInfo { + let version4::metadata::ColumnInfo { + name, + r#type, + nullable, + has_default, + is_identity, + is_generated, + description, + } = column_info; + + let upgraded_type = upgrade_type(r#type); + + metadata::ColumnInfo { + name, + r#type: upgraded_type, + nullable: upgrade_nullable(nullable), + has_default: upgrade_has_default(has_default), + is_identity: upgrade_is_identity(is_identity), + is_generated: upgrade_is_generated(is_generated), + description, + } +} + +fn upgrade_is_generated(is_generated: version4::metadata::IsGenerated) -> metadata::IsGenerated { + match is_generated { + version4::metadata::IsGenerated::NotGenerated => metadata::IsGenerated::NotGenerated, + version4::metadata::IsGenerated::Stored => metadata::IsGenerated::Stored, + } +} + +fn upgrade_is_identity(is_identity: version4::metadata::IsIdentity) -> metadata::IsIdentity { + match is_identity { + version4::metadata::IsIdentity::NotIdentity => metadata::IsIdentity::NotIdentity, + version4::metadata::IsIdentity::IdentityByDefault => { + metadata::IsIdentity::IdentityByDefault + } + version4::metadata::IsIdentity::IdentityAlways => metadata::IsIdentity::IdentityAlways, + } +} + +fn upgrade_has_default(has_default: version4::metadata::HasDefault) -> metadata::HasDefault { + match has_default { + version4::metadata::HasDefault::NoDefault => metadata::HasDefault::NoDefault, + version4::metadata::HasDefault::HasDefault => metadata::HasDefault::HasDefault, + } +} diff --git a/crates/connectors/ndc-postgres/src/schema/mod.rs b/crates/connectors/ndc-postgres/src/schema/mod.rs index 48469cdd2..e61510d3b 100644 --- a/crates/connectors/ndc-postgres/src/schema/mod.rs +++ b/crates/connectors/ndc-postgres/src/schema/mod.rs @@ -159,10 +159,10 @@ pub fn get_schema( .collect(); let native_queries: Vec = metadata - .native_queries + .native_operations + .queries .0 .iter() - .filter(|(_, info)| !info.is_procedure) .map(|(name, info)| models::CollectionInfo { name: name.clone(), description: info.description.clone(), @@ -215,7 +215,35 @@ pub fn get_schema( .collect::>(); let native_queries_types = metadata - .native_queries + .native_operations + .queries + .0 + .iter() + .map(|(nq_name, nq_info)| { + let object_type = models::ObjectType { + description: nq_info.description.clone(), + fields: nq_info + .columns + .iter() + .map(|(column_name, column_info)| { + ( + column_name.clone(), + models::ObjectField { + description: column_info.description.clone(), + r#type: readonly_column_to_type(column_info), + arguments: BTreeMap::new(), + }, + ) + }) + .collect(), + }; + (nq_name.clone(), object_type) + }) + .collect::>(); + + let native_mutations_types = metadata + .native_operations + .mutations .0 .iter() .map(|(nq_name, nq_info)| { @@ -268,13 +296,14 @@ pub fn get_schema( let mut object_types = table_types; object_types.extend(native_queries_types); + object_types.extend(native_mutations_types); object_types.extend(composite_types); let mut procedures: Vec = metadata - .native_queries + .native_operations + .mutations .0 .iter() - .filter(|(_, nq_info)| nq_info.is_procedure) .map(|(nq_name, nq_info)| { mutation::helpers::make_procedure_type( nq_name.clone(), diff --git a/crates/query-engine/metadata/Cargo.toml b/crates/query-engine/metadata/Cargo.toml index 90b03b97f..ac1c87c28 100644 --- a/crates/query-engine/metadata/Cargo.toml +++ b/crates/query-engine/metadata/Cargo.toml @@ -6,3 +6,7 @@ license.workspace = true [lints] workspace = true + +[dependencies] +ref-cast = { workspace = true } + diff --git a/crates/query-engine/metadata/src/metadata/database.rs b/crates/query-engine/metadata/src/metadata/database.rs index 20b38ead5..59f49ad3c 100644 --- a/crates/query-engine/metadata/src/metadata/database.rs +++ b/crates/query-engine/metadata/src/metadata/database.rs @@ -1,5 +1,6 @@ //! Metadata information regarding the database and tracked information. +use ref_cast::RefCast; use std::collections::{BTreeMap, BTreeSet}; /// A name of a Scalar Type, as it appears in the NDC scheme. @@ -7,7 +8,8 @@ use std::collections::{BTreeMap, BTreeSet}; pub struct ScalarTypeName(pub String); /// The name of a Composite Type, as it appears in the NDC schema -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, RefCast)] +#[repr(transparent)] pub struct CompositeTypeName(pub String); /// The type of values that a column, field, or argument may take. diff --git a/crates/query-engine/metadata/src/metadata/mod.rs b/crates/query-engine/metadata/src/metadata/mod.rs index 296f0d7a7..afcf5795f 100644 --- a/crates/query-engine/metadata/src/metadata/mod.rs +++ b/crates/query-engine/metadata/src/metadata/mod.rs @@ -13,7 +13,7 @@ pub use native_queries::*; pub struct Metadata { pub tables: TablesInfo, pub composite_types: CompositeTypes, - pub native_queries: NativeQueries, + pub native_operations: NativeOperations, pub scalar_types: ScalarTypes, } @@ -22,7 +22,7 @@ impl Metadata { Metadata { tables: TablesInfo::empty(), composite_types: CompositeTypes::empty(), - native_queries: NativeQueries::empty(), + native_operations: NativeOperations::empty(), scalar_types: ScalarTypes::empty(), } } diff --git a/crates/query-engine/metadata/src/metadata/native_queries.rs b/crates/query-engine/metadata/src/metadata/native_queries.rs index 7bee05706..a18b79b64 100644 --- a/crates/query-engine/metadata/src/metadata/native_queries.rs +++ b/crates/query-engine/metadata/src/metadata/native_queries.rs @@ -8,7 +8,21 @@ use std::collections::BTreeMap; /// Metadata information of native queries. #[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct NativeOperations { + pub queries: NativeQueries, + pub mutations: NativeQueries, +} +impl NativeOperations { + pub fn empty() -> Self { + NativeOperations { + queries: NativeQueries::empty(), + mutations: NativeQueries::empty(), + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct NativeQueries(pub BTreeMap); impl NativeQueries { @@ -32,8 +46,6 @@ pub struct NativeQueryInfo { pub arguments: BTreeMap, pub description: Option, - /// True if this native query mutates the database - pub is_procedure: bool, } /// Information about a native query column. diff --git a/crates/query-engine/translation/Cargo.toml b/crates/query-engine/translation/Cargo.toml index adde3863b..ea8322962 100644 --- a/crates/query-engine/translation/Cargo.toml +++ b/crates/query-engine/translation/Cargo.toml @@ -18,6 +18,7 @@ anyhow = { workspace = true } indexmap = { workspace = true } multimap = { workspace = true } nonempty = { workspace = true } +ref-cast = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } tokio = { workspace = true } diff --git a/crates/query-engine/translation/src/translation/helpers.rs b/crates/query-engine/translation/src/translation/helpers.rs index aca0f0ef2..a3b014f69 100644 --- a/crates/query-engine/translation/src/translation/helpers.rs +++ b/crates/query-engine/translation/src/translation/helpers.rs @@ -1,5 +1,6 @@ //! Helpers for processing requests and building SQL. +use ref_cast::RefCast; use std::collections::BTreeMap; use ndc_sdk::models; @@ -183,37 +184,51 @@ impl<'request> Env<'request> { /// This is used to translate field selection, where any of these may occur. pub fn lookup_fields_info( &self, - type_name: &'request str, + type_name: &'request String, ) -> Result, Error> { // Lookup the fields of a type name in a specific order: // tables, then composite types, then native queries. - let info = - self.metadata - .tables - .0 - .get(type_name) - .map(|t| FieldsInfo::Table { - name: type_name, - info: t, - }) - .or_else(|| { - self.metadata - .composite_types - .0 - .get(&metadata::CompositeTypeName(type_name.to_string())) - .map(|t| FieldsInfo::CompositeType { - name: &t.type_name, - info: t, - }) - }) - .or_else(|| { - self.metadata.native_queries.0.get(type_name).map(|nq| { - FieldsInfo::NativeQuery { - name: type_name, - info: nq, - } + let info = self + .metadata + .tables + .0 + .get(type_name) + .map(|t| FieldsInfo::Table { + name: type_name, + info: t, + }) + .or_else(|| { + self.metadata + .composite_types + .0 + .get(metadata::CompositeTypeName::ref_cast(type_name)) + .map(|t| FieldsInfo::CompositeType { + name: &t.type_name, + info: t, }) - }); + }) + .or_else(|| { + self.metadata + .native_operations + .queries + .0 + .get(type_name) + .map(|nq| FieldsInfo::NativeQuery { + name: type_name, + info: nq, + }) + }) + .or_else(|| { + self.metadata + .native_operations + .mutations + .0 + .get(type_name) + .map(|nq| FieldsInfo::NativeQuery { + name: type_name, + info: nq, + }) + }); info.ok_or(Error::CollectionNotFound(type_name.to_string())) } @@ -268,28 +283,45 @@ impl<'request> Env<'request> { info: t, }); - match table { - Some(table) => Ok(table), - None => self + if let Some(table) = table { + Ok(table) + } else { + let query = self .metadata - .native_queries + .native_operations + .queries .0 .get(collection_name) .map(|nq| CollectionInfo::NativeQuery { name: collection_name, info: nq, - }) - .ok_or(Error::CollectionNotFound(collection_name.to_string())), + }); + + if let Some(query) = query { + Ok(query) + } else { + self.metadata + .native_operations + .mutations + .0 + .get(collection_name) + .map(|nq| CollectionInfo::NativeQuery { + name: collection_name, + info: nq, + }) + .ok_or(Error::CollectionNotFound(collection_name.to_string())) + } } } /// Lookup a native query's information in the metadata. - pub fn lookup_native_query( + pub fn lookup_native_mutation( &self, procedure_name: &str, ) -> Result<&metadata::NativeQueryInfo, Error> { self.metadata - .native_queries + .native_operations + .mutations .0 .get(procedure_name) .ok_or(Error::ProcedureNotFound(procedure_name.to_string())) diff --git a/crates/query-engine/translation/src/translation/mutation/translate.rs b/crates/query-engine/translation/src/translation/mutation/translate.rs index 300303d20..40f374282 100644 --- a/crates/query-engine/translation/src/translation/mutation/translate.rs +++ b/crates/query-engine/translation/src/translation/mutation/translate.rs @@ -29,7 +29,7 @@ pub fn translate( fields, } => { // lookup native query first - match env.lookup_native_query(&name) { + match env.lookup_native_mutation(&name) { Ok(native_query) => { translate_native_query(&env, name, fields, arguments, native_query) } diff --git a/crates/query-engine/translation/tests/goldenfiles/mutations/simple/configuration.json b/crates/query-engine/translation/tests/goldenfiles/mutations/simple/configuration.json index aa3fa0d43..58974b468 100644 --- a/crates/query-engine/translation/tests/goldenfiles/mutations/simple/configuration.json +++ b/crates/query-engine/translation/tests/goldenfiles/mutations/simple/configuration.json @@ -1,52 +1,57 @@ { - "version": "4", + "version": "5", "metadata": { "tables": {}, - "scalarTypes": { - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": {}, - "typeRepresentation": null - } + "types": { + "scalar": { + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": {}, + "typeRepresentation": null + } + }, + "composite": {} }, - "compositeTypes": {}, - "nativeQueries": { - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null + "nativeOperations": { + "queries": {}, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null }, - "nullable": "nullable", - "description": null - } - }, - "description": null + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } } } }, diff --git a/crates/query-engine/translation/tests/goldenfiles/mutations/v2_insert/configuration.json b/crates/query-engine/translation/tests/goldenfiles/mutations/v2_insert/configuration.json index 1f7a3d9ff..d780284c2 100644 --- a/crates/query-engine/translation/tests/goldenfiles/mutations/v2_insert/configuration.json +++ b/crates/query-engine/translation/tests/goldenfiles/mutations/v2_insert/configuration.json @@ -1,5 +1,5 @@ { - "version": "4", + "version": "5", "metadata": { "tables": { "Artist": { @@ -28,26 +28,31 @@ "description": null } }, - "scalarTypes": { - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": {}, - "typeRepresentation": null + "types": { + "scalar": { + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": {}, + "typeRepresentation": null + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": {}, + "typeRepresentation": null + } }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": {}, - "typeRepresentation": null - } + "composite": {} }, - "compositeTypes": {}, - "nativeQueries": {} + "nativeOperations": { + "queries": {}, + "mutations": {} + } }, "mutationsVersion": "v2" } diff --git a/crates/tests/databases-tests/src/aurora/common.rs b/crates/tests/databases-tests/src/aurora/common.rs index 4c74af0fe..a36b81ec3 100644 --- a/crates/tests/databases-tests/src/aurora/common.rs +++ b/crates/tests/databases-tests/src/aurora/common.rs @@ -2,7 +2,7 @@ use std::env; -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/aurora/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/aurora/v5-configuration"; /// We get our connection string from an env var so that it can be stored in secrets in CI pub fn get_connection_string() -> String { diff --git a/crates/tests/databases-tests/src/citus/common.rs b/crates/tests/databases-tests/src/citus/common.rs index fe199b4d7..8b41377c7 100644 --- a/crates/tests/databases-tests/src/citus/common.rs +++ b/crates/tests/databases-tests/src/citus/common.rs @@ -1,6 +1,6 @@ //! Common functions used across test cases. -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/citus/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/citus/v5-configuration"; pub const CONNECTION_URI: &str = "postgresql://postgres:password@localhost:64004?sslmode=disable"; diff --git a/crates/tests/databases-tests/src/citus/configuration_tests.rs b/crates/tests/databases-tests/src/citus/configuration_tests.rs index 6b338415d..39ca4991f 100644 --- a/crates/tests/databases-tests/src/citus/configuration_tests.rs +++ b/crates/tests/databases-tests/src/citus/configuration_tests.rs @@ -13,7 +13,7 @@ use std::path::{Path, PathBuf}; use similar_asserts::assert_eq; -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/citus/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/citus/v5-configuration"; pub const CONNECTION_URI: &str = "postgresql://postgres:password@localhost:64004?sslmode=disable"; diff --git a/crates/tests/databases-tests/src/cockroach/common.rs b/crates/tests/databases-tests/src/cockroach/common.rs index 7a9bd072f..47415a36d 100644 --- a/crates/tests/databases-tests/src/cockroach/common.rs +++ b/crates/tests/databases-tests/src/cockroach/common.rs @@ -1,6 +1,6 @@ //! Common functions used across test cases. -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/cockroach/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/cockroach/v5-configuration"; pub const CONNECTION_URI: &str = "postgresql://postgres:password@localhost:64003/defaultdb"; diff --git a/crates/tests/databases-tests/src/cockroach/configuration_tests.rs b/crates/tests/databases-tests/src/cockroach/configuration_tests.rs index c46c3b352..5a721e4cb 100644 --- a/crates/tests/databases-tests/src/cockroach/configuration_tests.rs +++ b/crates/tests/databases-tests/src/cockroach/configuration_tests.rs @@ -13,7 +13,7 @@ use std::path::{Path, PathBuf}; use similar_asserts::assert_eq; -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/cockroach/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/cockroach/v5-configuration"; pub const CONNECTION_URI: &str = "postgresql://postgres:password@localhost:64003/defaultdb"; diff --git a/crates/tests/databases-tests/src/postgres/cli_version5_tests.rs b/crates/tests/databases-tests/src/postgres/cli_version5_tests.rs new file mode 100644 index 000000000..157177dcf --- /dev/null +++ b/crates/tests/databases-tests/src/postgres/cli_version5_tests.rs @@ -0,0 +1,22 @@ +use std::collections::HashMap; + +use ndc_postgres_configuration::version5::connection_settings::DEFAULT_CONNECTION_URI_VARIABLE; +use ndc_postgres_configuration::version5::{introspect, ParsedConfiguration}; + +const CONNECTION_URI: &str = "postgresql://postgres:password@localhost:64002"; + +#[tokio::test] +async fn postgres_current_only_configure_initial_configuration_is_unchanged() { + let args = ParsedConfiguration::empty(); + let connection_string = CONNECTION_URI; + let environment = HashMap::from([( + DEFAULT_CONNECTION_URI_VARIABLE.into(), + connection_string.into(), + )]); + + let default_configuration = introspect(args, environment) + .await + .expect("configuration::introspect"); + + insta::assert_json_snapshot!(default_configuration); +} diff --git a/crates/tests/databases-tests/src/postgres/common.rs b/crates/tests/databases-tests/src/postgres/common.rs index 56b3a723e..c05c41ba2 100644 --- a/crates/tests/databases-tests/src/postgres/common.rs +++ b/crates/tests/databases-tests/src/postgres/common.rs @@ -1,6 +1,6 @@ //! Common functions used across test cases. -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/postgres/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/postgres/v5-configuration"; pub const BROKEN_QUERIES_NDC_METADATA_PATH: &str = "static/postgres/broken-queries-ndc-metadata"; diff --git a/crates/tests/databases-tests/src/postgres/configuration_tests.rs b/crates/tests/databases-tests/src/postgres/configuration_tests.rs index 55a29f7d2..5ed89b6a1 100644 --- a/crates/tests/databases-tests/src/postgres/configuration_tests.rs +++ b/crates/tests/databases-tests/src/postgres/configuration_tests.rs @@ -10,7 +10,7 @@ use tests_common::common_tests::configuration_tests::*; -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/postgres/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/postgres/v5-configuration"; pub const BROKEN_QUERIES_NDC_METADATA_PATH: &str = "static/postgres/broken-queries-ndc-metadata"; @@ -28,9 +28,7 @@ async fn postgres_current_only_configure_is_idempotent() -> anyhow::Result<()> { introspection_is_idempotent(CONNECTION_URI, CHINOOK_NDC_METADATA_PATH).await } -#[tokio::test] -async fn create_native_operation() -> anyhow::Result<()> { - let my_native_query = r#" +const MY_NATIVE_QUERY: &str = r#" SELECT "ArtistId" as artist_id, "Name", coalesce("Name", 'David') as "name_with_coalesce", @@ -40,14 +38,14 @@ CROSS JOIN "group_leader" WHERE "Name" LIKE '%' || {{name}} || '%' AND "ArtistId" > {{lower_bound}} AND "ArtistId" < {{upper_bound}} -"# - .to_string(); +"#; - let result = test_native_operation_create( +#[tokio::test] +async fn create_native_operation() -> anyhow::Result<()> { + let result = test_native_operation_create_v5( CONNECTION_URI, CHINOOK_NDC_METADATA_PATH, - my_native_query, - ndc_postgres_configuration::version4::native_operations::Kind::Query, + MY_NATIVE_QUERY.to_string(), ) .await?; diff --git a/crates/tests/databases-tests/src/postgres/mod.rs b/crates/tests/databases-tests/src/postgres/mod.rs index ad919898b..592041aec 100644 --- a/crates/tests/databases-tests/src/postgres/mod.rs +++ b/crates/tests/databases-tests/src/postgres/mod.rs @@ -1,6 +1,7 @@ pub mod cli_update_tests; pub mod cli_version3_tests; pub mod cli_version4_tests; +pub mod cli_version5_tests; pub mod common; pub mod configuration_tests; pub mod explain_tests; diff --git a/crates/tests/databases-tests/src/postgres/snapshots/databases_tests__postgres__cli_version5_tests__postgres_current_only_configure_initial_configuration_is_unchanged.snap b/crates/tests/databases-tests/src/postgres/snapshots/databases_tests__postgres__cli_version5_tests__postgres_current_only_configure_initial_configuration_is_unchanged.snap new file mode 100644 index 000000000..f8ebc1f52 --- /dev/null +++ b/crates/tests/databases-tests/src/postgres/snapshots/databases_tests__postgres__cli_version5_tests__postgres_current_only_configure_initial_configuration_is_unchanged.snap @@ -0,0 +1,2661 @@ +--- +source: crates/tests/databases-tests/src/postgres/cli_version5_tests.rs +expression: default_configuration +--- +{ + "version": "5", + "$schema": "schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": [ + "AlbumId" + ] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": [ + "ArtistId" + ] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": [ + "CustomerId" + ] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": [ + "EmployeeId" + ] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": [ + "GenreId" + ] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": [ + "InvoiceId" + ] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": [ + "InvoiceLineId" + ] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": [ + "MediaTypeId" + ] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": [ + "PlaylistId" + ] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": [ + "PlaylistId", + "TrackId" + ] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": [ + "TrackId" + ] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "custom_defaults": { + "schemaName": "custom", + "tableName": "defaults", + "columns": { + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "defaults_pkey": [ + "id" + ] + }, + "foreignRelations": {}, + "description": null + }, + "custom_dog": { + "schemaName": "custom", + "tableName": "dog", + "columns": { + "adopter_name": { + "name": "adopter_name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "dog_pkey": [ + "id" + ] + }, + "foreignRelations": {}, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "even_numbers": { + "schemaName": "public", + "tableName": "even_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "even_number" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "group_leader": { + "schemaName": "public", + "tableName": "group_leader", + "columns": { + "characters": { + "name": "characters", + "type": { + "compositeType": "characters" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "chara" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "phone_numbers": { + "schemaName": "public", + "tableName": "phone_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "Phone" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "spatial_ref_sys": { + "schemaName": "public", + "tableName": "spatial_ref_sys", + "columns": { + "auth_name": { + "name": "auth_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "auth_srid": { + "name": "auth_srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "proj4text": { + "name": "proj4text", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "srtext": { + "name": "srtext", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "spatial_ref_sys_pkey": [ + "srid" + ] + }, + "foreignRelations": {}, + "description": null + }, + "topology_layer": { + "schemaName": "topology", + "tableName": "layer", + "columns": { + "child_id": { + "name": "child_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "feature_column": { + "name": "feature_column", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "feature_type": { + "name": "feature_type", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "layer_id": { + "name": "layer_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "level": { + "name": "level", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "schema_name": { + "name": "schema_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "table_name": { + "name": "table_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "topology_id": { + "name": "topology_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "layer_pkey": [ + "layer_id", + "topology_id" + ], + "layer_schema_name_table_name_feature_column_key": [ + "feature_column", + "schema_name", + "table_name" + ] + }, + "foreignRelations": { + "layer_topology_id_fkey": { + "foreignSchema": "topology", + "foreignTable": "topology", + "columnMapping": { + "topology_id": "id" + } + } + }, + "description": null + }, + "topology_topology": { + "schemaName": "topology", + "tableName": "topology", + "columns": { + "hasz": { + "name": "hasz", + "type": { + "scalarType": "bool" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "precision": { + "name": "precision", + "type": { + "scalarType": "float8" + }, + "nullable": "nonNullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "topology_name_key": [ + "name" + ], + "topology_pkey": [ + "id" + ] + }, + "foreignRelations": {}, + "description": null + } + }, + "types": { + "scalar": { + "Phone": { + "typeName": "Phone", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "Phone", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "Phone", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": [ + "hearts", + "clubs", + "diamonds", + "spades" + ] + } + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "even_number": { + "typeName": "even_number", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "even_number", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "even_number", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "bit_xor": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "bit_xor": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "chara": { + "typeName": "chara", + "schemaName": "public", + "fields": { + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "popularity": { + "fieldName": "popularity", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "characters": { + "typeName": "characters", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "chara" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "discoverable_types": { + "typeName": "discoverable_types", + "schemaName": "public", + "fields": { + "only_occurring_here1": { + "fieldName": "only_occurring_here1", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + } + } + }, + "nativeOperations": { + "queries": {}, + "mutations": {} + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": [ + "public" + ], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": null +} diff --git a/crates/tests/databases-tests/src/yugabyte/common.rs b/crates/tests/databases-tests/src/yugabyte/common.rs index 6452577d7..37caa9965 100644 --- a/crates/tests/databases-tests/src/yugabyte/common.rs +++ b/crates/tests/databases-tests/src/yugabyte/common.rs @@ -1,6 +1,6 @@ //! Common functions used across test cases. -pub const CHINOOK_NDC_METADATA_PATH: &str = "static/yugabyte/v4-chinook-ndc-metadata"; +pub const CHINOOK_NDC_METADATA_PATH: &str = "static/yugabyte/v5-configuration"; pub const CONNECTION_URI: &str = "postgresql://yugabyte@localhost:64005"; diff --git a/crates/tests/tests-common/src/common_tests/configuration_tests.rs b/crates/tests/tests-common/src/common_tests/configuration_tests.rs index d91c16e9f..a46b3cb32 100644 --- a/crates/tests/tests-common/src/common_tests/configuration_tests.rs +++ b/crates/tests/tests-common/src/common_tests/configuration_tests.rs @@ -1,17 +1,16 @@ //! Tests the configuration generation has not changed. -use ndc_postgres_configuration::version4; +use ndc_postgres_configuration::version5; use ndc_postgres_configuration::ParsedConfiguration; use std::collections::HashMap; use std::path::{Path, PathBuf}; /// Test native query introspection. -pub async fn test_native_operation_create( +pub async fn test_native_operation_create_v5( connection_string: &str, ndc_metadata_path: impl AsRef + Sync, sql: String, - kind: version4::native_operations::Kind, -) -> anyhow::Result { +) -> anyhow::Result { let configuration = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("../../..") .join(ndc_metadata_path); @@ -21,13 +20,13 @@ pub async fn test_native_operation_create( match parsed_configuration { ParsedConfiguration::Version3(_) => anyhow::bail!("version3"), - ParsedConfiguration::Version4(parsed_configuration) => { - let result = version4::native_operations::create( + ParsedConfiguration::Version4(_) => anyhow::bail!("version4"), + ParsedConfiguration::Version5(parsed_configuration) => { + let result = version5::native_operations::create( &parsed_configuration, connection_string, &PathBuf::from("test.sql"), &sql, - kind, ) .await?; diff --git a/crates/tests/tests-common/src/ndc_metadata/configuration.rs b/crates/tests/tests-common/src/ndc_metadata/configuration.rs index f8b1dc7bb..d2123afde 100644 --- a/crates/tests/tests-common/src/ndc_metadata/configuration.rs +++ b/crates/tests/tests-common/src/ndc_metadata/configuration.rs @@ -66,5 +66,9 @@ fn set_connection_uri(input: ParsedConfiguration, connection_uri: String) -> Par config.connection_settings.connection_uri = connection_uri.into(); ParsedConfiguration::Version4(config) } + ParsedConfiguration::Version5(mut config) => { + config.connection_settings.connection_uri = connection_uri.into(); + ParsedConfiguration::Version5(config) + } } } diff --git a/justfile b/justfile index 0a044af8e..aad5530bb 100644 --- a/justfile +++ b/justfile @@ -12,20 +12,20 @@ CONNECTOR_IMAGE := CONNECTOR_IMAGE_NAME + ":" + CONNECTOR_IMAGE_TAG POSTGRESQL_CONNECTION_URI := "postgresql://postgres:password@localhost:64002" POSTGRESQL_EMPTY_CONNECTION_URI := "postgresql://postgres:password@localhost:64002/empty" -POSTGRES_LATEST_CHINOOK_NDC_METADATA := "static/postgres/v4-chinook-ndc-metadata" +POSTGRES_LATEST_CHINOOK_NDC_METADATA := "static/postgres/v5-configuration" POSTGRES_BROKEN_QUERIES_NDC_METADATA := "static/postgres/broken-queries-ndc-metadata" COCKROACH_CONNECTION_URI := "postgresql://postgres:password@localhost:64003/defaultdb" -COCKROACH_LATEST_CHINOOK_NDC_METADATA := "static/cockroach/v4-chinook-ndc-metadata" +COCKROACH_LATEST_CHINOOK_NDC_METADATA := "static/cockroach/v5-configuration" CITUS_CONNECTION_URI := "postgresql://postgres:password@localhost:64004?sslmode=disable" -CITUS_LATEST_CHINOOK_NDC_METADATA := "static/citus/v4-chinook-ndc-metadata" +CITUS_LATEST_CHINOOK_NDC_METADATA := "static/citus/v5-configuration" YUGABYTE_CONNECTION_URI := "postgresql://yugabyte@localhost:64005" -YUGABYTE_LATEST_CHINOOK_NDC_METADATA := "static/yugabyte/v4-chinook-ndc-metadata" +YUGABYTE_LATEST_CHINOOK_NDC_METADATA := "static/yugabyte/v5-configuration" AURORA_CONNECTION_URI := env_var_or_default('AURORA_CONNECTION_URI', '') -AURORA_LATEST_CHINOOK_NDC_METADATA := "static/aurora/v4-chinook-ndc-metadata" +AURORA_LATEST_CHINOOK_NDC_METADATA := "static/aurora/v5-configuration" # Notes: # * Building Docker images will not work on macOS. diff --git a/static/aurora/v3-chinook-ndc-metadata/configuration.json b/static/aurora/v3-chinook-ndc-metadata/configuration.json deleted file mode 100644 index b7fe8db72..000000000 --- a/static/aurora/v3-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3048 +0,0 @@ -{ - "version": "3", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 1, - "poolTimeout": 600, - "idleTimeout": 180, - "connectionLifetime": 600, - "checkConnectionAfterIdle": 60 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Album_pkey": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": null - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Artist_pkey": ["ArtistId"] - }, - "foreignRelations": {}, - "description": null - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Customer_pkey": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": null - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Employee_pkey": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Genre_pkey": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Invoice_pkey": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "InvoiceLine_pkey": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "MediaType_pkey": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - } - }, - "uniquenessConstraints": { - "Playlist_pkey": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Track_pkey": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - } - }, - "compositeTypes": { - "committee": { - "name": "committee", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "name": "organization", - "fields": { - "committees": { - "name": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "name": "person", - "fields": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "name": "person_address", - "fields": { - "address_line_1": { - "name": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": null - }, - "address_line_2": { - "name": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person_name": { - "name": "person_name", - "fields": { - "first_name": { - "name": "first_name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "last_name": { - "name": "last_name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": "SELECT {{address}} as result", - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)", - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr", - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": "SELECT * FROM public.\"Artist\"", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}", - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": "SELECT array_length({{array_argument}}, 1) as result", - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": "SELECT ROW({{name}}, {{address}})::person as result", - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true", - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid", - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - }, - "aggregateFunctions": { - "bool": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "char": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "date": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "float4": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "float8": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "int2": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int4": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int8": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "interval": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "numeric": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "text": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "time": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "timestamp": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "timestamptz": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "timetz": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "varchar": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - } - }, - "comparisonOperators": { - "bool": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "char": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "date": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "float4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "float8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "int2": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "int4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "int8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "interval": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "numeric": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "text": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "time": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "timestamp": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "timestamptz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "timetz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "uuid": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "varchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - } - }, - "typeRepresentations": { - "bool": "boolean", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64", - "numeric": "bigDecimal", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ] - }, - "mutationsVersion": null -} diff --git a/static/aurora/v4-chinook-ndc-metadata/configuration.json b/static/aurora/v4-chinook-ndc-metadata/configuration.json deleted file mode 100644 index fcfdbdaa7..000000000 --- a/static/aurora/v4-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3182 +0,0 @@ -{ - "version": "4", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 1, - "poolTimeout": 600, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Album_pkey": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": null - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Artist_pkey": ["ArtistId"] - }, - "foreignRelations": {}, - "description": null - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Customer_pkey": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": null - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Employee_pkey": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "Genre_pkey": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Invoice_pkey": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "InvoiceLine_pkey": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "MediaType_pkey": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - } - }, - "uniquenessConstraints": { - "Playlist_pkey": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "Track_pkey": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - } - }, - "scalarTypes": { - "bool": { - "typeName": "bool", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "typeRepresentation": "boolean" - }, - "char": { - "typeName": "char", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "date": { - "typeName": "date", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "typeRepresentation": "date" - }, - "float4": { - "typeName": "float4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "typeRepresentation": "float32" - }, - "float8": { - "typeName": "float8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "typeRepresentation": "float64" - }, - "int2": { - "typeName": "int2", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "typeRepresentation": "int16" - }, - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "int8": { - "typeName": "int8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "typeRepresentation": "int64AsString" - }, - "interval": { - "typeName": "interval", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "typeRepresentation": null - }, - "numeric": { - "typeName": "numeric", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "typeRepresentation": "bigDecimalAsString" - }, - "text": { - "typeName": "text", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "time": { - "typeName": "time", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "typeRepresentation": "time" - }, - "timestamp": { - "typeName": "timestamp", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "typeRepresentation": "timestamp" - }, - "timestamptz": { - "typeName": "timestamptz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "typeRepresentation": "timestamptz" - }, - "timetz": { - "typeName": "timetz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "typeRepresentation": "timetz" - }, - "uuid": { - "typeName": "uuid", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "typeRepresentation": "uUID" - }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - }, - "typeRepresentation": "string" - } - }, - "compositeTypes": { - "committee": { - "typeName": "committee", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "typeName": "organization", - "schemaName": "public", - "fields": { - "committees": { - "fieldName": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "typeName": "person", - "schemaName": "public", - "fields": { - "address": { - "fieldName": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "typeName": "person_address", - "schemaName": "public", - "fields": { - "address_line_1": { - "fieldName": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": null - }, - "address_line_2": { - "fieldName": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person_name": { - "typeName": "person_name", - "schemaName": "public", - "fields": { - "first_name": { - "fieldName": "first_name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "last_name": { - "fieldName": "last_name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "mutationsVersion": null -} diff --git a/static/aurora/v5-configuration/configuration.json b/static/aurora/v5-configuration/configuration.json new file mode 100644 index 000000000..64209285b --- /dev/null +++ b/static/aurora/v5-configuration/configuration.json @@ -0,0 +1,3185 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 1, + "poolTimeout": 600, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "Album_pkey": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": null + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "Artist_pkey": ["ArtistId"] + }, + "foreignRelations": {}, + "description": null + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "Customer_pkey": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": null + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "Employee_pkey": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "Genre_pkey": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "Invoice_pkey": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "InvoiceLine_pkey": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "MediaType_pkey": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + } + }, + "uniquenessConstraints": { + "Playlist_pkey": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "Track_pkey": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + } + }, + "types": { + "scalar": { + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float4" + }, + "min": { + "returnType": "float4" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float4" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "bit_xor": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "bit_xor": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "interval" + }, + "min": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "time" + }, + "min": { + "returnType": "time" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamptz" + }, + "min": { + "returnType": "timestamptz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timetz" + }, + "min": { + "returnType": "timetz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "committee": { + "typeName": "committee", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "person_name" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "organization": { + "typeName": "organization", + "schemaName": "public", + "fields": { + "committees": { + "fieldName": "committees", + "type": { + "arrayType": { + "compositeType": "committee" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person": { + "typeName": "person", + "schemaName": "public", + "fields": { + "address": { + "fieldName": "address", + "type": { + "compositeType": "person_address" + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "compositeType": "person_name" + }, + "description": null + } + }, + "description": null + }, + "person_address": { + "typeName": "person_address", + "schemaName": "public", + "fields": { + "address_line_1": { + "fieldName": "address_line_1", + "type": { + "scalarType": "text" + }, + "description": null + }, + "address_line_2": { + "fieldName": "address_line_2", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person_name": { + "typeName": "person_name", + "schemaName": "public", + "fields": { + "first_name": { + "fieldName": "first_name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "last_name": { + "fieldName": "last_name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + } + } + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "make_person": { + "sql": { + "inline": "SELECT ROW({{name}}, {{address}})::person as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "person_name" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "summarize_organizations": { + "sql": { + "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organizations": { + "name": "organizations", + "type": { + "arrayType": { + "compositeType": "organization" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": null +} diff --git a/static/citus/v3-chinook-ndc-metadata/configuration.json b/static/citus/v3-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 19c49f8ae..000000000 --- a/static/citus/v3-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3677 +0,0 @@ -{ - "version": "3", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "connectionLifetime": 600, - "checkConnectionAfterIdle": 60 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - } - }, - "compositeTypes": { - "chara": { - "name": "chara", - "fields": { - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "name": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "name": "characters", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "name": "committee", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "name": "discoverable_types", - "fields": { - "only_occurring_here1": { - "name": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "name": "organization", - "fields": { - "committees": { - "name": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "name": "person", - "fields": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "name": "person_address", - "fields": { - "address_line_1": { - "name": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "name": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "name": "person_name", - "fields": { - "first_name": { - "name": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "name": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - }, - "aggregateFunctions": { - "Phone": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "bit": { - "bit_and": { - "returnType": "bit" - }, - "bit_or": { - "returnType": "bit" - }, - "bit_xor": { - "returnType": "bit" - } - }, - "bool": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "bpchar": { - "max": { - "returnType": "bpchar" - }, - "min": { - "returnType": "bpchar" - } - }, - "card_suit": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "char": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "date": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "even_number": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "float4": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "float8": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "int2": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int4": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int8": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "interval": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "numeric": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "text": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "time": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "timestamp": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "timestamptz": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "timetz": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "varchar": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - } - }, - "comparisonOperators": { - "Phone": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "bit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - } - }, - "bool": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "bpchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bpchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bpchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - } - }, - "card_suit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "char": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "date": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "even_number": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "float4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "float8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "int2": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "int4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "int8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "interval": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "numeric": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "text": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "time": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "timestamp": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "timestamptz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "timetz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "uuid": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "varchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - } - }, - "typeRepresentations": { - "Phone": "string", - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "card_suit": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - }, - "char": "string", - "date": "date", - "even_number": "int32", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64", - "numeric": "bigDecimal", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ] - }, - "mutationsVersion": "v1" -} diff --git a/static/citus/v4-chinook-ndc-metadata/configuration.json b/static/citus/v4-chinook-ndc-metadata/configuration.json deleted file mode 100644 index c816e4008..000000000 --- a/static/citus/v4-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3634 +0,0 @@ -{ - "version": "4", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - } - }, - "scalarTypes": { - "Phone": { - "typeName": "Phone", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "bool": { - "typeName": "bool", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "typeRepresentation": "boolean" - }, - "card_suit": { - "typeName": "card_suit", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "typeRepresentation": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - } - }, - "char": { - "typeName": "char", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "date": { - "typeName": "date", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "typeRepresentation": "date" - }, - "even_number": { - "typeName": "even_number", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "float4": { - "typeName": "float4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "typeRepresentation": "float32" - }, - "float8": { - "typeName": "float8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "typeRepresentation": "float64" - }, - "int2": { - "typeName": "int2", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "typeRepresentation": "int16" - }, - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "int8": { - "typeName": "int8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "typeRepresentation": "int64AsString" - }, - "interval": { - "typeName": "interval", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "typeRepresentation": null - }, - "numeric": { - "typeName": "numeric", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "typeRepresentation": "bigDecimalAsString" - }, - "text": { - "typeName": "text", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "time": { - "typeName": "time", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "typeRepresentation": "time" - }, - "timestamp": { - "typeName": "timestamp", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "typeRepresentation": "timestamp" - }, - "timestamptz": { - "typeName": "timestamptz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "typeRepresentation": "timestamptz" - }, - "timetz": { - "typeName": "timetz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "typeRepresentation": "timetz" - }, - "uuid": { - "typeName": "uuid", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "typeRepresentation": "uUID" - }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - }, - "typeRepresentation": "string" - } - }, - "compositeTypes": { - "chara": { - "typeName": "chara", - "schemaName": "public", - "fields": { - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "fieldName": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "typeName": "characters", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "typeName": "committee", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "typeName": "discoverable_types", - "schemaName": "public", - "fields": { - "only_occurring_here1": { - "fieldName": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "typeName": "organization", - "schemaName": "public", - "fields": { - "committees": { - "fieldName": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "typeName": "person", - "schemaName": "public", - "fields": { - "address": { - "fieldName": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "typeName": "person_address", - "schemaName": "public", - "fields": { - "address_line_1": { - "fieldName": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "fieldName": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "typeName": "person_name", - "schemaName": "public", - "fields": { - "first_name": { - "fieldName": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "fieldName": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "mutationsVersion": "v1" -} diff --git a/static/citus/v5-configuration/configuration.json b/static/citus/v5-configuration/configuration.json new file mode 100644 index 000000000..a66743fd5 --- /dev/null +++ b/static/citus/v5-configuration/configuration.json @@ -0,0 +1,3637 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": ["ArtistId"] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "even_numbers": { + "schemaName": "public", + "tableName": "even_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "even_number" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "group_leader": { + "schemaName": "public", + "tableName": "group_leader", + "columns": { + "characters": { + "name": "characters", + "type": { + "compositeType": "characters" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "chara" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "phone_numbers": { + "schemaName": "public", + "tableName": "phone_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "Phone" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + } + }, + "types": { + "scalar": { + "Phone": { + "typeName": "Phone", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "Phone", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "Phone", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": ["hearts", "clubs", "diamonds", "spades"] + } + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "even_number": { + "typeName": "even_number", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "even_number", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "even_number", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float4" + }, + "min": { + "returnType": "float4" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float4" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "bit_xor": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "bit_xor": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "interval" + }, + "min": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "time" + }, + "min": { + "returnType": "time" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamptz" + }, + "min": { + "returnType": "timestamptz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timetz" + }, + "min": { + "returnType": "timetz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "chara": { + "typeName": "chara", + "schemaName": "public", + "fields": { + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "popularity": { + "fieldName": "popularity", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "characters": { + "typeName": "characters", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "chara" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "committee": { + "typeName": "committee", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "person_name" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "discoverable_types": { + "typeName": "discoverable_types", + "schemaName": "public", + "fields": { + "only_occurring_here1": { + "fieldName": "only_occurring_here1", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "organization": { + "typeName": "organization", + "schemaName": "public", + "fields": { + "committees": { + "fieldName": "committees", + "type": { + "arrayType": { + "compositeType": "committee" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person": { + "typeName": "person", + "schemaName": "public", + "fields": { + "address": { + "fieldName": "address", + "type": { + "compositeType": "person_address" + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "compositeType": "person_name" + }, + "description": null + } + }, + "description": null + }, + "person_address": { + "typeName": "person_address", + "schemaName": "public", + "fields": { + "address_line_1": { + "fieldName": "address_line_1", + "type": { + "scalarType": "text" + }, + "description": "Address line No 1" + }, + "address_line_2": { + "fieldName": "address_line_2", + "type": { + "scalarType": "text" + }, + "description": "Address line No 2" + } + }, + "description": "The address of a person, obviously" + }, + "person_name": { + "typeName": "person_name", + "schemaName": "public", + "fields": { + "first_name": { + "fieldName": "first_name", + "type": { + "scalarType": "text" + }, + "description": "The first name of a person" + }, + "last_name": { + "fieldName": "last_name", + "type": { + "scalarType": "text" + }, + "description": "The last name of a person" + } + }, + "description": "The name of a person, obviously" + } + } + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "make_person": { + "sql": { + "inline": "SELECT ROW({{name}}, {{address}})::person as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "person_name" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "organization_identity_function": { + "sql": { + "inline": "SELECT {{organization}} as result_the_column" + }, + "columns": { + "result_the_field": { + "name": "result_the_column", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organization": { + "name": "organization", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "summarize_organizations": { + "sql": { + "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organizations": { + "name": "organizations", + "type": { + "arrayType": { + "compositeType": "organization" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": "v1" +} diff --git a/static/cockroach/v3-chinook-ndc-metadata/configuration.json b/static/cockroach/v3-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 800a5c1fb..000000000 --- a/static/cockroach/v3-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3075 +0,0 @@ -{ - "version": "3", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "connectionLifetime": 600, - "checkConnectionAfterIdle": 60 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "rowid": { - "name": "rowid", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "deck_of_cards_pkey": ["rowid"] - }, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - }, - "rowid": { - "name": "rowid", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - } - }, - "uniquenessConstraints": { - "discoverable_types_root_occurrence_pkey": ["rowid"] - }, - "foreignRelations": {}, - "description": null - }, - "pg_extension_spatial_ref_sys": { - "schemaName": "pg_extension", - "tableName": "spatial_ref_sys", - "columns": { - "auth_name": { - "name": "auth_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "auth_srid": { - "name": "auth_srid", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "proj4text": { - "name": "proj4text", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "srtext": { - "name": "srtext", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": "Shows all defined Spatial Reference Identifiers (SRIDs). Matches PostGIS' spatial_ref_sys table." - } - }, - "compositeTypes": {}, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - }, - "aggregateFunctions": { - "bool": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "card_suit": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "char": { - "concat_agg": { - "returnType": "text" - } - }, - "float4": { - "avg": { - "returnType": "float8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "float8": { - "avg": { - "returnType": "float8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "int2": { - "avg": { - "returnType": "float8" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "int4": { - "avg": { - "returnType": "float8" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "int8": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "interval": { - "avg": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "numeric": { - "avg": { - "returnType": "numeric" - }, - "sqrdiff": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "text": { - "concat_agg": { - "returnType": "text" - } - }, - "time": { - "avg": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "varchar": { - "concat_agg": { - "returnType": "text" - } - } - }, - "comparisonOperators": { - "bool": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "card_suit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "char": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "date": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "float4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "float8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "int2": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "int4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "int8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "interval": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "numeric": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "text": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "time": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "timestamp": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "timestamptz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "timetz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "uuid": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "varchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - } - }, - "typeRepresentations": { - "bool": "boolean", - "card_suit": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - }, - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64", - "numeric": "bigDecimal", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ] - }, - "mutationsVersion": "v1" -} diff --git a/static/cockroach/v4-chinook-ndc-metadata/configuration.json b/static/cockroach/v4-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 71944b15f..000000000 --- a/static/cockroach/v4-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3187 +0,0 @@ -{ - "version": "4", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "rowid": { - "name": "rowid", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "deck_of_cards_pkey": ["rowid"] - }, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - }, - "rowid": { - "name": "rowid", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - } - }, - "uniquenessConstraints": { - "discoverable_types_root_occurrence_pkey": ["rowid"] - }, - "foreignRelations": {}, - "description": null - }, - "pg_extension_spatial_ref_sys": { - "schemaName": "pg_extension", - "tableName": "spatial_ref_sys", - "columns": { - "auth_name": { - "name": "auth_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "auth_srid": { - "name": "auth_srid", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "proj4text": { - "name": "proj4text", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "srtext": { - "name": "srtext", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": "Shows all defined Spatial Reference Identifiers (SRIDs). Matches PostGIS' spatial_ref_sys table." - } - }, - "scalarTypes": { - "bool": { - "typeName": "bool", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "typeRepresentation": "boolean" - }, - "card_suit": { - "typeName": "card_suit", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "typeRepresentation": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - } - }, - "char": { - "typeName": "char", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "concat_agg": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "date": { - "typeName": "date", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "typeRepresentation": "date" - }, - "float4": { - "typeName": "float4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "typeRepresentation": "float32" - }, - "float8": { - "typeName": "float8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "typeRepresentation": "float64" - }, - "int2": { - "typeName": "int2", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "typeRepresentation": "int16" - }, - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "int8": { - "typeName": "int8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "sqrdiff": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "sum_int": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - }, - "xor_agg": { - "returnType": "int8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "typeRepresentation": "int64AsString" - }, - "interval": { - "typeName": "interval", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "typeRepresentation": null - }, - "numeric": { - "typeName": "numeric", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "sqrdiff": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "typeRepresentation": "bigDecimalAsString" - }, - "text": { - "typeName": "text", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "concat_agg": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "time": { - "typeName": "time", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "typeRepresentation": "time" - }, - "timestamp": { - "typeName": "timestamp", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "typeRepresentation": "timestamp" - }, - "timestamptz": { - "typeName": "timestamptz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "typeRepresentation": "timestamptz" - }, - "timetz": { - "typeName": "timetz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "typeRepresentation": "timetz" - }, - "uuid": { - "typeName": "uuid", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "typeRepresentation": "uUID" - }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "concat_agg": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "ILIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "LIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "NOT ILIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "NOT LIKE", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nsimilar": { - "operatorName": "NOT SIMILAR TO", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_similar": { - "operatorName": "SIMILAR TO", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - }, - "typeRepresentation": "string" - } - }, - "compositeTypes": {}, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "mutationsVersion": "v1" -} diff --git a/static/cockroach/v5-configuration/configuration.json b/static/cockroach/v5-configuration/configuration.json new file mode 100644 index 000000000..57fa5648b --- /dev/null +++ b/static/cockroach/v5-configuration/configuration.json @@ -0,0 +1,3190 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": ["ArtistId"] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "rowid": { + "name": "rowid", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "deck_of_cards_pkey": ["rowid"] + }, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + }, + "rowid": { + "name": "rowid", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + } + }, + "uniquenessConstraints": { + "discoverable_types_root_occurrence_pkey": ["rowid"] + }, + "foreignRelations": {}, + "description": null + }, + "pg_extension_spatial_ref_sys": { + "schemaName": "pg_extension", + "tableName": "spatial_ref_sys", + "columns": { + "auth_name": { + "name": "auth_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "auth_srid": { + "name": "auth_srid", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "proj4text": { + "name": "proj4text", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "srtext": { + "name": "srtext", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": "Shows all defined Spatial Reference Identifiers (SRIDs). Matches PostGIS' spatial_ref_sys table." + } + }, + "types": { + "scalar": { + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": ["hearts", "clubs", "diamonds", "spades"] + } + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "concat_agg": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "ILIKE", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "LIKE", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "NOT ILIKE", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "NOT LIKE", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nsimilar": { + "operatorName": "NOT SIMILAR TO", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_similar": { + "operatorName": "SIMILAR TO", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "sqrdiff": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "sqrdiff": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "sqrdiff": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "sum_int": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + }, + "xor_agg": { + "returnType": "int8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "sqrdiff": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "sum_int": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + }, + "xor_agg": { + "returnType": "int8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "sqrdiff": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "sum_int": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + }, + "xor_agg": { + "returnType": "int8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "sqrdiff": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "concat_agg": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "ILIKE", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "LIKE", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "NOT ILIKE", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "NOT LIKE", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nsimilar": { + "operatorName": "NOT SIMILAR TO", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_similar": { + "operatorName": "SIMILAR TO", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "concat_agg": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "ILIKE", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "LIKE", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "NOT ILIKE", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "NOT LIKE", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nsimilar": { + "operatorName": "NOT SIMILAR TO", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_similar": { + "operatorName": "SIMILAR TO", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": {} + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": "v1" +} diff --git a/static/ndc-metadata-snapshots/48486e66058b25ceac1f21330b805617e1f6cd058a5123a1c4a7877da0bb9955/configuration.json b/static/ndc-metadata-snapshots/48486e66058b25ceac1f21330b805617e1f6cd058a5123a1c4a7877da0bb9955/configuration.json new file mode 100644 index 000000000..546f3d529 --- /dev/null +++ b/static/ndc-metadata-snapshots/48486e66058b25ceac1f21330b805617e1f6cd058a5123a1c4a7877da0bb9955/configuration.json @@ -0,0 +1,4046 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": ["ArtistId"] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "custom_defaults": { + "schemaName": "custom", + "tableName": "defaults", + "columns": { + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "defaults_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + }, + "custom_dog": { + "schemaName": "custom", + "tableName": "dog", + "columns": { + "adopter_name": { + "name": "adopter_name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "dog_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "even_numbers": { + "schemaName": "public", + "tableName": "even_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "even_number" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "group_leader": { + "schemaName": "public", + "tableName": "group_leader", + "columns": { + "characters": { + "name": "characters", + "type": { + "compositeType": "characters" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "chara" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "phone_numbers": { + "schemaName": "public", + "tableName": "phone_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "Phone" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "spatial_ref_sys": { + "schemaName": "public", + "tableName": "spatial_ref_sys", + "columns": { + "auth_name": { + "name": "auth_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "auth_srid": { + "name": "auth_srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "proj4text": { + "name": "proj4text", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "srtext": { + "name": "srtext", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "spatial_ref_sys_pkey": ["srid"] + }, + "foreignRelations": {}, + "description": null + }, + "topology_layer": { + "schemaName": "topology", + "tableName": "layer", + "columns": { + "child_id": { + "name": "child_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "feature_column": { + "name": "feature_column", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "feature_type": { + "name": "feature_type", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "layer_id": { + "name": "layer_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "level": { + "name": "level", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "schema_name": { + "name": "schema_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "table_name": { + "name": "table_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "topology_id": { + "name": "topology_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "layer_pkey": ["layer_id", "topology_id"], + "layer_schema_name_table_name_feature_column_key": [ + "feature_column", + "schema_name", + "table_name" + ] + }, + "foreignRelations": { + "layer_topology_id_fkey": { + "foreignSchema": "topology", + "foreignTable": "topology", + "columnMapping": { + "topology_id": "id" + } + } + }, + "description": null + }, + "topology_topology": { + "schemaName": "topology", + "tableName": "topology", + "columns": { + "hasz": { + "name": "hasz", + "type": { + "scalarType": "bool" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "precision": { + "name": "precision", + "type": { + "scalarType": "float8" + }, + "nullable": "nonNullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "topology_name_key": ["name"], + "topology_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + } + }, + "types": { + "scalar": { + "Phone": { + "typeName": "Phone", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "Phone", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "Phone", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": ["hearts", "clubs", "diamonds", "spades"] + } + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "even_number": { + "typeName": "even_number", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "even_number", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "even_number", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float4" + }, + "min": { + "returnType": "float4" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float4" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "bit_xor": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "bit_xor": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "interval" + }, + "min": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "time" + }, + "min": { + "returnType": "time" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamptz" + }, + "min": { + "returnType": "timestamptz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timetz" + }, + "min": { + "returnType": "timetz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "chara": { + "typeName": "chara", + "schemaName": "public", + "fields": { + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "popularity": { + "fieldName": "popularity", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "characters": { + "typeName": "characters", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "chara" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "committee": { + "typeName": "committee", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "person_name" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "discoverable_types": { + "typeName": "discoverable_types", + "schemaName": "public", + "fields": { + "only_occurring_here1": { + "fieldName": "only_occurring_here1", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "organization": { + "typeName": "organization", + "schemaName": "public", + "fields": { + "committees": { + "fieldName": "committees", + "type": { + "arrayType": { + "compositeType": "committee" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person": { + "typeName": "person", + "schemaName": "public", + "fields": { + "address": { + "fieldName": "address", + "type": { + "compositeType": "person_address" + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "compositeType": "person_name" + }, + "description": null + } + }, + "description": null + }, + "person_address": { + "typeName": "person_address", + "schemaName": "public", + "fields": { + "address_line_1": { + "fieldName": "address_line_1", + "type": { + "scalarType": "text" + }, + "description": "Address line No 1" + }, + "address_line_2": { + "fieldName": "address_line_2", + "type": { + "scalarType": "text" + }, + "description": "Address line No 2" + } + }, + "description": "The address of a person, obviously" + }, + "person_name": { + "typeName": "person_name", + "schemaName": "public", + "fields": { + "first_name": { + "fieldName": "first_name", + "type": { + "scalarType": "text" + }, + "description": "The first name of a person" + }, + "last_name": { + "fieldName": "last_name", + "type": { + "scalarType": "text" + }, + "description": "The last name of a person" + } + }, + "description": "The name of a person, obviously" + } + } + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "make_person": { + "sql": { + "inline": "SELECT ROW({{name}}, {{address}})::person as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "person_name" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "organization_identity_function": { + "sql": { + "inline": "SELECT {{organization}} as result_the_column" + }, + "columns": { + "result_the_field": { + "name": "result_the_column", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organization": { + "name": "organization", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "summarize_organizations": { + "sql": { + "file": "./native_queries/summarize_organizations.sql" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organizations": { + "name": "organizations", + "type": { + "arrayType": { + "compositeType": "organization" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": "v2" +} diff --git a/static/postgres/v3-chinook-ndc-metadata/native_queries/summarize_organizations.sql b/static/ndc-metadata-snapshots/48486e66058b25ceac1f21330b805617e1f6cd058a5123a1c4a7877da0bb9955/native_queries/summarize_organizations.sql similarity index 100% rename from static/postgres/v3-chinook-ndc-metadata/native_queries/summarize_organizations.sql rename to static/ndc-metadata-snapshots/48486e66058b25ceac1f21330b805617e1f6cd058a5123a1c4a7877da0bb9955/native_queries/summarize_organizations.sql diff --git a/static/ndc-metadata-snapshots/4f37dfdcdcfd2930881e96ec9f83f30ae46929e9bac92912e83ee5d700dee301/schema.json b/static/ndc-metadata-snapshots/4f37dfdcdcfd2930881e96ec9f83f30ae46929e9bac92912e83ee5d700dee301/schema.json deleted file mode 100644 index 08371633f..000000000 --- a/static/ndc-metadata-snapshots/4f37dfdcdcfd2930881e96ec9f83f30ae46929e9bac92912e83ee5d700dee301/schema.json +++ /dev/null @@ -1,1387 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "ParsedConfiguration", - "description": "Initial configuration, just enough to connect to a database and elaborate a full 'Configuration'.", - "type": "object", - "required": ["version"], - "properties": { - "version": { - "$ref": "#/definitions/Version" - }, - "$schema": { - "description": "Jsonschema of the configuration format.", - "type": ["string", "null"] - }, - "connectionSettings": { - "description": "Database connection settings.", - "default": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "allOf": [ - { - "$ref": "#/definitions/DatabaseConnectionSettings" - } - ] - }, - "metadata": { - "description": "Connector metadata.", - "default": { - "tables": {}, - "scalarTypes": {}, - "compositeTypes": {}, - "nativeQueries": {} - }, - "allOf": [ - { - "$ref": "#/definitions/Metadata" - } - ] - }, - "introspectionOptions": { - "description": "Database introspection options.", - "default": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "allOf": [ - { - "$ref": "#/definitions/IntrospectionOptions" - } - ] - }, - "mutationsVersion": { - "description": "Which version of the generated mutation procedures to include in the schema response", - "anyOf": [ - { - "$ref": "#/definitions/MutationsVersion" - }, - { - "type": "null" - } - ] - } - }, - "definitions": { - "Version": { - "type": "string", - "enum": ["4"] - }, - "DatabaseConnectionSettings": { - "description": "Database connection settings.", - "type": "object", - "required": ["connectionUri"], - "properties": { - "connectionUri": { - "description": "Connection string for a Postgres-compatible database.", - "allOf": [ - { - "$ref": "#/definitions/ConnectionUri" - } - ] - }, - "poolSettings": { - "description": "Connection pool settings.", - "default": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "allOf": [ - { - "$ref": "#/definitions/PoolSettings" - } - ] - }, - "isolationLevel": { - "description": "Query isolation level.", - "default": "ReadCommitted", - "allOf": [ - { - "$ref": "#/definitions/IsolationLevel" - } - ] - } - } - }, - "ConnectionUri": { - "$ref": "#/definitions/Secret" - }, - "Secret": { - "anyOf": [ - { - "type": "string" - }, - { - "type": "object", - "required": ["variable"], - "properties": { - "variable": { - "$ref": "#/definitions/Variable" - } - } - } - ] - }, - "Variable": { - "description": "The name of an an environment variable.", - "type": "string" - }, - "PoolSettings": { - "description": "Settings for the PostgreSQL connection pool", - "type": "object", - "properties": { - "maxConnections": { - "description": "maximum number of pool connections", - "default": 50, - "type": "integer", - "format": "uint32", - "minimum": 0.0 - }, - "poolTimeout": { - "description": "timeout for acquiring a connection from the pool (seconds)", - "default": 30, - "type": "integer", - "format": "uint64", - "minimum": 0.0 - }, - "idleTimeout": { - "description": "idle timeout for releasing a connection from the pool (seconds)", - "default": 180, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - }, - "checkConnectionAfterIdle": { - "description": "check the connection is alive after being idle for N seconds. Set to null to always check.", - "default": 60, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - }, - "connectionLifetime": { - "description": "maximum lifetime for an individual connection (seconds)", - "default": 600, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - } - } - }, - "IsolationLevel": { - "description": "The isolation level of the transaction in which a query is executed.", - "oneOf": [ - { - "description": "Prevents reading data from another uncommitted transaction.", - "type": "string", - "enum": ["ReadCommitted"] - }, - { - "description": "Reading the same data twice is guaranteed to return the same result.", - "type": "string", - "enum": ["RepeatableRead"] - }, - { - "description": "Concurrent transactions behave identically to serializing them one at a time.", - "type": "string", - "enum": ["Serializable"] - } - ] - }, - "Metadata": { - "description": "Metadata information.", - "type": "object", - "properties": { - "tables": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/TablesInfo" - } - ] - }, - "scalarTypes": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/ScalarTypes" - } - ] - }, - "compositeTypes": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/CompositeTypes" - } - ] - }, - "nativeQueries": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/NativeQueries" - } - ] - } - } - }, - "TablesInfo": { - "description": "Mapping from a \"table\" name to its information.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/TableInfo" - } - }, - "TableInfo": { - "description": "Information about a database table (or any other kind of relation).", - "type": "object", - "required": ["columns", "schemaName", "tableName"], - "properties": { - "schemaName": { - "type": "string" - }, - "tableName": { - "type": "string" - }, - "columns": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ColumnInfo" - } - }, - "uniquenessConstraints": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/UniquenessConstraints" - } - ] - }, - "foreignRelations": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/ForeignRelations" - } - ] - }, - "description": { - "type": ["string", "null"] - } - } - }, - "ColumnInfo": { - "description": "Information about a database column.", - "type": "object", - "required": ["name", "type"], - "properties": { - "name": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "nullable": { - "default": "nullable", - "allOf": [ - { - "$ref": "#/definitions/Nullable" - } - ] - }, - "hasDefault": { - "$ref": "#/definitions/HasDefault" - }, - "isIdentity": { - "$ref": "#/definitions/IsIdentity" - }, - "isGenerated": { - "$ref": "#/definitions/IsGenerated" - }, - "description": { - "type": ["string", "null"] - } - } - }, - "Type": { - "description": "The type of values that a column, field, or argument may take.", - "oneOf": [ - { - "type": "object", - "required": ["scalarType"], - "properties": { - "scalarType": { - "$ref": "#/definitions/ScalarTypeName" - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["compositeType"], - "properties": { - "compositeType": { - "$ref": "#/definitions/CompositeTypeName" - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["arrayType"], - "properties": { - "arrayType": { - "$ref": "#/definitions/Type" - } - }, - "additionalProperties": false - } - ] - }, - "ScalarTypeName": { - "description": "A name of a Scalar Type, as it appears in the NDC scheme.", - "type": "string" - }, - "CompositeTypeName": { - "description": "The name of a Composite Type, as it appears in the NDC schema", - "type": "string" - }, - "Nullable": { - "description": "Can this column contain null values", - "type": "string", - "enum": ["nullable", "nonNullable"] - }, - "HasDefault": { - "description": "Does this column have a default value.", - "type": "string", - "enum": ["noDefault", "hasDefault"] - }, - "IsIdentity": { - "description": "Is this column an identity column.", - "type": "string", - "enum": ["notIdentity", "identityByDefault", "identityAlways"] - }, - "IsGenerated": { - "description": "Is this column a generated column.", - "type": "string", - "enum": ["notGenerated", "stored"] - }, - "UniquenessConstraints": { - "description": "A mapping from the name of a unique constraint to its value.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/UniquenessConstraint" - } - }, - "UniquenessConstraint": { - "description": "The set of columns that make up a uniqueness constraint.", - "type": "array", - "items": { - "type": "string" - }, - "uniqueItems": true - }, - "ForeignRelations": { - "description": "A mapping from the name of a foreign key constraint to its value.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ForeignRelation" - } - }, - "ForeignRelation": { - "description": "A foreign key constraint.", - "type": "object", - "required": ["columnMapping", "foreignTable"], - "properties": { - "foreignSchema": { - "type": ["string", "null"] - }, - "foreignTable": { - "type": "string" - }, - "columnMapping": { - "type": "object", - "additionalProperties": { - "type": "string" - } - } - } - }, - "ScalarTypes": { - "description": "Map of all known/occurring scalar types.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ScalarType" - } - }, - "ScalarType": { - "description": "Information about a scalar type. A scalar type is completely characterized by its name and the operations you can do on it.", - "type": "object", - "required": [ - "aggregateFunctions", - "comparisonOperators", - "schemaName", - "typeName" - ], - "properties": { - "typeName": { - "type": "string" - }, - "schemaName": { - "type": "string" - }, - "description": { - "type": ["string", "null"] - }, - "aggregateFunctions": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/AggregateFunction" - } - }, - "comparisonOperators": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ComparisonOperator" - } - }, - "typeRepresentation": { - "anyOf": [ - { - "$ref": "#/definitions/TypeRepresentation" - }, - { - "type": "null" - } - ] - } - } - }, - "AggregateFunction": { - "type": "object", - "required": ["returnType"], - "properties": { - "returnType": { - "$ref": "#/definitions/ScalarTypeName" - } - } - }, - "ComparisonOperator": { - "description": "Represents a postgres binary comparison operator", - "type": "object", - "required": ["argumentType", "operatorKind", "operatorName"], - "properties": { - "operatorName": { - "type": "string" - }, - "operatorKind": { - "$ref": "#/definitions/OperatorKind" - }, - "argumentType": { - "$ref": "#/definitions/ScalarTypeName" - }, - "isInfix": { - "default": true, - "type": "boolean" - } - } - }, - "OperatorKind": { - "description": "Is it a built-in operator, or a custom operator.", - "type": "string", - "enum": ["equal", "in", "custom"] - }, - "TypeRepresentation": { - "description": "Type representation of a scalar type.", - "oneOf": [ - { - "description": "JSON booleans", - "type": "string", - "enum": ["boolean"] - }, - { - "description": "Any JSON string", - "type": "string", - "enum": ["string"] - }, - { - "description": "float4", - "type": "string", - "enum": ["float32"] - }, - { - "description": "float8", - "type": "string", - "enum": ["float64"] - }, - { - "description": "int2", - "type": "string", - "enum": ["int16"] - }, - { - "description": "int4", - "type": "string", - "enum": ["int32"] - }, - { - "description": "int8 as integer", - "type": "string", - "enum": ["int64"] - }, - { - "description": "int8 as string", - "type": "string", - "enum": ["int64AsString"] - }, - { - "description": "numeric", - "type": "string", - "enum": ["bigDecimal"] - }, - { - "description": "numeric as string", - "type": "string", - "enum": ["bigDecimalAsString"] - }, - { - "description": "timestamp", - "type": "string", - "enum": ["timestamp"] - }, - { - "description": "timestamp with timezone", - "type": "string", - "enum": ["timestamptz"] - }, - { - "description": "time", - "type": "string", - "enum": ["time"] - }, - { - "description": "time with timezone", - "type": "string", - "enum": ["timetz"] - }, - { - "description": "date", - "type": "string", - "enum": ["date"] - }, - { - "description": "uuid", - "type": "string", - "enum": ["uUID"] - }, - { - "description": "geography", - "type": "string", - "enum": ["geography"] - }, - { - "description": "geometry", - "type": "string", - "enum": ["geometry"] - }, - { - "description": "Any JSON number", - "type": "string", - "enum": ["number"] - }, - { - "description": "Any JSON number, with no decimal part", - "type": "string", - "enum": ["integer"] - }, - { - "description": "An arbitrary json.", - "type": "string", - "enum": ["json"] - }, - { - "description": "One of the specified string values", - "type": "object", - "required": ["enum"], - "properties": { - "enum": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "additionalProperties": false - } - ] - }, - "CompositeTypes": { - "description": "Map of all known composite types.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/CompositeType" - } - }, - "CompositeType": { - "description": "Information about a composite type. These are very similar to tables, but with the crucial difference that composite types do not support constraints (such as NOT NULL).", - "type": "object", - "required": ["fields", "schemaName", "typeName"], - "properties": { - "typeName": { - "type": "string" - }, - "schemaName": { - "type": "string" - }, - "fields": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/FieldInfo" - } - }, - "description": { - "type": ["string", "null"] - } - } - }, - "FieldInfo": { - "description": "Information about a composite type field.", - "type": "object", - "required": ["fieldName", "type"], - "properties": { - "fieldName": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "description": { - "type": ["string", "null"] - } - } - }, - "NativeQueries": { - "description": "Metadata information of native queries.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/NativeQueryInfo" - } - }, - "NativeQueryInfo": { - "description": "Information about a Native Query", - "type": "object", - "required": ["columns", "sql"], - "properties": { - "sql": { - "description": "SQL expression to use for the Native Query. We can interpolate values using `{{variable_name}}` syntax, such as `SELECT * FROM authors WHERE name = {{author_name}}`", - "allOf": [ - { - "$ref": "#/definitions/NativeQuerySql" - } - ] - }, - "columns": { - "description": "Columns returned by the Native Query", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ReadOnlyColumnInfo" - } - }, - "arguments": { - "description": "Names and types of arguments that can be passed to this Native Query", - "default": {}, - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ReadOnlyColumnInfo" - } - }, - "description": { - "type": ["string", "null"] - }, - "isProcedure": { - "description": "True if this native query mutates the database", - "type": "boolean" - } - } - }, - "NativeQuerySql": { - "description": "Native Query SQL location.", - "anyOf": [ - { - "description": "Refer to an external Native Query SQL file.", - "type": "object", - "required": ["file"], - "properties": { - "file": { - "description": "Relative path to a sql file.", - "type": "string" - } - } - }, - { - "description": "Inline Native Query SQL string.", - "type": "object", - "required": ["inline"], - "properties": { - "inline": { - "description": "An inline Native Query SQL string.", - "allOf": [ - { - "$ref": "#/definitions/InlineNativeQuerySql" - } - ] - } - } - }, - { - "$ref": "#/definitions/InlineNativeQuerySql" - } - ] - }, - "InlineNativeQuerySql": { - "type": "string" - }, - "ReadOnlyColumnInfo": { - "description": "Information about a native query column.", - "type": "object", - "required": ["name", "type"], - "properties": { - "name": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "nullable": { - "default": "nullable", - "allOf": [ - { - "$ref": "#/definitions/Nullable" - } - ] - }, - "description": { - "type": ["string", "null"] - } - } - }, - "IntrospectionOptions": { - "description": "Options which only influence how the configuration is updated.", - "type": "object", - "properties": { - "excludedSchemas": { - "description": "Schemas which are excluded from introspection. The default setting will exclude the internal schemas of Postgres, Citus, Cockroach, and the PostGIS extension.", - "default": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "type": "array", - "items": { - "type": "string" - } - }, - "unqualifiedSchemasForTables": { - "description": "The names of Tables and Views in these schemas will be returned unqualified. The default setting will set the `public` schema as unqualified.", - "default": ["public"], - "type": "array", - "items": { - "type": "string" - } - }, - "unqualifiedSchemasForTypesAndProcedures": { - "description": "The types and procedures in these schemas will be returned unqualified.", - "default": ["public", "pg_catalog", "tiger"], - "type": "array", - "items": { - "type": "string" - } - }, - "comparisonOperatorMapping": { - "description": "The mapping of comparison operator names to apply when updating the configuration", - "default": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "type": "array", - "items": { - "$ref": "#/definitions/ComparisonOperatorMapping" - } - }, - "introspectPrefixFunctionComparisonOperators": { - "description": "Which prefix functions (i.e., non-infix operators) to generate introspection metadata for.\n\nThis list will accept any boolean-returning function taking two concrete scalar types as arguments.\n\nThe default includes comparisons for various build-in types as well as those of PostGIS.", - "default": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "type": "array", - "items": { - "type": "string" - } - }, - "typeRepresentations": { - "description": "The type representations to pick for base scalar types.", - "default": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - }, - "allOf": [ - { - "$ref": "#/definitions/TypeRepresentations" - } - ] - } - } - }, - "ComparisonOperatorMapping": { - "description": "Define the names that comparison operators will be exposed as by the automatic introspection.", - "type": "object", - "required": ["exposedName", "operatorKind", "operatorName"], - "properties": { - "operatorName": { - "description": "The name of the operator as defined by the database", - "type": "string" - }, - "exposedName": { - "description": "The name the operator will appear under in the exposed API", - "type": "string" - }, - "operatorKind": { - "description": "Equal, In or Custom.", - "allOf": [ - { - "$ref": "#/definitions/OperatorKind" - } - ] - } - } - }, - "TypeRepresentations": { - "description": "The type representations that guide introspection.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/TypeRepresentation" - } - }, - "MutationsVersion": { - "description": "Which version of the generated mutations will be included in the schema", - "type": "string", - "enum": ["v1"] - } - } -} diff --git a/static/postgres/broken-queries-ndc-metadata/schema.json b/static/postgres/broken-queries-ndc-metadata/schema.json deleted file mode 100644 index 787e63813..000000000 --- a/static/postgres/broken-queries-ndc-metadata/schema.json +++ /dev/null @@ -1,1387 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "ParsedConfiguration", - "description": "Initial configuration, just enough to connect to a database and elaborate a full 'Configuration'.", - "type": "object", - "required": ["version"], - "properties": { - "version": { - "$ref": "#/definitions/Version" - }, - "$schema": { - "description": "Jsonschema of the configuration format.", - "type": ["string", "null"] - }, - "connectionSettings": { - "description": "Database connection settings.", - "default": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "allOf": [ - { - "$ref": "#/definitions/DatabaseConnectionSettings" - } - ] - }, - "metadata": { - "description": "Connector metadata.", - "default": { - "tables": {}, - "scalarTypes": {}, - "compositeTypes": {}, - "nativeQueries": {} - }, - "allOf": [ - { - "$ref": "#/definitions/Metadata" - } - ] - }, - "introspectionOptions": { - "description": "Database introspection options.", - "default": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "allOf": [ - { - "$ref": "#/definitions/IntrospectionOptions" - } - ] - }, - "mutationsVersion": { - "description": "Which version of the generated mutation procedures to include in the schema response", - "anyOf": [ - { - "$ref": "#/definitions/MutationsVersion" - }, - { - "type": "null" - } - ] - } - }, - "definitions": { - "Version": { - "type": "string", - "enum": ["4"] - }, - "DatabaseConnectionSettings": { - "description": "Database connection settings.", - "type": "object", - "required": ["connectionUri"], - "properties": { - "connectionUri": { - "description": "Connection string for a Postgres-compatible database.", - "allOf": [ - { - "$ref": "#/definitions/ConnectionUri" - } - ] - }, - "poolSettings": { - "description": "Connection pool settings.", - "default": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "allOf": [ - { - "$ref": "#/definitions/PoolSettings" - } - ] - }, - "isolationLevel": { - "description": "Query isolation level.", - "default": "ReadCommitted", - "allOf": [ - { - "$ref": "#/definitions/IsolationLevel" - } - ] - } - } - }, - "ConnectionUri": { - "$ref": "#/definitions/Secret" - }, - "Secret": { - "anyOf": [ - { - "type": "string" - }, - { - "type": "object", - "required": ["variable"], - "properties": { - "variable": { - "$ref": "#/definitions/Variable" - } - } - } - ] - }, - "Variable": { - "description": "The name of an an environment variable.", - "type": "string" - }, - "PoolSettings": { - "description": "Settings for the PostgreSQL connection pool", - "type": "object", - "properties": { - "maxConnections": { - "description": "maximum number of pool connections", - "default": 50, - "type": "integer", - "format": "uint32", - "minimum": 0.0 - }, - "poolTimeout": { - "description": "timeout for acquiring a connection from the pool (seconds)", - "default": 30, - "type": "integer", - "format": "uint64", - "minimum": 0.0 - }, - "idleTimeout": { - "description": "idle timeout for releasing a connection from the pool (seconds)", - "default": 180, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - }, - "checkConnectionAfterIdle": { - "description": "check the connection is alive after being idle for N seconds. Set to null to always check.", - "default": 60, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - }, - "connectionLifetime": { - "description": "maximum lifetime for an individual connection (seconds)", - "default": 600, - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - } - } - }, - "IsolationLevel": { - "description": "The isolation level of the transaction in which a query is executed.", - "oneOf": [ - { - "description": "Prevents reading data from another uncommitted transaction.", - "type": "string", - "enum": ["ReadCommitted"] - }, - { - "description": "Reading the same data twice is guaranteed to return the same result.", - "type": "string", - "enum": ["RepeatableRead"] - }, - { - "description": "Concurrent transactions behave identically to serializing them one at a time.", - "type": "string", - "enum": ["Serializable"] - } - ] - }, - "Metadata": { - "description": "Metadata information.", - "type": "object", - "properties": { - "tables": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/TablesInfo" - } - ] - }, - "scalarTypes": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/ScalarTypes" - } - ] - }, - "compositeTypes": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/CompositeTypes" - } - ] - }, - "nativeQueries": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/NativeQueries" - } - ] - } - } - }, - "TablesInfo": { - "description": "Mapping from a \"table\" name to its information.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/TableInfo" - } - }, - "TableInfo": { - "description": "Information about a database table (or any other kind of relation).", - "type": "object", - "required": ["columns", "schemaName", "tableName"], - "properties": { - "schemaName": { - "type": "string" - }, - "tableName": { - "type": "string" - }, - "columns": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ColumnInfo" - } - }, - "uniquenessConstraints": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/UniquenessConstraints" - } - ] - }, - "foreignRelations": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/ForeignRelations" - } - ] - }, - "description": { - "type": ["string", "null"] - } - } - }, - "ColumnInfo": { - "description": "Information about a database column.", - "type": "object", - "required": ["name", "type"], - "properties": { - "name": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "nullable": { - "default": "nullable", - "allOf": [ - { - "$ref": "#/definitions/Nullable" - } - ] - }, - "hasDefault": { - "$ref": "#/definitions/HasDefault" - }, - "isIdentity": { - "$ref": "#/definitions/IsIdentity" - }, - "isGenerated": { - "$ref": "#/definitions/IsGenerated" - }, - "description": { - "type": ["string", "null"] - } - } - }, - "Type": { - "description": "The type of values that a column, field, or argument may take.", - "oneOf": [ - { - "type": "object", - "required": ["scalarType"], - "properties": { - "scalarType": { - "$ref": "#/definitions/ScalarTypeName" - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["compositeType"], - "properties": { - "compositeType": { - "$ref": "#/definitions/CompositeTypeName" - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["arrayType"], - "properties": { - "arrayType": { - "$ref": "#/definitions/Type" - } - }, - "additionalProperties": false - } - ] - }, - "ScalarTypeName": { - "description": "A name of a Scalar Type, as it appears in the NDC scheme.", - "type": "string" - }, - "CompositeTypeName": { - "description": "The name of a Composite Type, as it appears in the NDC schema", - "type": "string" - }, - "Nullable": { - "description": "Can this column contain null values", - "type": "string", - "enum": ["nullable", "nonNullable"] - }, - "HasDefault": { - "description": "Does this column have a default value.", - "type": "string", - "enum": ["noDefault", "hasDefault"] - }, - "IsIdentity": { - "description": "Is this column an identity column.", - "type": "string", - "enum": ["notIdentity", "identityByDefault", "identityAlways"] - }, - "IsGenerated": { - "description": "Is this column a generated column.", - "type": "string", - "enum": ["notGenerated", "stored"] - }, - "UniquenessConstraints": { - "description": "A mapping from the name of a unique constraint to its value.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/UniquenessConstraint" - } - }, - "UniquenessConstraint": { - "description": "The set of columns that make up a uniqueness constraint.", - "type": "array", - "items": { - "type": "string" - }, - "uniqueItems": true - }, - "ForeignRelations": { - "description": "A mapping from the name of a foreign key constraint to its value.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ForeignRelation" - } - }, - "ForeignRelation": { - "description": "A foreign key constraint.", - "type": "object", - "required": ["columnMapping", "foreignTable"], - "properties": { - "foreignSchema": { - "type": ["string", "null"] - }, - "foreignTable": { - "type": "string" - }, - "columnMapping": { - "type": "object", - "additionalProperties": { - "type": "string" - } - } - } - }, - "ScalarTypes": { - "description": "Map of all known/occurring scalar types.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ScalarType" - } - }, - "ScalarType": { - "description": "Information about a scalar type. A scalar type is completely characterized by its name and the operations you can do on it.", - "type": "object", - "required": [ - "aggregateFunctions", - "comparisonOperators", - "schemaName", - "typeName" - ], - "properties": { - "typeName": { - "type": "string" - }, - "schemaName": { - "type": "string" - }, - "description": { - "type": ["string", "null"] - }, - "aggregateFunctions": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/AggregateFunction" - } - }, - "comparisonOperators": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ComparisonOperator" - } - }, - "typeRepresentation": { - "anyOf": [ - { - "$ref": "#/definitions/TypeRepresentation" - }, - { - "type": "null" - } - ] - } - } - }, - "AggregateFunction": { - "type": "object", - "required": ["returnType"], - "properties": { - "returnType": { - "$ref": "#/definitions/ScalarTypeName" - } - } - }, - "ComparisonOperator": { - "description": "Represents a postgres binary comparison operator", - "type": "object", - "required": ["argumentType", "operatorKind", "operatorName"], - "properties": { - "operatorName": { - "type": "string" - }, - "operatorKind": { - "$ref": "#/definitions/OperatorKind" - }, - "argumentType": { - "$ref": "#/definitions/ScalarTypeName" - }, - "isInfix": { - "default": true, - "type": "boolean" - } - } - }, - "OperatorKind": { - "description": "Is it a built-in operator, or a custom operator.", - "type": "string", - "enum": ["equal", "in", "custom"] - }, - "TypeRepresentation": { - "description": "Type representation of a scalar type.", - "oneOf": [ - { - "description": "JSON booleans", - "type": "string", - "enum": ["boolean"] - }, - { - "description": "Any JSON string", - "type": "string", - "enum": ["string"] - }, - { - "description": "float4", - "type": "string", - "enum": ["float32"] - }, - { - "description": "float8", - "type": "string", - "enum": ["float64"] - }, - { - "description": "int2", - "type": "string", - "enum": ["int16"] - }, - { - "description": "int4", - "type": "string", - "enum": ["int32"] - }, - { - "description": "int8 as integer", - "type": "string", - "enum": ["int64"] - }, - { - "description": "int8 as string", - "type": "string", - "enum": ["int64AsString"] - }, - { - "description": "numeric", - "type": "string", - "enum": ["bigDecimal"] - }, - { - "description": "numeric as string", - "type": "string", - "enum": ["bigDecimalAsString"] - }, - { - "description": "timestamp", - "type": "string", - "enum": ["timestamp"] - }, - { - "description": "timestamp with timezone", - "type": "string", - "enum": ["timestamptz"] - }, - { - "description": "time", - "type": "string", - "enum": ["time"] - }, - { - "description": "time with timezone", - "type": "string", - "enum": ["timetz"] - }, - { - "description": "date", - "type": "string", - "enum": ["date"] - }, - { - "description": "uuid", - "type": "string", - "enum": ["uUID"] - }, - { - "description": "geography", - "type": "string", - "enum": ["geography"] - }, - { - "description": "geometry", - "type": "string", - "enum": ["geometry"] - }, - { - "description": "Any JSON number", - "type": "string", - "enum": ["number"] - }, - { - "description": "Any JSON number, with no decimal part", - "type": "string", - "enum": ["integer"] - }, - { - "description": "An arbitrary json.", - "type": "string", - "enum": ["json"] - }, - { - "description": "One of the specified string values", - "type": "object", - "required": ["enum"], - "properties": { - "enum": { - "type": "array", - "items": { - "type": "string" - } - } - }, - "additionalProperties": false - } - ] - }, - "CompositeTypes": { - "description": "Map of all known composite types.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/CompositeType" - } - }, - "CompositeType": { - "description": "Information about a composite type. These are very similar to tables, but with the crucial difference that composite types do not support constraints (such as NOT NULL).", - "type": "object", - "required": ["fields", "schemaName", "typeName"], - "properties": { - "typeName": { - "type": "string" - }, - "schemaName": { - "type": "string" - }, - "fields": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/FieldInfo" - } - }, - "description": { - "type": ["string", "null"] - } - } - }, - "FieldInfo": { - "description": "Information about a composite type field.", - "type": "object", - "required": ["fieldName", "type"], - "properties": { - "fieldName": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "description": { - "type": ["string", "null"] - } - } - }, - "NativeQueries": { - "description": "Metadata information of native queries.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/NativeQueryInfo" - } - }, - "NativeQueryInfo": { - "description": "Information about a Native Query", - "type": "object", - "required": ["columns", "sql"], - "properties": { - "sql": { - "description": "SQL expression to use for the Native Query. We can interpolate values using `{{variable_name}}` syntax, such as `SELECT * FROM authors WHERE name = {{author_name}}`", - "allOf": [ - { - "$ref": "#/definitions/NativeQuerySql" - } - ] - }, - "columns": { - "description": "Columns returned by the Native Query", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ReadOnlyColumnInfo" - } - }, - "arguments": { - "description": "Names and types of arguments that can be passed to this Native Query", - "default": {}, - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ReadOnlyColumnInfo" - } - }, - "description": { - "type": ["string", "null"] - }, - "isProcedure": { - "description": "True if this native query mutates the database", - "type": "boolean" - } - } - }, - "NativeQuerySql": { - "description": "Native Query SQL location.", - "anyOf": [ - { - "description": "Refer to an external Native Query SQL file.", - "type": "object", - "required": ["file"], - "properties": { - "file": { - "description": "Relative path to a sql file.", - "type": "string" - } - } - }, - { - "description": "Inline Native Query SQL string.", - "type": "object", - "required": ["inline"], - "properties": { - "inline": { - "description": "An inline Native Query SQL string.", - "allOf": [ - { - "$ref": "#/definitions/InlineNativeQuerySql" - } - ] - } - } - }, - { - "$ref": "#/definitions/InlineNativeQuerySql" - } - ] - }, - "InlineNativeQuerySql": { - "type": "string" - }, - "ReadOnlyColumnInfo": { - "description": "Information about a native query column.", - "type": "object", - "required": ["name", "type"], - "properties": { - "name": { - "type": "string" - }, - "type": { - "$ref": "#/definitions/Type" - }, - "nullable": { - "default": "nullable", - "allOf": [ - { - "$ref": "#/definitions/Nullable" - } - ] - }, - "description": { - "type": ["string", "null"] - } - } - }, - "IntrospectionOptions": { - "description": "Options which only influence how the configuration is updated.", - "type": "object", - "properties": { - "excludedSchemas": { - "description": "Schemas which are excluded from introspection. The default setting will exclude the internal schemas of Postgres, Citus, Cockroach, and the PostGIS extension.", - "default": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "type": "array", - "items": { - "type": "string" - } - }, - "unqualifiedSchemasForTables": { - "description": "The names of Tables and Views in these schemas will be returned unqualified. The default setting will set the `public` schema as unqualified.", - "default": ["public"], - "type": "array", - "items": { - "type": "string" - } - }, - "unqualifiedSchemasForTypesAndProcedures": { - "description": "The types and procedures in these schemas will be returned unqualified.", - "default": ["public", "pg_catalog", "tiger"], - "type": "array", - "items": { - "type": "string" - } - }, - "comparisonOperatorMapping": { - "description": "The mapping of comparison operator names to apply when updating the configuration", - "default": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "type": "array", - "items": { - "$ref": "#/definitions/ComparisonOperatorMapping" - } - }, - "introspectPrefixFunctionComparisonOperators": { - "description": "Which prefix functions (i.e., non-infix operators) to generate introspection metadata for.\n\nThis list will accept any boolean-returning function taking two concrete scalar types as arguments.\n\nThe default includes comparisons for various build-in types as well as those of PostGIS.", - "default": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "type": "array", - "items": { - "type": "string" - } - }, - "typeRepresentations": { - "description": "The type representations to pick for base scalar types.", - "default": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - }, - "allOf": [ - { - "$ref": "#/definitions/TypeRepresentations" - } - ] - } - } - }, - "ComparisonOperatorMapping": { - "description": "Define the names that comparison operators will be exposed as by the automatic introspection.", - "type": "object", - "required": ["exposedName", "operatorKind", "operatorName"], - "properties": { - "operatorName": { - "description": "The name of the operator as defined by the database", - "type": "string" - }, - "exposedName": { - "description": "The name the operator will appear under in the exposed API", - "type": "string" - }, - "operatorKind": { - "description": "Equal, In or Custom.", - "allOf": [ - { - "$ref": "#/definitions/OperatorKind" - } - ] - } - } - }, - "TypeRepresentations": { - "description": "The type representations that guide introspection.", - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/TypeRepresentation" - } - }, - "MutationsVersion": { - "description": "Which version of the generated mutations will be included in the schema", - "type": "string", - "enum": ["v1", "v2"] - } - } -} diff --git a/static/postgres/v3-chinook-ndc-metadata/configuration.json b/static/postgres/v3-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 36b3feb90..000000000 --- a/static/postgres/v3-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,4054 +0,0 @@ -{ - "version": "3", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "connectionLifetime": 600, - "checkConnectionAfterIdle": 60 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "custom_dog": { - "schemaName": "custom", - "tableName": "dog", - "columns": { - "adopter_name": { - "name": "adopter_name", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "birthday": { - "name": "birthday", - "type": { - "scalarType": "date" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "height_cm": { - "name": "height_cm", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - }, - "height_in": { - "name": "height_in", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "hasDefault": "hasDefault", - "isGenerated": "stored", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "isIdentity": "identityAlways", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "dog_pkey": ["id"] - }, - "foreignRelations": {}, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "spatial_ref_sys": { - "schemaName": "public", - "tableName": "spatial_ref_sys", - "columns": { - "auth_name": { - "name": "auth_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "auth_srid": { - "name": "auth_srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "proj4text": { - "name": "proj4text", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "srtext": { - "name": "srtext", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "spatial_ref_sys_pkey": ["srid"] - }, - "foreignRelations": {}, - "description": null - }, - "topology_layer": { - "schemaName": "topology", - "tableName": "layer", - "columns": { - "child_id": { - "name": "child_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "feature_column": { - "name": "feature_column", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "feature_type": { - "name": "feature_type", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "layer_id": { - "name": "layer_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "level": { - "name": "level", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "schema_name": { - "name": "schema_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "table_name": { - "name": "table_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "topology_id": { - "name": "topology_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "layer_pkey": ["layer_id", "topology_id"], - "layer_schema_name_table_name_feature_column_key": [ - "feature_column", - "schema_name", - "table_name" - ] - }, - "foreignRelations": { - "layer_topology_id_fkey": { - "foreignSchema": "topology", - "foreignTable": "topology", - "columnMapping": { - "topology_id": "id" - } - } - }, - "description": null - }, - "topology_topology": { - "schemaName": "topology", - "tableName": "topology", - "columns": { - "hasz": { - "name": "hasz", - "type": { - "scalarType": "bool" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "precision": { - "name": "precision", - "type": { - "scalarType": "float8" - }, - "nullable": "nonNullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "topology_name_key": ["name"], - "topology_pkey": ["id"] - }, - "foreignRelations": {}, - "description": null - } - }, - "compositeTypes": { - "chara": { - "name": "chara", - "fields": { - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "name": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "name": "characters", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "name": "committee", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "name": "discoverable_types", - "fields": { - "only_occurring_here1": { - "name": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "name": "organization", - "fields": { - "committees": { - "name": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "name": "person", - "fields": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "name": "person_address", - "fields": { - "address_line_1": { - "name": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "name": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "name": "person_name", - "fields": { - "first_name": { - "name": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "name": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "file": "./native_queries/summarize_organizations.sql" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - }, - "aggregateFunctions": { - "Phone": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "bit": { - "bit_and": { - "returnType": "bit" - }, - "bit_or": { - "returnType": "bit" - }, - "bit_xor": { - "returnType": "bit" - } - }, - "bool": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "bpchar": { - "max": { - "returnType": "bpchar" - }, - "min": { - "returnType": "bpchar" - } - }, - "card_suit": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "char": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "date": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "even_number": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "float4": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "float8": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "int2": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int4": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int8": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "interval": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "numeric": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "text": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "time": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "timestamp": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "timestamptz": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "timetz": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "varchar": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - } - }, - "comparisonOperators": { - "Phone": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "bit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - } - }, - "bool": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "bpchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bpchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bpchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - } - }, - "card_suit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "char": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "date": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "even_number": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "float4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "float8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "int2": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "int4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "int8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "interval": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "numeric": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "text": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "time": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "timestamp": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "timestamptz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "timetz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "uuid": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "varchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - } - }, - "typeRepresentations": { - "Phone": "string", - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "card_suit": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - }, - "char": "string", - "date": "date", - "even_number": "int32", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ] - }, - "mutationsVersion": "v1" -} diff --git a/static/postgres/v4-chinook-ndc-metadata/configuration.json b/static/postgres/v4-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 1e4f98063..000000000 --- a/static/postgres/v4-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,4043 +0,0 @@ -{ - "version": "4", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "custom_defaults": { - "schemaName": "custom", - "tableName": "defaults", - "columns": { - "birthday": { - "name": "birthday", - "type": { - "scalarType": "date" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "height_cm": { - "name": "height_cm", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "height_in": { - "name": "height_in", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "hasDefault": "hasDefault", - "isGenerated": "stored", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "isIdentity": "identityAlways", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "defaults_pkey": ["id"] - }, - "foreignRelations": {}, - "description": null - }, - "custom_dog": { - "schemaName": "custom", - "tableName": "dog", - "columns": { - "adopter_name": { - "name": "adopter_name", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "birthday": { - "name": "birthday", - "type": { - "scalarType": "date" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "height_cm": { - "name": "height_cm", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - }, - "height_in": { - "name": "height_in", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "hasDefault": "hasDefault", - "isGenerated": "stored", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int8" - }, - "nullable": "nonNullable", - "isIdentity": "identityAlways", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "dog_pkey": ["id"] - }, - "foreignRelations": {}, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "spatial_ref_sys": { - "schemaName": "public", - "tableName": "spatial_ref_sys", - "columns": { - "auth_name": { - "name": "auth_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "auth_srid": { - "name": "auth_srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "proj4text": { - "name": "proj4text", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "srtext": { - "name": "srtext", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "spatial_ref_sys_pkey": ["srid"] - }, - "foreignRelations": {}, - "description": null - }, - "topology_layer": { - "schemaName": "topology", - "tableName": "layer", - "columns": { - "child_id": { - "name": "child_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "feature_column": { - "name": "feature_column", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "feature_type": { - "name": "feature_type", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "layer_id": { - "name": "layer_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "level": { - "name": "level", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "schema_name": { - "name": "schema_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "table_name": { - "name": "table_name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "topology_id": { - "name": "topology_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "layer_pkey": ["layer_id", "topology_id"], - "layer_schema_name_table_name_feature_column_key": [ - "feature_column", - "schema_name", - "table_name" - ] - }, - "foreignRelations": { - "layer_topology_id_fkey": { - "foreignSchema": "topology", - "foreignTable": "topology", - "columnMapping": { - "topology_id": "id" - } - } - }, - "description": null - }, - "topology_topology": { - "schemaName": "topology", - "tableName": "topology", - "columns": { - "hasz": { - "name": "hasz", - "type": { - "scalarType": "bool" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "hasDefault": "hasDefault", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "precision": { - "name": "precision", - "type": { - "scalarType": "float8" - }, - "nullable": "nonNullable", - "description": null - }, - "srid": { - "name": "srid", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "topology_name_key": ["name"], - "topology_pkey": ["id"] - }, - "foreignRelations": {}, - "description": null - } - }, - "scalarTypes": { - "Phone": { - "typeName": "Phone", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "bool": { - "typeName": "bool", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "typeRepresentation": "boolean" - }, - "card_suit": { - "typeName": "card_suit", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "typeRepresentation": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - } - }, - "char": { - "typeName": "char", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "date": { - "typeName": "date", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "typeRepresentation": "date" - }, - "even_number": { - "typeName": "even_number", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "float4": { - "typeName": "float4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "typeRepresentation": "float32" - }, - "float8": { - "typeName": "float8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "typeRepresentation": "float64" - }, - "int2": { - "typeName": "int2", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "bit_xor": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "typeRepresentation": "int16" - }, - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "bit_xor": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "int8": { - "typeName": "int8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "bit_xor": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "typeRepresentation": "int64AsString" - }, - "interval": { - "typeName": "interval", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "typeRepresentation": null - }, - "numeric": { - "typeName": "numeric", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "typeRepresentation": "bigDecimalAsString" - }, - "text": { - "typeName": "text", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "time": { - "typeName": "time", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "typeRepresentation": "time" - }, - "timestamp": { - "typeName": "timestamp", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "typeRepresentation": "timestamp" - }, - "timestamptz": { - "typeName": "timestamptz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "typeRepresentation": "timestamptz" - }, - "timetz": { - "typeName": "timetz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "typeRepresentation": "timetz" - }, - "uuid": { - "typeName": "uuid", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "typeRepresentation": "uUID" - }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "st_coveredby": { - "operatorName": "st_coveredby", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_covers": { - "operatorName": "st_covers", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_intersects": { - "operatorName": "st_intersects", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "st_relatematch": { - "operatorName": "st_relatematch", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - }, - "typeRepresentation": "string" - } - }, - "compositeTypes": { - "chara": { - "typeName": "chara", - "schemaName": "public", - "fields": { - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "fieldName": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "typeName": "characters", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "typeName": "committee", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "typeName": "discoverable_types", - "schemaName": "public", - "fields": { - "only_occurring_here1": { - "fieldName": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "typeName": "organization", - "schemaName": "public", - "fields": { - "committees": { - "fieldName": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "typeName": "person", - "schemaName": "public", - "fields": { - "address": { - "fieldName": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "typeName": "person_address", - "schemaName": "public", - "fields": { - "address_line_1": { - "fieldName": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "fieldName": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "typeName": "person_name", - "schemaName": "public", - "fields": { - "first_name": { - "fieldName": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "fieldName": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "file": "./native_queries/summarize_organizations.sql" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "mutationsVersion": "v2" -} diff --git a/static/postgres/v5-configuration/configuration.json b/static/postgres/v5-configuration/configuration.json new file mode 100644 index 000000000..546f3d529 --- /dev/null +++ b/static/postgres/v5-configuration/configuration.json @@ -0,0 +1,4046 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": ["ArtistId"] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "custom_defaults": { + "schemaName": "custom", + "tableName": "defaults", + "columns": { + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "defaults_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + }, + "custom_dog": { + "schemaName": "custom", + "tableName": "dog", + "columns": { + "adopter_name": { + "name": "adopter_name", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "birthday": { + "name": "birthday", + "type": { + "scalarType": "date" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "height_cm": { + "name": "height_cm", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + }, + "height_in": { + "name": "height_in", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "hasDefault": "hasDefault", + "isGenerated": "stored", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int8" + }, + "nullable": "nonNullable", + "isIdentity": "identityAlways", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "text" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "dog_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "even_numbers": { + "schemaName": "public", + "tableName": "even_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "even_number" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "group_leader": { + "schemaName": "public", + "tableName": "group_leader", + "columns": { + "characters": { + "name": "characters", + "type": { + "compositeType": "characters" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "chara" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "phone_numbers": { + "schemaName": "public", + "tableName": "phone_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "Phone" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "spatial_ref_sys": { + "schemaName": "public", + "tableName": "spatial_ref_sys", + "columns": { + "auth_name": { + "name": "auth_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "auth_srid": { + "name": "auth_srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "proj4text": { + "name": "proj4text", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "srtext": { + "name": "srtext", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "spatial_ref_sys_pkey": ["srid"] + }, + "foreignRelations": {}, + "description": null + }, + "topology_layer": { + "schemaName": "topology", + "tableName": "layer", + "columns": { + "child_id": { + "name": "child_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "feature_column": { + "name": "feature_column", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "feature_type": { + "name": "feature_type", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "layer_id": { + "name": "layer_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "level": { + "name": "level", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "schema_name": { + "name": "schema_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "table_name": { + "name": "table_name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "topology_id": { + "name": "topology_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "layer_pkey": ["layer_id", "topology_id"], + "layer_schema_name_table_name_feature_column_key": [ + "feature_column", + "schema_name", + "table_name" + ] + }, + "foreignRelations": { + "layer_topology_id_fkey": { + "foreignSchema": "topology", + "foreignTable": "topology", + "columnMapping": { + "topology_id": "id" + } + } + }, + "description": null + }, + "topology_topology": { + "schemaName": "topology", + "tableName": "topology", + "columns": { + "hasz": { + "name": "hasz", + "type": { + "scalarType": "bool" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "hasDefault": "hasDefault", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "precision": { + "name": "precision", + "type": { + "scalarType": "float8" + }, + "nullable": "nonNullable", + "description": null + }, + "srid": { + "name": "srid", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "topology_name_key": ["name"], + "topology_pkey": ["id"] + }, + "foreignRelations": {}, + "description": null + } + }, + "types": { + "scalar": { + "Phone": { + "typeName": "Phone", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "Phone", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "Phone", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": ["hearts", "clubs", "diamonds", "spades"] + } + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "even_number": { + "typeName": "even_number", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "even_number", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "even_number", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float4" + }, + "min": { + "returnType": "float4" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float4" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "bit_xor": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "bit_xor": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "bit_xor": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "interval" + }, + "min": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "time" + }, + "min": { + "returnType": "time" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamptz" + }, + "min": { + "returnType": "timestamptz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timetz" + }, + "min": { + "returnType": "timetz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "st_coveredby": { + "operatorName": "st_coveredby", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_covers": { + "operatorName": "st_covers", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_intersects": { + "operatorName": "st_intersects", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "st_relatematch": { + "operatorName": "st_relatematch", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "chara": { + "typeName": "chara", + "schemaName": "public", + "fields": { + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "popularity": { + "fieldName": "popularity", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "characters": { + "typeName": "characters", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "chara" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "committee": { + "typeName": "committee", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "person_name" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "discoverable_types": { + "typeName": "discoverable_types", + "schemaName": "public", + "fields": { + "only_occurring_here1": { + "fieldName": "only_occurring_here1", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "organization": { + "typeName": "organization", + "schemaName": "public", + "fields": { + "committees": { + "fieldName": "committees", + "type": { + "arrayType": { + "compositeType": "committee" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person": { + "typeName": "person", + "schemaName": "public", + "fields": { + "address": { + "fieldName": "address", + "type": { + "compositeType": "person_address" + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "compositeType": "person_name" + }, + "description": null + } + }, + "description": null + }, + "person_address": { + "typeName": "person_address", + "schemaName": "public", + "fields": { + "address_line_1": { + "fieldName": "address_line_1", + "type": { + "scalarType": "text" + }, + "description": "Address line No 1" + }, + "address_line_2": { + "fieldName": "address_line_2", + "type": { + "scalarType": "text" + }, + "description": "Address line No 2" + } + }, + "description": "The address of a person, obviously" + }, + "person_name": { + "typeName": "person_name", + "schemaName": "public", + "fields": { + "first_name": { + "fieldName": "first_name", + "type": { + "scalarType": "text" + }, + "description": "The first name of a person" + }, + "last_name": { + "fieldName": "last_name", + "type": { + "scalarType": "text" + }, + "description": "The last name of a person" + } + }, + "description": "The name of a person, obviously" + } + } + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "make_person": { + "sql": { + "inline": "SELECT ROW({{name}}, {{address}})::person as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "person_name" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "organization_identity_function": { + "sql": { + "inline": "SELECT {{organization}} as result_the_column" + }, + "columns": { + "result_the_field": { + "name": "result_the_column", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organization": { + "name": "organization", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "summarize_organizations": { + "sql": { + "file": "./native_queries/summarize_organizations.sql" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organizations": { + "name": "organizations", + "type": { + "arrayType": { + "compositeType": "organization" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": "v2" +} diff --git a/static/postgres/v4-chinook-ndc-metadata/native_queries/summarize_organizations.sql b/static/postgres/v5-configuration/native_queries/summarize_organizations.sql similarity index 100% rename from static/postgres/v4-chinook-ndc-metadata/native_queries/summarize_organizations.sql rename to static/postgres/v5-configuration/native_queries/summarize_organizations.sql diff --git a/static/schema.json b/static/schema.json index e30671d16..5267cd982 100644 --- a/static/schema.json +++ b/static/schema.json @@ -38,9 +38,14 @@ "description": "Connector metadata.", "default": { "tables": {}, - "scalarTypes": {}, - "compositeTypes": {}, - "nativeQueries": {} + "types": { + "scalar": {}, + "composite": {} + }, + "nativeOperations": { + "queries": {}, + "mutations": {} + } }, "allOf": [ { @@ -338,7 +343,7 @@ "definitions": { "Version": { "type": "string", - "enum": ["4"] + "enum": ["5"] }, "DatabaseConnectionSettings": { "description": "Database connection settings.", @@ -475,27 +480,25 @@ } ] }, - "scalarTypes": { - "default": {}, - "allOf": [ - { - "$ref": "#/definitions/ScalarTypes" - } - ] - }, - "compositeTypes": { - "default": {}, + "types": { + "default": { + "scalar": {}, + "composite": {} + }, "allOf": [ { - "$ref": "#/definitions/CompositeTypes" + "$ref": "#/definitions/Types" } ] }, - "nativeQueries": { - "default": {}, + "nativeOperations": { + "default": { + "queries": {}, + "mutations": {} + }, "allOf": [ { - "$ref": "#/definitions/NativeQueries" + "$ref": "#/definitions/NativeOperations" } ] } @@ -685,6 +688,19 @@ } } }, + "Types": { + "description": "Information about types.", + "type": "object", + "required": ["composite", "scalar"], + "properties": { + "scalar": { + "$ref": "#/definitions/ScalarTypes" + }, + "composite": { + "$ref": "#/definitions/CompositeTypes" + } + } + }, "ScalarTypes": { "description": "Map of all known/occurring scalar types.", "type": "object", @@ -940,20 +956,43 @@ } } }, + "NativeOperations": { + "description": "Metadata information of Native Operations.", + "type": "object", + "required": ["mutations", "queries"], + "properties": { + "queries": { + "description": "Native Queries.", + "allOf": [ + { + "$ref": "#/definitions/NativeQueries" + } + ] + }, + "mutations": { + "description": "Native Mutations.", + "allOf": [ + { + "$ref": "#/definitions/NativeQueries" + } + ] + } + } + }, "NativeQueries": { - "description": "Metadata information of native queries.", + "description": "Metadata information of Native Operations.", "type": "object", "additionalProperties": { "$ref": "#/definitions/NativeQueryInfo" } }, "NativeQueryInfo": { - "description": "Information about a Native Query", + "description": "Information about a Native Operation", "type": "object", "required": ["columns", "sql"], "properties": { "sql": { - "description": "SQL expression to use for the Native Query. We can interpolate values using `{{variable_name}}` syntax, such as `SELECT * FROM authors WHERE name = {{author_name}}`", + "description": "SQL expression to use for the Native Operation. We can interpolate values using `{{variable_name}}` syntax, such as `SELECT * FROM authors WHERE name = {{author_name}}`", "allOf": [ { "$ref": "#/definitions/NativeQuerySql" @@ -961,14 +1000,14 @@ ] }, "columns": { - "description": "Columns returned by the Native Query", + "description": "Columns returned by the Native Operation", "type": "object", "additionalProperties": { "$ref": "#/definitions/ReadOnlyColumnInfo" } }, "arguments": { - "description": "Names and types of arguments that can be passed to this Native Query", + "description": "Names and types of arguments that can be passed to this Native Operation", "default": {}, "type": "object", "additionalProperties": { @@ -978,18 +1017,14 @@ "description": { "default": null, "type": ["string", "null"] - }, - "isProcedure": { - "description": "True if this native query mutates the database", - "type": "boolean" } } }, "NativeQuerySql": { - "description": "Native Query SQL location.", + "description": "Native Operation SQL location.", "anyOf": [ { - "description": "Refer to an external Native Query SQL file.", + "description": "Refer to an external Native Operation SQL file.", "type": "object", "required": ["file"], "properties": { @@ -1000,12 +1035,12 @@ } }, { - "description": "Inline Native Query SQL string.", + "description": "Inline Native Operation SQL string.", "type": "object", "required": ["inline"], "properties": { "inline": { - "description": "An inline Native Query SQL string.", + "description": "An inline Native Operation SQL string.", "allOf": [ { "$ref": "#/definitions/InlineNativeQuerySql" diff --git a/static/yugabyte/v3-chinook-ndc-metadata/configuration.json b/static/yugabyte/v3-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 83d51e4bf..000000000 --- a/static/yugabyte/v3-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3636 +0,0 @@ -{ - "version": "3", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "connectionLifetime": 600, - "checkConnectionAfterIdle": 60 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - } - }, - "compositeTypes": { - "chara": { - "name": "chara", - "fields": { - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "name": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "name": "characters", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "name": "committee", - "fields": { - "members": { - "name": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "name": "discoverable_types", - "fields": { - "only_occurring_here1": { - "name": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "name": "organization", - "fields": { - "committees": { - "name": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "name": "person", - "fields": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "name": "person_address", - "fields": { - "address_line_1": { - "name": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "name": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "name": "person_name", - "fields": { - "first_name": { - "name": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "name": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": "SELECT {{address}} as result", - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)", - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr", - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": "SELECT * FROM public.\"Artist\"", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}", - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": "SELECT array_length({{array_argument}}, 1) as result", - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": "SELECT ROW({{name}}, {{address}})::person as result", - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true", - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid", - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - }, - "aggregateFunctions": { - "Phone": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "bit": { - "bit_and": { - "returnType": "bit" - }, - "bit_or": { - "returnType": "bit" - } - }, - "bool": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "bpchar": { - "max": { - "returnType": "bpchar" - }, - "min": { - "returnType": "bpchar" - } - }, - "card_suit": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "char": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "date": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "even_number": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "float4": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "float8": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "int2": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int4": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "int8": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "interval": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "numeric": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "text": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "time": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "timestamp": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "timestamptz": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "timetz": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "varchar": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - } - }, - "comparisonOperators": { - "Phone": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "bit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bit", - "isInfix": true - } - }, - "bool": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "bpchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bpchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bpchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "bpchar", - "isInfix": false - } - }, - "card_suit": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "char": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "date": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "even_number": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "float4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "float8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "int2": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "int4": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "int8": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "interval": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "numeric": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "text": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "time": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "timestamp": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "timestamptz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "timetz": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "uuid": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "varchar": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - } - }, - "typeRepresentations": { - "Phone": "string", - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "card_suit": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - }, - "char": "string", - "date": "date", - "even_number": "int32", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64", - "numeric": "bigDecimal", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ] - }, - "mutationsVersion": "v1" -} diff --git a/static/yugabyte/v4-chinook-ndc-metadata/configuration.json b/static/yugabyte/v4-chinook-ndc-metadata/configuration.json deleted file mode 100644 index 9f3a78e9f..000000000 --- a/static/yugabyte/v4-chinook-ndc-metadata/configuration.json +++ /dev/null @@ -1,3622 +0,0 @@ -{ - "version": "4", - "$schema": "../../schema.json", - "connectionSettings": { - "connectionUri": { - "variable": "CONNECTION_URI" - }, - "poolSettings": { - "maxConnections": 50, - "poolTimeout": 30, - "idleTimeout": 180, - "checkConnectionAfterIdle": 60, - "connectionLifetime": 600 - }, - "isolationLevel": "ReadCommitted" - }, - "metadata": { - "tables": { - "Album": { - "schemaName": "public", - "tableName": "Album", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an album" - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The id of the artist that authored the album" - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The title of an album" - } - }, - "uniquenessConstraints": { - "PK_Album": ["AlbumId"] - }, - "foreignRelations": { - "FK_AlbumArtistId": { - "foreignSchema": "public", - "foreignTable": "Artist", - "columnMapping": { - "ArtistId": "ArtistId" - } - } - }, - "description": "The record of all albums" - }, - "Artist": { - "schemaName": "public", - "tableName": "Artist", - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of an artist" - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": "The name of an artist" - } - }, - "uniquenessConstraints": { - "PK_Artist": ["ArtistId"] - }, - "foreignRelations": {}, - "description": "The record of all artists" - }, - "Customer": { - "schemaName": "public", - "tableName": "Customer", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Company": { - "name": "Company", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": "The identifier of customer" - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The first name of a customer" - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": "The last name of a customer" - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "SupportRepId": { - "name": "SupportRepId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Customer": ["CustomerId"] - }, - "foreignRelations": { - "FK_CustomerSupportRepId": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "SupportRepId": "EmployeeId" - } - } - }, - "description": "The record of all customers" - }, - "Employee": { - "schemaName": "public", - "tableName": "Employee", - "columns": { - "Address": { - "name": "Address", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BirthDate": { - "name": "BirthDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "City": { - "name": "City", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Country": { - "name": "Country", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Email": { - "name": "Email", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "EmployeeId": { - "name": "EmployeeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Fax": { - "name": "Fax", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "FirstName": { - "name": "FirstName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "HireDate": { - "name": "HireDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "LastName": { - "name": "LastName", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "Phone": { - "name": "Phone", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PostalCode": { - "name": "PostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "ReportsTo": { - "name": "ReportsTo", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "State": { - "name": "State", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Employee": ["EmployeeId"] - }, - "foreignRelations": { - "FK_EmployeeReportsTo": { - "foreignSchema": "public", - "foreignTable": "Employee", - "columnMapping": { - "ReportsTo": "EmployeeId" - } - } - }, - "description": null - }, - "Genre": { - "schemaName": "public", - "tableName": "Genre", - "columns": { - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Genre": ["GenreId"] - }, - "foreignRelations": {}, - "description": null - }, - "Invoice": { - "schemaName": "public", - "tableName": "Invoice", - "columns": { - "BillingAddress": { - "name": "BillingAddress", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCity": { - "name": "BillingCity", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingCountry": { - "name": "BillingCountry", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingPostalCode": { - "name": "BillingPostalCode", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "BillingState": { - "name": "BillingState", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "CustomerId": { - "name": "CustomerId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceDate": { - "name": "InvoiceDate", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Total": { - "name": "Total", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Invoice": ["InvoiceId"] - }, - "foreignRelations": { - "FK_InvoiceCustomerId": { - "foreignSchema": "public", - "foreignTable": "Customer", - "columnMapping": { - "CustomerId": "CustomerId" - } - } - }, - "description": null - }, - "InvoiceLine": { - "schemaName": "public", - "tableName": "InvoiceLine", - "columns": { - "InvoiceId": { - "name": "InvoiceId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "InvoiceLineId": { - "name": "InvoiceLineId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Quantity": { - "name": "Quantity", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_InvoiceLine": ["InvoiceLineId"] - }, - "foreignRelations": { - "FK_InvoiceLineInvoiceId": { - "foreignSchema": "public", - "foreignTable": "Invoice", - "columnMapping": { - "InvoiceId": "InvoiceId" - } - }, - "FK_InvoiceLineTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "MediaType": { - "schemaName": "public", - "tableName": "MediaType", - "columns": { - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_MediaType": ["MediaTypeId"] - }, - "foreignRelations": {}, - "description": null - }, - "Playlist": { - "schemaName": "public", - "tableName": "Playlist", - "columns": { - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Playlist": ["PlaylistId"] - }, - "foreignRelations": {}, - "description": null - }, - "PlaylistTrack": { - "schemaName": "public", - "tableName": "PlaylistTrack", - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_PlaylistTrack": ["PlaylistId", "TrackId"] - }, - "foreignRelations": { - "FK_PlaylistTrackPlaylistId": { - "foreignSchema": "public", - "foreignTable": "Playlist", - "columnMapping": { - "PlaylistId": "PlaylistId" - } - }, - "FK_PlaylistTrackTrackId": { - "foreignSchema": "public", - "foreignTable": "Track", - "columnMapping": { - "TrackId": "TrackId" - } - } - }, - "description": null - }, - "Track": { - "schemaName": "public", - "tableName": "Track", - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Bytes": { - "name": "Bytes", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Composer": { - "name": "Composer", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - }, - "GenreId": { - "name": "GenreId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "MediaTypeId": { - "name": "MediaTypeId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Milliseconds": { - "name": "Milliseconds", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nonNullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nonNullable", - "description": null - }, - "UnitPrice": { - "name": "UnitPrice", - "type": { - "scalarType": "numeric" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": { - "PK_Track": ["TrackId"] - }, - "foreignRelations": { - "FK_TrackAlbumId": { - "foreignSchema": "public", - "foreignTable": "Album", - "columnMapping": { - "AlbumId": "AlbumId" - } - }, - "FK_TrackGenreId": { - "foreignSchema": "public", - "foreignTable": "Genre", - "columnMapping": { - "GenreId": "GenreId" - } - }, - "FK_TrackMediaTypeId": { - "foreignSchema": "public", - "foreignTable": "MediaType", - "columnMapping": { - "MediaTypeId": "MediaTypeId" - } - } - }, - "description": null - }, - "deck_of_cards": { - "schemaName": "public", - "tableName": "deck_of_cards", - "columns": { - "pips": { - "name": "pips", - "type": { - "scalarType": "int2" - }, - "nullable": "nonNullable", - "description": null - }, - "suit": { - "name": "suit", - "type": { - "scalarType": "card_suit" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "discoverable_types_root_occurrence": { - "schemaName": "public", - "tableName": "discoverable_types_root_occurrence", - "columns": { - "col": { - "name": "col", - "type": { - "compositeType": "discoverable_types" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "even_numbers": { - "schemaName": "public", - "tableName": "even_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "even_number" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "group_leader": { - "schemaName": "public", - "tableName": "group_leader", - "columns": { - "characters": { - "name": "characters", - "type": { - "compositeType": "characters" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "chara" - }, - "nullable": "nullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - }, - "phone_numbers": { - "schemaName": "public", - "tableName": "phone_numbers", - "columns": { - "the_number": { - "name": "the_number", - "type": { - "scalarType": "Phone" - }, - "nullable": "nonNullable", - "description": null - } - }, - "uniquenessConstraints": {}, - "foreignRelations": {}, - "description": null - } - }, - "scalarTypes": { - "Phone": { - "typeName": "Phone", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "Phone", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "Phone", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "Phone", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "bool": { - "typeName": "bool", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "bool_and": { - "returnType": "bool" - }, - "bool_or": { - "returnType": "bool" - }, - "every": { - "returnType": "bool" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "bool", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "bool", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "bool", - "isInfix": true - } - }, - "typeRepresentation": "boolean" - }, - "card_suit": { - "typeName": "card_suit", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "card_suit" - }, - "min": { - "returnType": "card_suit" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "card_suit", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "card_suit", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - }, - "_neq": { - "operatorName": "!=", - "operatorKind": "custom", - "argumentType": "card_suit", - "isInfix": true - } - }, - "typeRepresentation": { - "enum": ["hearts", "clubs", "diamonds", "spades"] - } - }, - "char": { - "typeName": "char", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "char", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "char", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "char", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "date": { - "typeName": "date", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "date" - }, - "min": { - "returnType": "date" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "date", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "date", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "date", - "isInfix": true - } - }, - "typeRepresentation": "date" - }, - "even_number": { - "typeName": "even_number", - "schemaName": "public", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "even_number", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "even_number", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "even_number", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "float4": { - "typeName": "float4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float4" - }, - "min": { - "returnType": "float4" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float4" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float4", - "isInfix": true - } - }, - "typeRepresentation": "float32" - }, - "float8": { - "typeName": "float8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "float8" - }, - "max": { - "returnType": "float8" - }, - "min": { - "returnType": "float8" - }, - "stddev": { - "returnType": "float8" - }, - "stddev_pop": { - "returnType": "float8" - }, - "stddev_samp": { - "returnType": "float8" - }, - "sum": { - "returnType": "float8" - }, - "var_pop": { - "returnType": "float8" - }, - "var_samp": { - "returnType": "float8" - }, - "variance": { - "returnType": "float8" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "float8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "float8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "float8", - "isInfix": true - } - }, - "typeRepresentation": "float64" - }, - "int2": { - "typeName": "int2", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int2" - }, - "bit_or": { - "returnType": "int2" - }, - "max": { - "returnType": "int2" - }, - "min": { - "returnType": "int2" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int2", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int2", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int2", - "isInfix": true - } - }, - "typeRepresentation": "int16" - }, - "int4": { - "typeName": "int4", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int4" - }, - "bit_or": { - "returnType": "int4" - }, - "max": { - "returnType": "int4" - }, - "min": { - "returnType": "int4" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "int8" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int4", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int4", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int4", - "isInfix": true - } - }, - "typeRepresentation": "int32" - }, - "int8": { - "typeName": "int8", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "bit_and": { - "returnType": "int8" - }, - "bit_or": { - "returnType": "int8" - }, - "max": { - "returnType": "int8" - }, - "min": { - "returnType": "int8" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "int8", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "int8", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "int8", - "isInfix": true - } - }, - "typeRepresentation": "int64AsString" - }, - "interval": { - "typeName": "interval", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "interval" - }, - "min": { - "returnType": "interval" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "interval", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "interval", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "interval", - "isInfix": true - } - }, - "typeRepresentation": null - }, - "numeric": { - "typeName": "numeric", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "numeric" - }, - "max": { - "returnType": "numeric" - }, - "min": { - "returnType": "numeric" - }, - "stddev": { - "returnType": "numeric" - }, - "stddev_pop": { - "returnType": "numeric" - }, - "stddev_samp": { - "returnType": "numeric" - }, - "sum": { - "returnType": "numeric" - }, - "var_pop": { - "returnType": "numeric" - }, - "var_samp": { - "returnType": "numeric" - }, - "variance": { - "returnType": "numeric" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "numeric", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "numeric", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "numeric", - "isInfix": true - } - }, - "typeRepresentation": "bigDecimalAsString" - }, - "text": { - "typeName": "text", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "text", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "text", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "text", - "isInfix": false - } - }, - "typeRepresentation": "string" - }, - "time": { - "typeName": "time", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "avg": { - "returnType": "interval" - }, - "max": { - "returnType": "time" - }, - "min": { - "returnType": "time" - }, - "sum": { - "returnType": "interval" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "time", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "time", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "time", - "isInfix": true - } - }, - "typeRepresentation": "time" - }, - "timestamp": { - "typeName": "timestamp", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamp" - }, - "min": { - "returnType": "timestamp" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamp", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamp", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamp", - "isInfix": true - } - }, - "typeRepresentation": "timestamp" - }, - "timestamptz": { - "typeName": "timestamptz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timestamptz" - }, - "min": { - "returnType": "timestamptz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timestamptz", - "isInfix": true - } - }, - "typeRepresentation": "timestamptz" - }, - "timetz": { - "typeName": "timetz", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "timetz" - }, - "min": { - "returnType": "timetz" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "timetz", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "timetz", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "timetz", - "isInfix": true - } - }, - "typeRepresentation": "timetz" - }, - "uuid": { - "typeName": "uuid", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": {}, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "uuid", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "uuid", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "uuid", - "isInfix": true - } - }, - "typeRepresentation": "uUID" - }, - "varchar": { - "typeName": "varchar", - "schemaName": "pg_catalog", - "description": null, - "aggregateFunctions": { - "max": { - "returnType": "text" - }, - "min": { - "returnType": "text" - } - }, - "comparisonOperators": { - "_eq": { - "operatorName": "=", - "operatorKind": "equal", - "argumentType": "varchar", - "isInfix": true - }, - "_gt": { - "operatorName": ">", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_gte": { - "operatorName": ">=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_ilike": { - "operatorName": "~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_in": { - "operatorName": "IN", - "operatorKind": "in", - "argumentType": "varchar", - "isInfix": true - }, - "_iregex": { - "operatorName": "~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_like": { - "operatorName": "~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lt": { - "operatorName": "<", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_lte": { - "operatorName": "<=", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_neq": { - "operatorName": "<>", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nilike": { - "operatorName": "!~~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_niregex": { - "operatorName": "!~*", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nlike": { - "operatorName": "!~~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_nregex": { - "operatorName": "!~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "_regex": { - "operatorName": "~", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": true - }, - "starts_with": { - "operatorName": "starts_with", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - }, - "ts_match_tt": { - "operatorName": "ts_match_tt", - "operatorKind": "custom", - "argumentType": "varchar", - "isInfix": false - } - }, - "typeRepresentation": "string" - } - }, - "compositeTypes": { - "chara": { - "typeName": "chara", - "schemaName": "public", - "fields": { - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - }, - "popularity": { - "fieldName": "popularity", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "characters": { - "typeName": "characters", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "chara" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "committee": { - "typeName": "committee", - "schemaName": "public", - "fields": { - "members": { - "fieldName": "members", - "type": { - "arrayType": { - "compositeType": "person_name" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "discoverable_types": { - "typeName": "discoverable_types", - "schemaName": "public", - "fields": { - "only_occurring_here1": { - "fieldName": "only_occurring_here1", - "type": { - "scalarType": "int8" - }, - "description": null - } - }, - "description": null - }, - "organization": { - "typeName": "organization", - "schemaName": "public", - "fields": { - "committees": { - "fieldName": "committees", - "type": { - "arrayType": { - "compositeType": "committee" - } - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "scalarType": "text" - }, - "description": null - } - }, - "description": null - }, - "person": { - "typeName": "person", - "schemaName": "public", - "fields": { - "address": { - "fieldName": "address", - "type": { - "compositeType": "person_address" - }, - "description": null - }, - "name": { - "fieldName": "name", - "type": { - "compositeType": "person_name" - }, - "description": null - } - }, - "description": null - }, - "person_address": { - "typeName": "person_address", - "schemaName": "public", - "fields": { - "address_line_1": { - "fieldName": "address_line_1", - "type": { - "scalarType": "text" - }, - "description": "Address line No 1" - }, - "address_line_2": { - "fieldName": "address_line_2", - "type": { - "scalarType": "text" - }, - "description": "Address line No 2" - } - }, - "description": "The address of a person, obviously" - }, - "person_name": { - "typeName": "person_name", - "schemaName": "public", - "fields": { - "first_name": { - "fieldName": "first_name", - "type": { - "scalarType": "text" - }, - "description": "The first name of a person" - }, - "last_name": { - "fieldName": "last_name", - "type": { - "scalarType": "text" - }, - "description": "The last name of a person" - } - }, - "description": "The name of a person, obviously" - } - }, - "nativeQueries": { - "address_identity_function": { - "sql": { - "inline": "SELECT {{address}} as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "album_by_title": { - "sql": { - "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "array_reverse": { - "sql": { - "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" - }, - "columns": { - "reversed": { - "name": "reversed", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nullable", - "description": "The reversed array" - } - }, - "arguments": { - "array": { - "name": "array", - "type": { - "arrayType": { - "scalarType": "varchar" - } - }, - "nullable": "nonNullable", - "description": "The array to reverse. This is necessarily of a monomorphic type." - } - }, - "description": "A native query used to test support for arrays as inputs" - }, - "array_series": { - "sql": { - "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" - }, - "columns": { - "series": { - "name": "series", - "type": { - "arrayType": { - "scalarType": "int4" - } - }, - "nullable": "nullable", - "description": null - }, - "three": { - "name": "three", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "from": { - "name": "from", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "to": { - "name": "to", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for arrays" - }, - "artist": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\"" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": {}, - "description": null - }, - "artist_below_id": { - "sql": { - "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" - }, - "columns": { - "id": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - }, - "count_elements": { - "sql": { - "inline": "SELECT array_length({{array_argument}}, 1) as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "array_argument": { - "name": "array_argument", - "type": { - "arrayType": { - "scalarType": "text" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "delete_playlist_track": { - "sql": { - "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" - }, - "columns": { - "PlaylistId": { - "name": "PlaylistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "TrackId": { - "name": "TrackId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "track_id": { - "name": "track_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_album": { - "sql": { - "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" - }, - "columns": { - "AlbumId": { - "name": "AlbumId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Title": { - "name": "Title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "artist_id": { - "name": "artist_id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "title": { - "name": "title", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "insert_artist": { - "sql": { - "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" - }, - "columns": { - "ArtistId": { - "name": "ArtistId", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "Name": { - "name": "Name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "id": { - "name": "id", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null, - "isProcedure": true - }, - "make_person": { - "sql": { - "inline": "SELECT ROW({{name}}, {{address}})::person as result" - }, - "columns": { - "result": { - "name": "result", - "type": { - "compositeType": "person" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "address": { - "name": "address", - "type": { - "compositeType": "person_address" - }, - "nullable": "nullable", - "description": null - }, - "name": { - "name": "name", - "type": { - "compositeType": "person_name" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "organization_identity_function": { - "sql": { - "inline": "SELECT {{organization}} as result_the_column" - }, - "columns": { - "result_the_field": { - "name": "result_the_column", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organization": { - "name": "organization", - "type": { - "compositeType": "organization" - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support for composite types" - }, - "summarize_organizations": { - "sql": { - "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" - }, - "columns": { - "result": { - "name": "result", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "organizations": { - "name": "organizations", - "type": { - "arrayType": { - "compositeType": "organization" - } - }, - "nullable": "nullable", - "description": null - } - }, - "description": "A native query used to test support array-valued variables" - }, - "value_types": { - "sql": { - "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" - }, - "columns": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "arguments": { - "bool": { - "name": "bool", - "type": { - "scalarType": "bool" - }, - "nullable": "nullable", - "description": null - }, - "char": { - "name": "char", - "type": { - "scalarType": "char" - }, - "nullable": "nullable", - "description": null - }, - "date": { - "name": "date", - "type": { - "scalarType": "date" - }, - "nullable": "nullable", - "description": null - }, - "float4": { - "name": "float4", - "type": { - "scalarType": "float4" - }, - "nullable": "nullable", - "description": null - }, - "float8": { - "name": "float8", - "type": { - "scalarType": "float8" - }, - "nullable": "nullable", - "description": null - }, - "int2": { - "name": "int2", - "type": { - "scalarType": "int2" - }, - "nullable": "nullable", - "description": null - }, - "int4": { - "name": "int4", - "type": { - "scalarType": "int4" - }, - "nullable": "nullable", - "description": null - }, - "int8": { - "name": "int8", - "type": { - "scalarType": "int8" - }, - "nullable": "nullable", - "description": null - }, - "numeric": { - "name": "numeric", - "type": { - "scalarType": "numeric" - }, - "nullable": "nullable", - "description": null - }, - "text": { - "name": "text", - "type": { - "scalarType": "text" - }, - "nullable": "nullable", - "description": null - }, - "time": { - "name": "time", - "type": { - "scalarType": "time" - }, - "nullable": "nullable", - "description": null - }, - "timestamp": { - "name": "timestamp", - "type": { - "scalarType": "timestamp" - }, - "nullable": "nullable", - "description": null - }, - "timestamptz": { - "name": "timestamptz", - "type": { - "scalarType": "timestamptz" - }, - "nullable": "nullable", - "description": null - }, - "timetz": { - "name": "timetz", - "type": { - "scalarType": "timetz" - }, - "nullable": "nullable", - "description": null - }, - "uuid": { - "name": "uuid", - "type": { - "scalarType": "uuid" - }, - "nullable": "nullable", - "description": null - }, - "varchar": { - "name": "varchar", - "type": { - "scalarType": "varchar" - }, - "nullable": "nullable", - "description": null - } - }, - "description": null - } - } - }, - "introspectionOptions": { - "excludedSchemas": [ - "information_schema", - "pg_catalog", - "tiger", - "crdb_internal", - "columnar", - "columnar_internal" - ], - "unqualifiedSchemasForTables": ["public"], - "unqualifiedSchemasForTypesAndProcedures": [ - "public", - "pg_catalog", - "tiger" - ], - "comparisonOperatorMapping": [ - { - "operatorName": "=", - "exposedName": "_eq", - "operatorKind": "equal" - }, - { - "operatorName": "<=", - "exposedName": "_lte", - "operatorKind": "custom" - }, - { - "operatorName": ">", - "exposedName": "_gt", - "operatorKind": "custom" - }, - { - "operatorName": ">=", - "exposedName": "_gte", - "operatorKind": "custom" - }, - { - "operatorName": "<", - "exposedName": "_lt", - "operatorKind": "custom" - }, - { - "operatorName": "!=", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "LIKE", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "NOT LIKE", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "ILIKE", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "NOT ILIKE", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "SIMILAR TO", - "exposedName": "_similar", - "operatorKind": "custom" - }, - { - "operatorName": "NOT SIMILAR TO", - "exposedName": "_nsimilar", - "operatorKind": "custom" - }, - { - "operatorName": "<>", - "exposedName": "_neq", - "operatorKind": "custom" - }, - { - "operatorName": "~~", - "exposedName": "_like", - "operatorKind": "custom" - }, - { - "operatorName": "!~~", - "exposedName": "_nlike", - "operatorKind": "custom" - }, - { - "operatorName": "~~*", - "exposedName": "_ilike", - "operatorKind": "custom" - }, - { - "operatorName": "!~~*", - "exposedName": "_nilike", - "operatorKind": "custom" - }, - { - "operatorName": "~", - "exposedName": "_regex", - "operatorKind": "custom" - }, - { - "operatorName": "!~", - "exposedName": "_nregex", - "operatorKind": "custom" - }, - { - "operatorName": "~*", - "exposedName": "_iregex", - "operatorKind": "custom" - }, - { - "operatorName": "!~*", - "exposedName": "_niregex", - "operatorKind": "custom" - } - ], - "introspectPrefixFunctionComparisonOperators": [ - "box_above", - "box_below", - "box_contain", - "box_contain_pt", - "box_contained", - "box_left", - "box_overabove", - "box_overbelow", - "box_overlap", - "box_overleft", - "box_overright", - "box_right", - "box_same", - "circle_above", - "circle_below", - "circle_contain", - "circle_contain_pt", - "circle_contained", - "circle_left", - "circle_overabove", - "circle_overbelow", - "circle_overlap", - "circle_overleft", - "circle_overright", - "circle_right", - "circle_same", - "contains_2d", - "equals", - "geography_overlaps", - "geometry_above", - "geometry_below", - "geometry_contained_3d", - "geometry_contains", - "geometry_contains_3d", - "geometry_contains_nd", - "geometry_left", - "geometry_overabove", - "geometry_overbelow", - "geometry_overlaps", - "geometry_overlaps_3d", - "geometry_overlaps_nd", - "geometry_overleft", - "geometry_overright", - "geometry_right", - "geometry_same", - "geometry_same_3d", - "geometry_same_nd", - "geometry_within", - "geometry_within_nd", - "inet_same_family", - "inter_lb", - "inter_sb", - "inter_sl", - "is_contained_2d", - "ishorizontal", - "isparallel", - "isperp", - "isvertical", - "jsonb_contained", - "jsonb_contains", - "jsonb_exists", - "jsonb_path_exists_opr", - "jsonb_path_match_opr", - "line_intersect", - "line_parallel", - "line_perp", - "lseg_intersect", - "lseg_parallel", - "lseg_perp", - "network_overlap", - "network_sub", - "network_sup", - "on_pb", - "on_pl", - "on_ppath", - "on_ps", - "on_sb", - "on_sl", - "overlaps_2d", - "path_contain_pt", - "path_inter", - "point_above", - "point_below", - "point_horiz", - "point_left", - "point_right", - "point_vert", - "poly_above", - "poly_below", - "poly_contain", - "poly_contain_pt", - "poly_contained", - "poly_left", - "poly_overabove", - "poly_overbelow", - "poly_overlap", - "poly_overleft", - "poly_overright", - "poly_right", - "poly_same", - "pt_contained_poly", - "st_3dintersects", - "st_contains", - "st_containsproperly", - "st_coveredby", - "st_covers", - "st_crosses", - "st_disjoint", - "st_equals", - "st_intersects", - "st_isvalid", - "st_orderingequals", - "st_overlaps", - "st_relatematch", - "st_touches", - "st_within", - "starts_with", - "ts_match_qv", - "ts_match_tq", - "ts_match_tt", - "ts_match_vq", - "tsq_mcontained", - "tsq_mcontains", - "xmlexists", - "xmlvalidate", - "xpath_exists" - ], - "typeRepresentations": { - "bit": "string", - "bool": "boolean", - "bpchar": "string", - "char": "string", - "date": "date", - "float4": "float32", - "float8": "float64", - "int2": "int16", - "int4": "int32", - "int8": "int64AsString", - "numeric": "bigDecimalAsString", - "text": "string", - "time": "time", - "timestamp": "timestamp", - "timestamptz": "timestamptz", - "timetz": "timetz", - "uuid": "uUID", - "varchar": "string" - } - }, - "mutationsVersion": "v1" -} diff --git a/static/yugabyte/v5-configuration/configuration.json b/static/yugabyte/v5-configuration/configuration.json new file mode 100644 index 000000000..14afa7676 --- /dev/null +++ b/static/yugabyte/v5-configuration/configuration.json @@ -0,0 +1,3625 @@ +{ + "version": "5", + "$schema": "../../schema.json", + "connectionSettings": { + "connectionUri": { + "variable": "CONNECTION_URI" + }, + "poolSettings": { + "maxConnections": 50, + "poolTimeout": 30, + "idleTimeout": 180, + "checkConnectionAfterIdle": 60, + "connectionLifetime": 600 + }, + "isolationLevel": "ReadCommitted" + }, + "metadata": { + "tables": { + "Album": { + "schemaName": "public", + "tableName": "Album", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an album" + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The id of the artist that authored the album" + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The title of an album" + } + }, + "uniquenessConstraints": { + "PK_Album": ["AlbumId"] + }, + "foreignRelations": { + "FK_AlbumArtistId": { + "foreignSchema": "public", + "foreignTable": "Artist", + "columnMapping": { + "ArtistId": "ArtistId" + } + } + }, + "description": "The record of all albums" + }, + "Artist": { + "schemaName": "public", + "tableName": "Artist", + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of an artist" + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": "The name of an artist" + } + }, + "uniquenessConstraints": { + "PK_Artist": ["ArtistId"] + }, + "foreignRelations": {}, + "description": "The record of all artists" + }, + "Customer": { + "schemaName": "public", + "tableName": "Customer", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Company": { + "name": "Company", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": "The identifier of customer" + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The first name of a customer" + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": "The last name of a customer" + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "SupportRepId": { + "name": "SupportRepId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Customer": ["CustomerId"] + }, + "foreignRelations": { + "FK_CustomerSupportRepId": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "SupportRepId": "EmployeeId" + } + } + }, + "description": "The record of all customers" + }, + "Employee": { + "schemaName": "public", + "tableName": "Employee", + "columns": { + "Address": { + "name": "Address", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BirthDate": { + "name": "BirthDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "City": { + "name": "City", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Country": { + "name": "Country", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Email": { + "name": "Email", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "EmployeeId": { + "name": "EmployeeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Fax": { + "name": "Fax", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "FirstName": { + "name": "FirstName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "HireDate": { + "name": "HireDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "LastName": { + "name": "LastName", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "Phone": { + "name": "Phone", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PostalCode": { + "name": "PostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "ReportsTo": { + "name": "ReportsTo", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "State": { + "name": "State", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Employee": ["EmployeeId"] + }, + "foreignRelations": { + "FK_EmployeeReportsTo": { + "foreignSchema": "public", + "foreignTable": "Employee", + "columnMapping": { + "ReportsTo": "EmployeeId" + } + } + }, + "description": null + }, + "Genre": { + "schemaName": "public", + "tableName": "Genre", + "columns": { + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Genre": ["GenreId"] + }, + "foreignRelations": {}, + "description": null + }, + "Invoice": { + "schemaName": "public", + "tableName": "Invoice", + "columns": { + "BillingAddress": { + "name": "BillingAddress", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCity": { + "name": "BillingCity", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingCountry": { + "name": "BillingCountry", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingPostalCode": { + "name": "BillingPostalCode", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "BillingState": { + "name": "BillingState", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "CustomerId": { + "name": "CustomerId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceDate": { + "name": "InvoiceDate", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Total": { + "name": "Total", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Invoice": ["InvoiceId"] + }, + "foreignRelations": { + "FK_InvoiceCustomerId": { + "foreignSchema": "public", + "foreignTable": "Customer", + "columnMapping": { + "CustomerId": "CustomerId" + } + } + }, + "description": null + }, + "InvoiceLine": { + "schemaName": "public", + "tableName": "InvoiceLine", + "columns": { + "InvoiceId": { + "name": "InvoiceId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "InvoiceLineId": { + "name": "InvoiceLineId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Quantity": { + "name": "Quantity", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_InvoiceLine": ["InvoiceLineId"] + }, + "foreignRelations": { + "FK_InvoiceLineInvoiceId": { + "foreignSchema": "public", + "foreignTable": "Invoice", + "columnMapping": { + "InvoiceId": "InvoiceId" + } + }, + "FK_InvoiceLineTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "MediaType": { + "schemaName": "public", + "tableName": "MediaType", + "columns": { + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_MediaType": ["MediaTypeId"] + }, + "foreignRelations": {}, + "description": null + }, + "Playlist": { + "schemaName": "public", + "tableName": "Playlist", + "columns": { + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Playlist": ["PlaylistId"] + }, + "foreignRelations": {}, + "description": null + }, + "PlaylistTrack": { + "schemaName": "public", + "tableName": "PlaylistTrack", + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_PlaylistTrack": ["PlaylistId", "TrackId"] + }, + "foreignRelations": { + "FK_PlaylistTrackPlaylistId": { + "foreignSchema": "public", + "foreignTable": "Playlist", + "columnMapping": { + "PlaylistId": "PlaylistId" + } + }, + "FK_PlaylistTrackTrackId": { + "foreignSchema": "public", + "foreignTable": "Track", + "columnMapping": { + "TrackId": "TrackId" + } + } + }, + "description": null + }, + "Track": { + "schemaName": "public", + "tableName": "Track", + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Bytes": { + "name": "Bytes", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Composer": { + "name": "Composer", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + }, + "GenreId": { + "name": "GenreId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "MediaTypeId": { + "name": "MediaTypeId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Milliseconds": { + "name": "Milliseconds", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nonNullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nonNullable", + "description": null + }, + "UnitPrice": { + "name": "UnitPrice", + "type": { + "scalarType": "numeric" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": { + "PK_Track": ["TrackId"] + }, + "foreignRelations": { + "FK_TrackAlbumId": { + "foreignSchema": "public", + "foreignTable": "Album", + "columnMapping": { + "AlbumId": "AlbumId" + } + }, + "FK_TrackGenreId": { + "foreignSchema": "public", + "foreignTable": "Genre", + "columnMapping": { + "GenreId": "GenreId" + } + }, + "FK_TrackMediaTypeId": { + "foreignSchema": "public", + "foreignTable": "MediaType", + "columnMapping": { + "MediaTypeId": "MediaTypeId" + } + } + }, + "description": null + }, + "deck_of_cards": { + "schemaName": "public", + "tableName": "deck_of_cards", + "columns": { + "pips": { + "name": "pips", + "type": { + "scalarType": "int2" + }, + "nullable": "nonNullable", + "description": null + }, + "suit": { + "name": "suit", + "type": { + "scalarType": "card_suit" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "discoverable_types_root_occurrence": { + "schemaName": "public", + "tableName": "discoverable_types_root_occurrence", + "columns": { + "col": { + "name": "col", + "type": { + "compositeType": "discoverable_types" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "even_numbers": { + "schemaName": "public", + "tableName": "even_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "even_number" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "group_leader": { + "schemaName": "public", + "tableName": "group_leader", + "columns": { + "characters": { + "name": "characters", + "type": { + "compositeType": "characters" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "chara" + }, + "nullable": "nullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + }, + "phone_numbers": { + "schemaName": "public", + "tableName": "phone_numbers", + "columns": { + "the_number": { + "name": "the_number", + "type": { + "scalarType": "Phone" + }, + "nullable": "nonNullable", + "description": null + } + }, + "uniquenessConstraints": {}, + "foreignRelations": {}, + "description": null + } + }, + "types": { + "scalar": { + "Phone": { + "typeName": "Phone", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "Phone", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "Phone", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "Phone", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "bool": { + "typeName": "bool", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "bool_and": { + "returnType": "bool" + }, + "bool_or": { + "returnType": "bool" + }, + "every": { + "returnType": "bool" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "bool", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "bool", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "bool", + "isInfix": true + } + }, + "typeRepresentation": "boolean" + }, + "card_suit": { + "typeName": "card_suit", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "card_suit" + }, + "min": { + "returnType": "card_suit" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "card_suit", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "card_suit", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + }, + "_neq": { + "operatorName": "!=", + "operatorKind": "custom", + "argumentType": "card_suit", + "isInfix": true + } + }, + "typeRepresentation": { + "enum": ["hearts", "clubs", "diamonds", "spades"] + } + }, + "char": { + "typeName": "char", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "char", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "char", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "char", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "date": { + "typeName": "date", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "date" + }, + "min": { + "returnType": "date" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "date", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "date", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "date", + "isInfix": true + } + }, + "typeRepresentation": "date" + }, + "even_number": { + "typeName": "even_number", + "schemaName": "public", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "even_number", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "even_number", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "even_number", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "float4": { + "typeName": "float4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float4" + }, + "min": { + "returnType": "float4" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float4" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float4", + "isInfix": true + } + }, + "typeRepresentation": "float32" + }, + "float8": { + "typeName": "float8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "float8" + }, + "max": { + "returnType": "float8" + }, + "min": { + "returnType": "float8" + }, + "stddev": { + "returnType": "float8" + }, + "stddev_pop": { + "returnType": "float8" + }, + "stddev_samp": { + "returnType": "float8" + }, + "sum": { + "returnType": "float8" + }, + "var_pop": { + "returnType": "float8" + }, + "var_samp": { + "returnType": "float8" + }, + "variance": { + "returnType": "float8" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "float8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "float8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "float8", + "isInfix": true + } + }, + "typeRepresentation": "float64" + }, + "int2": { + "typeName": "int2", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int2" + }, + "bit_or": { + "returnType": "int2" + }, + "max": { + "returnType": "int2" + }, + "min": { + "returnType": "int2" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int2", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int2", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int2", + "isInfix": true + } + }, + "typeRepresentation": "int16" + }, + "int4": { + "typeName": "int4", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int4" + }, + "bit_or": { + "returnType": "int4" + }, + "max": { + "returnType": "int4" + }, + "min": { + "returnType": "int4" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "int8" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int4", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int4", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int4", + "isInfix": true + } + }, + "typeRepresentation": "int32" + }, + "int8": { + "typeName": "int8", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "bit_and": { + "returnType": "int8" + }, + "bit_or": { + "returnType": "int8" + }, + "max": { + "returnType": "int8" + }, + "min": { + "returnType": "int8" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "int8", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "int8", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "int8", + "isInfix": true + } + }, + "typeRepresentation": "int64AsString" + }, + "interval": { + "typeName": "interval", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "interval" + }, + "min": { + "returnType": "interval" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "interval", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "interval", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "interval", + "isInfix": true + } + }, + "typeRepresentation": null + }, + "numeric": { + "typeName": "numeric", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "numeric" + }, + "max": { + "returnType": "numeric" + }, + "min": { + "returnType": "numeric" + }, + "stddev": { + "returnType": "numeric" + }, + "stddev_pop": { + "returnType": "numeric" + }, + "stddev_samp": { + "returnType": "numeric" + }, + "sum": { + "returnType": "numeric" + }, + "var_pop": { + "returnType": "numeric" + }, + "var_samp": { + "returnType": "numeric" + }, + "variance": { + "returnType": "numeric" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "numeric", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "numeric", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "numeric", + "isInfix": true + } + }, + "typeRepresentation": "bigDecimalAsString" + }, + "text": { + "typeName": "text", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "text", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "text", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "text", + "isInfix": false + } + }, + "typeRepresentation": "string" + }, + "time": { + "typeName": "time", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "avg": { + "returnType": "interval" + }, + "max": { + "returnType": "time" + }, + "min": { + "returnType": "time" + }, + "sum": { + "returnType": "interval" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "time", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "time", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "time", + "isInfix": true + } + }, + "typeRepresentation": "time" + }, + "timestamp": { + "typeName": "timestamp", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamp" + }, + "min": { + "returnType": "timestamp" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamp", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamp", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamp", + "isInfix": true + } + }, + "typeRepresentation": "timestamp" + }, + "timestamptz": { + "typeName": "timestamptz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timestamptz" + }, + "min": { + "returnType": "timestamptz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timestamptz", + "isInfix": true + } + }, + "typeRepresentation": "timestamptz" + }, + "timetz": { + "typeName": "timetz", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "timetz" + }, + "min": { + "returnType": "timetz" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "timetz", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "timetz", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "timetz", + "isInfix": true + } + }, + "typeRepresentation": "timetz" + }, + "uuid": { + "typeName": "uuid", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": {}, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "uuid", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "uuid", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "uuid", + "isInfix": true + } + }, + "typeRepresentation": "uUID" + }, + "varchar": { + "typeName": "varchar", + "schemaName": "pg_catalog", + "description": null, + "aggregateFunctions": { + "max": { + "returnType": "text" + }, + "min": { + "returnType": "text" + } + }, + "comparisonOperators": { + "_eq": { + "operatorName": "=", + "operatorKind": "equal", + "argumentType": "varchar", + "isInfix": true + }, + "_gt": { + "operatorName": ">", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_gte": { + "operatorName": ">=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_ilike": { + "operatorName": "~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_in": { + "operatorName": "IN", + "operatorKind": "in", + "argumentType": "varchar", + "isInfix": true + }, + "_iregex": { + "operatorName": "~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_like": { + "operatorName": "~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lt": { + "operatorName": "<", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_lte": { + "operatorName": "<=", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_neq": { + "operatorName": "<>", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nilike": { + "operatorName": "!~~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_niregex": { + "operatorName": "!~*", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nlike": { + "operatorName": "!~~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_nregex": { + "operatorName": "!~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "_regex": { + "operatorName": "~", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": true + }, + "starts_with": { + "operatorName": "starts_with", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + }, + "ts_match_tt": { + "operatorName": "ts_match_tt", + "operatorKind": "custom", + "argumentType": "varchar", + "isInfix": false + } + }, + "typeRepresentation": "string" + } + }, + "composite": { + "chara": { + "typeName": "chara", + "schemaName": "public", + "fields": { + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + }, + "popularity": { + "fieldName": "popularity", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "characters": { + "typeName": "characters", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "chara" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "committee": { + "typeName": "committee", + "schemaName": "public", + "fields": { + "members": { + "fieldName": "members", + "type": { + "arrayType": { + "compositeType": "person_name" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "discoverable_types": { + "typeName": "discoverable_types", + "schemaName": "public", + "fields": { + "only_occurring_here1": { + "fieldName": "only_occurring_here1", + "type": { + "scalarType": "int8" + }, + "description": null + } + }, + "description": null + }, + "organization": { + "typeName": "organization", + "schemaName": "public", + "fields": { + "committees": { + "fieldName": "committees", + "type": { + "arrayType": { + "compositeType": "committee" + } + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "scalarType": "text" + }, + "description": null + } + }, + "description": null + }, + "person": { + "typeName": "person", + "schemaName": "public", + "fields": { + "address": { + "fieldName": "address", + "type": { + "compositeType": "person_address" + }, + "description": null + }, + "name": { + "fieldName": "name", + "type": { + "compositeType": "person_name" + }, + "description": null + } + }, + "description": null + }, + "person_address": { + "typeName": "person_address", + "schemaName": "public", + "fields": { + "address_line_1": { + "fieldName": "address_line_1", + "type": { + "scalarType": "text" + }, + "description": "Address line No 1" + }, + "address_line_2": { + "fieldName": "address_line_2", + "type": { + "scalarType": "text" + }, + "description": "Address line No 2" + } + }, + "description": "The address of a person, obviously" + }, + "person_name": { + "typeName": "person_name", + "schemaName": "public", + "fields": { + "first_name": { + "fieldName": "first_name", + "type": { + "scalarType": "text" + }, + "description": "The first name of a person" + }, + "last_name": { + "fieldName": "last_name", + "type": { + "scalarType": "text" + }, + "description": "The last name of a person" + } + }, + "description": "The name of a person, obviously" + } + } + }, + "nativeOperations": { + "queries": { + "address_identity_function": { + "sql": { + "inline": "SELECT {{address}} as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "album_by_title": { + "sql": { + "inline": "SELECT * FROM public.\"Album\" WHERE \"Title\" LIKE {{title}} AND \"AlbumId\" < {{id}}" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "array_reverse": { + "sql": { + "inline": "SELECT array_agg(t.x) as reversed FROM (SELECT x FROM unnest({{array}}) WITH ORDINALITY AS t(x,ix) ORDER BY t.ix DESC) as t(x)" + }, + "columns": { + "reversed": { + "name": "reversed", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nullable", + "description": "The reversed array" + } + }, + "arguments": { + "array": { + "name": "array", + "type": { + "arrayType": { + "scalarType": "varchar" + } + }, + "nullable": "nonNullable", + "description": "The array to reverse. This is necessarily of a monomorphic type." + } + }, + "description": "A native query used to test support for arrays as inputs" + }, + "array_series": { + "sql": { + "inline": "SELECT 3 as three, array_agg(arr.series) AS series FROM (SELECT generate_series({{from}},{{to}}) AS series) AS arr" + }, + "columns": { + "series": { + "name": "series", + "type": { + "arrayType": { + "scalarType": "int4" + } + }, + "nullable": "nullable", + "description": null + }, + "three": { + "name": "three", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "from": { + "name": "from", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "to": { + "name": "to", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for arrays" + }, + "artist": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\"" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": {}, + "description": null + }, + "artist_below_id": { + "sql": { + "inline": "SELECT * FROM public.\"Artist\" WHERE \"ArtistId\" < {{id}}" + }, + "columns": { + "id": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "count_elements": { + "sql": { + "inline": "SELECT array_length({{array_argument}}, 1) as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "array_argument": { + "name": "array_argument", + "type": { + "arrayType": { + "scalarType": "text" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "make_person": { + "sql": { + "inline": "SELECT ROW({{name}}, {{address}})::person as result" + }, + "columns": { + "result": { + "name": "result", + "type": { + "compositeType": "person" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "address": { + "name": "address", + "type": { + "compositeType": "person_address" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "compositeType": "person_name" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "organization_identity_function": { + "sql": { + "inline": "SELECT {{organization}} as result_the_column" + }, + "columns": { + "result_the_field": { + "name": "result_the_column", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organization": { + "name": "organization", + "type": { + "compositeType": "organization" + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support for composite types" + }, + "summarize_organizations": { + "sql": { + "inline": "SELECT 'The organization ' || org.name || ' has ' || no_committees::text || ' committees, ' || 'the largest of which has ' || max_members || ' members.' AS result FROM (SELECT orgs.* FROM unnest({{organizations}}) as orgs) AS org JOIN LATERAL ( SELECT count(committee.*) AS no_committees, max(members_agg.no_members) AS max_members FROM unnest(org.committees) AS committee JOIN LATERAL ( SELECT count(*) as no_members FROM unnest(committee.members) AS members) AS members_agg ON true) AS coms ON true" + }, + "columns": { + "result": { + "name": "result", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "organizations": { + "name": "organizations", + "type": { + "arrayType": { + "compositeType": "organization" + } + }, + "nullable": "nullable", + "description": null + } + }, + "description": "A native query used to test support array-valued variables" + }, + "value_types": { + "sql": { + "inline": "SELECT {{bool}} as bool, {{int4}} as int4, {{int2}} as int2, {{int8}} as int8, {{float4}} as float4, {{float8}} as \"float8\", {{numeric}} as numeric, {{char}} as char, {{varchar}} as \"varchar\", {{text}} as text, {{date}} as date, {{time}} as time, {{timetz}} as timetz, {{timestamp}} as timestamp, {{timestamptz}} as timestamptz, {{uuid}} as uuid" + }, + "columns": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "bool": { + "name": "bool", + "type": { + "scalarType": "bool" + }, + "nullable": "nullable", + "description": null + }, + "char": { + "name": "char", + "type": { + "scalarType": "char" + }, + "nullable": "nullable", + "description": null + }, + "date": { + "name": "date", + "type": { + "scalarType": "date" + }, + "nullable": "nullable", + "description": null + }, + "float4": { + "name": "float4", + "type": { + "scalarType": "float4" + }, + "nullable": "nullable", + "description": null + }, + "float8": { + "name": "float8", + "type": { + "scalarType": "float8" + }, + "nullable": "nullable", + "description": null + }, + "int2": { + "name": "int2", + "type": { + "scalarType": "int2" + }, + "nullable": "nullable", + "description": null + }, + "int4": { + "name": "int4", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "int8": { + "name": "int8", + "type": { + "scalarType": "int8" + }, + "nullable": "nullable", + "description": null + }, + "numeric": { + "name": "numeric", + "type": { + "scalarType": "numeric" + }, + "nullable": "nullable", + "description": null + }, + "text": { + "name": "text", + "type": { + "scalarType": "text" + }, + "nullable": "nullable", + "description": null + }, + "time": { + "name": "time", + "type": { + "scalarType": "time" + }, + "nullable": "nullable", + "description": null + }, + "timestamp": { + "name": "timestamp", + "type": { + "scalarType": "timestamp" + }, + "nullable": "nullable", + "description": null + }, + "timestamptz": { + "name": "timestamptz", + "type": { + "scalarType": "timestamptz" + }, + "nullable": "nullable", + "description": null + }, + "timetz": { + "name": "timetz", + "type": { + "scalarType": "timetz" + }, + "nullable": "nullable", + "description": null + }, + "uuid": { + "name": "uuid", + "type": { + "scalarType": "uuid" + }, + "nullable": "nullable", + "description": null + }, + "varchar": { + "name": "varchar", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + }, + "mutations": { + "delete_playlist_track": { + "sql": { + "inline": "DELETE FROM public.\"PlaylistTrack\" WHERE \"TrackId\" = {{track_id}} RETURNING *" + }, + "columns": { + "PlaylistId": { + "name": "PlaylistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "TrackId": { + "name": "TrackId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "track_id": { + "name": "track_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_album": { + "sql": { + "inline": "INSERT INTO public.\"Album\" VALUES({{id}}, {{title}}, {{artist_id}}) RETURNING *" + }, + "columns": { + "AlbumId": { + "name": "AlbumId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Title": { + "name": "Title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "artist_id": { + "name": "artist_id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "title": { + "name": "title", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + }, + "insert_artist": { + "sql": { + "inline": "INSERT INTO public.\"Artist\" VALUES ({{id}}, {{name}}) RETURNING *" + }, + "columns": { + "ArtistId": { + "name": "ArtistId", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "Name": { + "name": "Name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "arguments": { + "id": { + "name": "id", + "type": { + "scalarType": "int4" + }, + "nullable": "nullable", + "description": null + }, + "name": { + "name": "name", + "type": { + "scalarType": "varchar" + }, + "nullable": "nullable", + "description": null + } + }, + "description": null + } + } + } + }, + "introspectionOptions": { + "excludedSchemas": [ + "information_schema", + "pg_catalog", + "tiger", + "crdb_internal", + "columnar", + "columnar_internal" + ], + "unqualifiedSchemasForTables": ["public"], + "unqualifiedSchemasForTypesAndProcedures": [ + "public", + "pg_catalog", + "tiger" + ], + "comparisonOperatorMapping": [ + { + "operatorName": "=", + "exposedName": "_eq", + "operatorKind": "equal" + }, + { + "operatorName": "<=", + "exposedName": "_lte", + "operatorKind": "custom" + }, + { + "operatorName": ">", + "exposedName": "_gt", + "operatorKind": "custom" + }, + { + "operatorName": ">=", + "exposedName": "_gte", + "operatorKind": "custom" + }, + { + "operatorName": "<", + "exposedName": "_lt", + "operatorKind": "custom" + }, + { + "operatorName": "!=", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "LIKE", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "NOT LIKE", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "ILIKE", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "NOT ILIKE", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "SIMILAR TO", + "exposedName": "_similar", + "operatorKind": "custom" + }, + { + "operatorName": "NOT SIMILAR TO", + "exposedName": "_nsimilar", + "operatorKind": "custom" + }, + { + "operatorName": "<>", + "exposedName": "_neq", + "operatorKind": "custom" + }, + { + "operatorName": "~~", + "exposedName": "_like", + "operatorKind": "custom" + }, + { + "operatorName": "!~~", + "exposedName": "_nlike", + "operatorKind": "custom" + }, + { + "operatorName": "~~*", + "exposedName": "_ilike", + "operatorKind": "custom" + }, + { + "operatorName": "!~~*", + "exposedName": "_nilike", + "operatorKind": "custom" + }, + { + "operatorName": "~", + "exposedName": "_regex", + "operatorKind": "custom" + }, + { + "operatorName": "!~", + "exposedName": "_nregex", + "operatorKind": "custom" + }, + { + "operatorName": "~*", + "exposedName": "_iregex", + "operatorKind": "custom" + }, + { + "operatorName": "!~*", + "exposedName": "_niregex", + "operatorKind": "custom" + } + ], + "introspectPrefixFunctionComparisonOperators": [ + "box_above", + "box_below", + "box_contain", + "box_contain_pt", + "box_contained", + "box_left", + "box_overabove", + "box_overbelow", + "box_overlap", + "box_overleft", + "box_overright", + "box_right", + "box_same", + "circle_above", + "circle_below", + "circle_contain", + "circle_contain_pt", + "circle_contained", + "circle_left", + "circle_overabove", + "circle_overbelow", + "circle_overlap", + "circle_overleft", + "circle_overright", + "circle_right", + "circle_same", + "contains_2d", + "equals", + "geography_overlaps", + "geometry_above", + "geometry_below", + "geometry_contained_3d", + "geometry_contains", + "geometry_contains_3d", + "geometry_contains_nd", + "geometry_left", + "geometry_overabove", + "geometry_overbelow", + "geometry_overlaps", + "geometry_overlaps_3d", + "geometry_overlaps_nd", + "geometry_overleft", + "geometry_overright", + "geometry_right", + "geometry_same", + "geometry_same_3d", + "geometry_same_nd", + "geometry_within", + "geometry_within_nd", + "inet_same_family", + "inter_lb", + "inter_sb", + "inter_sl", + "is_contained_2d", + "ishorizontal", + "isparallel", + "isperp", + "isvertical", + "jsonb_contained", + "jsonb_contains", + "jsonb_exists", + "jsonb_path_exists_opr", + "jsonb_path_match_opr", + "line_intersect", + "line_parallel", + "line_perp", + "lseg_intersect", + "lseg_parallel", + "lseg_perp", + "network_overlap", + "network_sub", + "network_sup", + "on_pb", + "on_pl", + "on_ppath", + "on_ps", + "on_sb", + "on_sl", + "overlaps_2d", + "path_contain_pt", + "path_inter", + "point_above", + "point_below", + "point_horiz", + "point_left", + "point_right", + "point_vert", + "poly_above", + "poly_below", + "poly_contain", + "poly_contain_pt", + "poly_contained", + "poly_left", + "poly_overabove", + "poly_overbelow", + "poly_overlap", + "poly_overleft", + "poly_overright", + "poly_right", + "poly_same", + "pt_contained_poly", + "st_3dintersects", + "st_contains", + "st_containsproperly", + "st_coveredby", + "st_covers", + "st_crosses", + "st_disjoint", + "st_equals", + "st_intersects", + "st_isvalid", + "st_orderingequals", + "st_overlaps", + "st_relatematch", + "st_touches", + "st_within", + "starts_with", + "ts_match_qv", + "ts_match_tq", + "ts_match_tt", + "ts_match_vq", + "tsq_mcontained", + "tsq_mcontains", + "xmlexists", + "xmlvalidate", + "xpath_exists" + ], + "typeRepresentations": { + "bit": "string", + "bool": "boolean", + "bpchar": "string", + "char": "string", + "date": "date", + "float4": "float32", + "float8": "float64", + "int2": "int16", + "int4": "int32", + "int8": "int64AsString", + "numeric": "bigDecimalAsString", + "text": "string", + "time": "time", + "timestamp": "timestamp", + "timestamptz": "timestamptz", + "timetz": "timetz", + "uuid": "uUID", + "varchar": "string" + } + }, + "mutationsVersion": "v1" +}