diff --git a/Cargo.lock b/Cargo.lock index ab5073efbf..a3a4f57c38 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -398,6 +398,7 @@ dependencies = [ "semver", "serde", "serde-xml-rs", + "serde_json", "tar", "tempfile", "toml 0.9.7", @@ -2044,6 +2045,8 @@ dependencies = [ "petgraph", "proc-macro2", "quote", + "serde", + "serde_json", "syn", "syntect", "thiserror 2.0.16", diff --git a/cargo-pgrx/Cargo.toml b/cargo-pgrx/Cargo.toml index 0528aaf6de..851c51f67b 100644 --- a/cargo-pgrx/Cargo.toml +++ b/cargo-pgrx/Cargo.toml @@ -53,6 +53,7 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter"] } bzip2 = "0.5.2" env_proxy = "0.4.1" serde.workspace = true +serde_json.workspace = true serde-xml-rs = "0.6.0" tar = "0.4.44" ureq = { version = "3.0.10", default-features = false, features = ["gzip", "platform-verifier", "rustls"] } diff --git a/cargo-pgrx/src/command/install.rs b/cargo-pgrx/src/command/install.rs index 6554b789ad..678a80b5bb 100644 --- a/cargo-pgrx/src/command/install.rs +++ b/cargo-pgrx/src/command/install.rs @@ -356,11 +356,18 @@ fn copy_sql_files( output_tracking: &mut Vec, ) -> eyre::Result<()> { let (_, extname) = find_control_file(package_manifest_path)?; + let version = get_version(package_manifest_path)?; + + // Generate main SQL file and snapshot { - let version = get_version(package_manifest_path)?; let filename = format!("{extname}--{version}.sql"); let dest = extdir.join(filename); + // Also generate a snapshot for this version + let project_dir = package_manifest_path.parent().unwrap(); + let snapshot_dir = project_dir.join("sql/snapshots"); + let snapshot_path = snapshot_dir.join(format!("{extname}--{version}.json")); + crate::command::schema::generate_schema( user_manifest_path, user_package, @@ -371,6 +378,7 @@ fn copy_sql_files( target, Some(&dest), None, + Some(&snapshot_path), None, skip_build, output_tracking, diff --git a/cargo-pgrx/src/command/schema.rs b/cargo-pgrx/src/command/schema.rs index d9ec0bd4ad..7101475942 100644 --- a/cargo-pgrx/src/command/schema.rs +++ b/cargo-pgrx/src/command/schema.rs @@ -54,6 +54,9 @@ pub(crate) struct Schema { /// A path to output a produced GraphViz DOT file #[clap(long, short, value_parser)] dot: Option, + /// A path to output a schema snapshot JSON file (for upgrade script generation) + #[clap(long, value_parser)] + snapshot: Option, #[clap(long)] target: Option, #[clap(from_global, action = ArgAction::Count)] @@ -107,6 +110,7 @@ impl CommandExecute for Schema { self.target.as_deref(), self.out.as_deref(), self.dot.as_deref(), + self.snapshot.as_deref(), log_level, self.skip_build, &mut vec![], @@ -119,6 +123,7 @@ impl CommandExecute for Schema { test = is_test, path = path.map(|path| tracing::field::display(path.display())), dot, + snapshot, features = ?features.features, ))] pub(crate) fn generate_schema_for_cli( @@ -131,6 +136,7 @@ pub(crate) fn generate_schema_for_cli( target: Option<&str>, path: Option<&Path>, dot: Option<&Path>, + snapshot: Option<&Path>, log_level: Option, skip_build: bool, output_tracking: &mut Vec, @@ -163,6 +169,7 @@ pub(crate) fn generate_schema_for_cli( target, path, dot, + snapshot, output_tracking, manifest, ) @@ -177,6 +184,7 @@ pub(crate) fn generate_schema_implicit( target: Option<&str>, path: Option<&Path>, dot: Option<&Path>, + snapshot: Option<&Path>, output_tracking: &mut Vec, manifest: cargo_toml::Manifest, ) -> eyre::Result<()> { @@ -186,8 +194,15 @@ pub(crate) fn generate_schema_implicit( let symbols = find_and_compute_symbols(profile, &lib_filename, target)?; - let codegen = - compute_codegen(&control_file, package_manifest_path, &symbols, &lib_name, path, dot)?; + let codegen = compute_codegen( + &control_file, + package_manifest_path, + &symbols, + &lib_name, + path, + dot, + snapshot, + )?; let embed = { let mut embed = tempfile::NamedTempFile::new()?; @@ -358,6 +373,7 @@ fn compute_codegen( lib_name: &str, path: Option<&Path>, dot: Option<&Path>, + snapshot: Option<&Path>, ) -> eyre::Result { use proc_macro2::{Ident, Span, TokenStream}; let lib_name_ident = Ident::new(lib_name, Span::call_site()); @@ -434,6 +450,104 @@ fn compute_codegen( .expect("Could not write Graphviz DOT"); }); } + if let Some(snapshot) = snapshot { + let snapshot = str_from_path("snapshot", snapshot)?; + let writing = " Writing".bold().green().to_string(); + let generating = " Generating".bold().green().to_string(); + let wrote = " Wrote".bold().green().to_string(); + out.extend(quote::quote! { + eprintln!("{} schema snapshot to {}", #writing, #snapshot); + let current_snapshot = ::pgrx::pgrx_sql_entity_graph::SchemaSnapshot::from_pgrx_sql(&pgrx_sql); + current_snapshot + .save(std::path::Path::new(#snapshot)) + .expect(&format!("Could not write snapshot to {}", #snapshot)); + + // Generate upgrade script from the previous version only + let snapshot_path = std::path::Path::new(#snapshot); + let snapshot_dir = snapshot_path.parent().unwrap(); + let sql_dir = snapshot_dir.parent().unwrap(); + + if snapshot_dir.exists() { + let extname = &pgrx_sql.extension_name; + let current_version = ¤t_snapshot.version; + + // Collect all version snapshots and sort them + let mut versions: Vec<(String, std::path::PathBuf)> = Vec::new(); + + if let Ok(entries) = std::fs::read_dir(snapshot_dir) { + for entry in entries.flatten() { + let path = entry.path(); + if !path.is_file() || path.extension().and_then(|s| s.to_str()) != Some("json") { + continue; + } + + let filename = path.file_name().unwrap().to_str().unwrap(); + + // Extract version from filename (format: extname--version.json) + if let Some(version) = filename + .strip_prefix(&format!("{extname}--")) + .and_then(|s| s.strip_suffix(".json")) + { + versions.push((version.to_string(), path)); + } + } + } + + // Sort versions (simple string comparison) + // Note: This is a simple lexicographic sort. For proper semantic + // versioning, ensure version strings use consistent formatting (e.g., "0.1.0", "0.10.0") + versions.sort_by(|a, b| a.0.cmp(&b.0)); + + // Find the immediate previous version + let current_idx = versions.iter().position(|(v, _)| v == current_version); + if let Some(idx) = current_idx { + if idx > 0 { + // There is a previous version + let (prev_version, prev_path) = &versions[idx - 1]; + + // Load previous snapshot + let prev_json_str = std::fs::read_to_string(prev_path) + .expect(&format!("Failed to load snapshot for version {}", prev_version)); + + // Leak the JSON string to get 'static lifetime for deserialization + let prev_json_str_static: &'static str = Box::leak(prev_json_str.into_boxed_str()); + + // Deserialize the snapshot + let prev_snapshot_result: Result<::pgrx::pgrx_sql_entity_graph::SchemaSnapshot, _> = + ::pgrx::pgrx_sql_entity_graph::deserialize_snapshot(prev_json_str_static); + let prev_snapshot = prev_snapshot_result + .expect(&format!("Failed to deserialize snapshot for version {}", prev_version)); + + // Generate upgrade script + eprintln!( + "{} upgrade script: {} -> {}", + #generating, + prev_version, + current_version + ); + + let diff = ::pgrx::pgrx_sql_entity_graph::SchemaDiff::compare(&prev_snapshot, ¤t_snapshot); + + let upgrade_script = ::pgrx::pgrx_sql_entity_graph::generate_upgrade_script_with_sql( + prev_version, + current_version, + &diff, + &pgrx_sql, + ) + .expect(&format!("Failed to generate upgrade script from {} to {}", prev_version, current_version)); + + // Write upgrade script + let upgrade_filename = format!("{extname}--{prev_version}--{current_version}.sql"); + let upgrade_path = sql_dir.join(&upgrade_filename); + std::fs::write(&upgrade_path, upgrade_script) + .expect(&format!("Failed to write upgrade script {}", upgrade_filename)); + + eprintln!("{} {}", #wrote, upgrade_filename); + } + } + } + }); + } out }; Ok(quote::quote! { diff --git a/pgrx-examples/versioned_so/src/lib.rs b/pgrx-examples/versioned_so/src/lib.rs index 70479ba373..55a20f636d 100644 --- a/pgrx-examples/versioned_so/src/lib.rs +++ b/pgrx-examples/versioned_so/src/lib.rs @@ -16,6 +16,14 @@ fn hello_versioned_so() -> &'static str { "Hello, versioned_so" } + +#[pg_extern] +fn peos_pne(e: i32) -> String { + let p = e + 0; + format!("Hello, versioned_so {}", p) +} + + #[cfg(any(test, feature = "pg_test"))] #[pg_schema] mod tests { diff --git a/pgrx-sql-entity-graph/Cargo.toml b/pgrx-sql-entity-graph/Cargo.toml index d152351186..176946b1f6 100644 --- a/pgrx-sql-entity-graph/Cargo.toml +++ b/pgrx-sql-entity-graph/Cargo.toml @@ -31,6 +31,8 @@ proc-macro2.workspace = true quote.workspace = true syn.workspace = true thiserror.workspace = true +serde.workspace = true +serde_json.workspace = true convert_case = "0.8.0" petgraph = "0.8.1" diff --git a/pgrx-sql-entity-graph/src/aggregate/entity.rs b/pgrx-sql-entity-graph/src/aggregate/entity.rs index 843f649600..45adabb79b 100644 --- a/pgrx-sql-entity-graph/src/aggregate/entity.rs +++ b/pgrx-sql-entity-graph/src/aggregate/entity.rs @@ -27,20 +27,32 @@ use crate::{SqlGraphEntity, SqlGraphIdentifier, UsedTypeEntity}; use core::any::TypeId; use eyre::{WrapErr, eyre}; -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +fn default_type_id() -> TypeId { + TypeId::of::() +} + +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct AggregateTypeEntity { pub used_ty: UsedTypeEntity, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub name: Option<&'static str>, } -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgAggregateEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(skip, default = "default_type_id")] pub ty_id: TypeId, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, /// If the aggregate is an ordered set aggregate. @@ -66,11 +78,13 @@ pub struct PgAggregateEntity { /// The `SFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `state` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub sfunc: &'static str, /// The `FINALFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `finalize` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub finalfunc: Option<&'static str>, /// The `FINALFUNC_MODIFY` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) @@ -81,31 +95,37 @@ pub struct PgAggregateEntity { /// The `COMBINEFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `combine` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub combinefunc: Option<&'static str>, /// The `SERIALFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `serial` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub serialfunc: Option<&'static str>, /// The `DESERIALFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `deserial` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub deserialfunc: Option<&'static str>, /// The `INITCOND` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `INITIAL_CONDITION` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub initcond: Option<&'static str>, /// The `MSFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `moving_state` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub msfunc: Option<&'static str>, /// The `MINVFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `moving_state_inverse` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub minvfunc: Option<&'static str>, /// The `MSTYPE` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) @@ -120,6 +140,7 @@ pub struct PgAggregateEntity { /// The `MFINALFUNC` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `moving_state_finalize` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub mfinalfunc: Option<&'static str>, /// The `MFINALFUNC_MODIFY` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) @@ -130,11 +151,13 @@ pub struct PgAggregateEntity { /// The `MINITCOND` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `MOVING_INITIAL_CONDITION` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub minitcond: Option<&'static str>, /// The `SORTOP` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) /// /// Corresponds to `SORT_OPERATOR` in `pgrx::aggregate::Aggregate`. + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub sortop: Option<&'static str>, /// The `PARALLEL` parameter for [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html) diff --git a/pgrx-sql-entity-graph/src/aggregate/options.rs b/pgrx-sql-entity-graph/src/aggregate/options.rs index f35c208048..b8163f9c11 100644 --- a/pgrx-sql-entity-graph/src/aggregate/options.rs +++ b/pgrx-sql-entity-graph/src/aggregate/options.rs @@ -18,7 +18,18 @@ use crate::{PgrxSql, ToSql}; /// Corresponds to the `PARALLEL` and `MFINALFUNC_MODIFY` in [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html). -#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive( + Debug, + Clone, + Copy, + Hash, + PartialEq, + Eq, + PartialOrd, + Ord, + serde::Serialize, + serde::Deserialize +)] pub enum ParallelOption { Safe, Restricted, @@ -37,7 +48,18 @@ impl ToSql for ParallelOption { } /// Corresponds to the `FINALFUNC_MODIFY` and `MFINALFUNC_MODIFY` in [`CREATE AGGREGATE`](https://www.postgresql.org/docs/current/sql-createaggregate.html). -#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive( + Debug, + Clone, + Copy, + Hash, + PartialEq, + Eq, + PartialOrd, + Ord, + serde::Serialize, + serde::Deserialize +)] pub enum FinalizeModify { ReadOnly, Shareable, diff --git a/pgrx-sql-entity-graph/src/control_file.rs b/pgrx-sql-entity-graph/src/control_file.rs index 25360e315c..6f29b919c4 100644 --- a/pgrx-sql-entity-graph/src/control_file.rs +++ b/pgrx-sql-entity-graph/src/control_file.rs @@ -32,7 +32,7 @@ use thiserror::Error; /// # Ok(()) /// # } /// ``` -#[derive(Debug, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +#[derive(Debug, Clone, Hash, PartialOrd, Ord, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ControlFile { pub comment: String, pub default_version: String, diff --git a/pgrx-sql-entity-graph/src/diff.rs b/pgrx-sql-entity-graph/src/diff.rs new file mode 100644 index 0000000000..446dafb401 --- /dev/null +++ b/pgrx-sql-entity-graph/src/diff.rs @@ -0,0 +1,504 @@ +//LICENSE Portions Copyright 2019-2021 ZomboDB, LLC. +//LICENSE +//LICENSE Portions Copyright 2021-2023 Technology Concepts & Design, Inc. +//LICENSE +//LICENSE Portions Copyright 2023-2023 PgCentral Foundation, Inc. +//LICENSE +//LICENSE All rights reserved. +//LICENSE +//LICENSE Use of this source code is governed by the MIT license that can be found in the LICENSE file. + +//! Schema snapshot comparison and diff infrastructure. +//! +//! This module provides functionality for comparing two schema snapshots +//! and detecting additions, removals, modifications, and renames. + +use crate::SqlGraphIdentifier; +use crate::snapshot::{EntityId, SchemaSnapshot, SerializableEntity}; +use crate::snapshot_types::SqlGraphEntitySnapshot; +use std::collections::{HashMap, HashSet}; + +/// The result of comparing two schema snapshots. +#[derive(Debug, Clone)] +pub struct SchemaDiff { + /// The old (baseline) snapshot version + pub from_version: String, + /// The new (target) snapshot version + pub to_version: String, + /// Entities that exist in the new snapshot but not the old + pub added: Vec, + /// Entities that exist in the old snapshot but not the new + pub removed: Vec, + /// Entities that exist in both but have different signatures + pub modified: Vec, + /// Entities that appear to have been renamed (based on signature matching) + pub renamed: Vec, +} + +/// A single entity that was added or removed. +#[derive(Debug, Clone)] +pub struct EntityChange { + /// The entity ID + pub id: EntityId, + /// The entity data (snapshot version without TypeId) + pub entity: SqlGraphEntitySnapshot, + /// Whether this entity depends on other changes + pub dependencies: Vec, // rust_identifiers of dependencies +} + +/// An entity that was modified between versions. +#[derive(Debug, Clone)] +pub struct EntityModification { + /// The entity's identifier + pub id: EntityId, + /// The old version of the entity + pub old_entity: SqlGraphEntitySnapshot, + /// The new version of the entity + pub new_entity: SqlGraphEntitySnapshot, + /// Description of what changed + pub changes: Vec, +} + +/// An entity that appears to have been renamed. +#[derive(Debug, Clone)] +pub struct EntityRename { + /// The old entity identifier + pub old_id: EntityId, + /// The new entity identifier + pub new_id: EntityId, + /// The old entity data + pub old_entity: SqlGraphEntitySnapshot, + /// The new entity data + pub new_entity: SqlGraphEntitySnapshot, + /// Confidence score (0.0-1.0) that this is actually a rename + pub confidence: f64, +} + +impl SchemaDiff { + /// Compare two schema snapshots and produce a diff. + pub fn compare(old: &SchemaSnapshot, new: &SchemaSnapshot) -> Self { + let mut diff = SchemaDiff { + from_version: old.version.clone(), + to_version: new.version.clone(), + added: Vec::new(), + removed: Vec::new(), + modified: Vec::new(), + renamed: Vec::new(), + }; + + // Build indices for fast lookup + let new_index = new.build_entity_index(); + + // Track which entities we've already processed + let mut processed_old: HashSet = HashSet::new(); + let mut processed_new: HashSet = HashSet::new(); + + // First pass: detect exact matches and modifications + for old_entity in &old.entities { + let old_identifier = &old_entity.id.rust_identifier; + + if let Some(new_entity) = new_index.get(old_identifier) { + // Entity exists in both snapshots + if old_entity.id.signature_hash != new_entity.id.signature_hash { + // Entity was modified + let changes = Self::describe_changes(&old_entity.entity, &new_entity.entity); + diff.modified.push(EntityModification { + id: new_entity.id.clone(), + old_entity: old_entity.entity.clone(), + new_entity: new_entity.entity.clone(), + changes, + }); + } + processed_old.insert(old_identifier.clone()); + processed_new.insert(old_identifier.clone()); + } + } + + // Second pass: detect potential renames using signature matching + let unmatched_old: Vec<&SerializableEntity> = old + .entities + .iter() + .filter(|e| !processed_old.contains(&e.id.rust_identifier)) + .collect(); + + let unmatched_new: Vec<&SerializableEntity> = new + .entities + .iter() + .filter(|e| !processed_new.contains(&e.id.rust_identifier)) + .collect(); + + // Try to match by signature hash (fuzzy matching for renames) + for old_entity in &unmatched_old { + for new_entity in &unmatched_new { + // Can only rename within the same entity type + if old_entity.id.entity_type != new_entity.id.entity_type { + continue; + } + + // Skip if already processed + if processed_new.contains(&new_entity.id.rust_identifier) { + continue; + } + + // Calculate similarity + let confidence = Self::calculate_rename_confidence(old_entity, new_entity); + + if confidence > 0.7 { + // Likely a rename + diff.renamed.push(EntityRename { + old_id: old_entity.id.clone(), + new_id: new_entity.id.clone(), + old_entity: old_entity.entity.clone(), + new_entity: new_entity.entity.clone(), + confidence, + }); + + processed_old.insert(old_entity.id.rust_identifier.clone()); + processed_new.insert(new_entity.id.rust_identifier.clone()); + break; // Found a match, move to next old_entity + } + } + } + + // Third pass: remaining entities are pure additions/removals + for old_entity in &old.entities { + if !processed_old.contains(&old_entity.id.rust_identifier) { + diff.removed.push(EntityChange { + id: old_entity.id.clone(), + entity: old_entity.entity.clone(), + dependencies: Self::extract_dependencies(&old_entity.entity, old), + }); + } + } + + for new_entity in &new.entities { + if !processed_new.contains(&new_entity.id.rust_identifier) { + diff.added.push(EntityChange { + id: new_entity.id.clone(), + entity: new_entity.entity.clone(), + dependencies: Self::extract_dependencies(&new_entity.entity, new), + }); + } + } + + diff + } + + /// Calculate confidence (0.0-1.0) that two entities represent a rename. + fn calculate_rename_confidence(old: &SerializableEntity, new: &SerializableEntity) -> f64 { + let mut score = 0.0; + let mut max_score = 0.0; + + // Same type is required (already filtered) + max_score += 1.0; + score += 1.0; + + // Same signature hash is strong evidence + max_score += 3.0; + if old.id.signature_hash == new.id.signature_hash { + score += 3.0; + } + + // Similar file location + max_score += 1.0; + if let (Some(old_file), Some(new_file)) = (old.entity.file(), new.entity.file()) { + if old_file == new_file { + score += 1.0; + } else if old_file.contains(new_file) || new_file.contains(old_file) { + score += 0.5; + } + } + + // Similar module path + max_score += 1.0; + let old_parts: Vec<&str> = old.id.rust_identifier.split("::").collect(); + let new_parts: Vec<&str> = new.id.rust_identifier.split("::").collect(); + + if old_parts.len() > 1 && new_parts.len() > 1 { + // Compare module path (all but last segment) + let old_module = &old_parts[..old_parts.len() - 1]; + let new_module = &new_parts[..new_parts.len() - 1]; + + let common = + old_module.iter().zip(new_module.iter()).take_while(|(a, b)| a == b).count(); + let max_len = old_module.len().max(new_module.len()) as f64; + + if max_len > 0.0 { + score += (common as f64) / max_len; + } + } + + score / max_score + } + + /// Describe what changed between two versions of an entity. + fn describe_changes(old: &SqlGraphEntitySnapshot, new: &SqlGraphEntitySnapshot) -> Vec { + let mut changes = Vec::new(); + + // This is a simplified version - in reality, we'd do deep comparisons + // For now, just note that the signature changed + let old_hash = { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + let mut hasher = DefaultHasher::new(); + old.hash(&mut hasher); + format!("{:x}", hasher.finish()) + }; + + let new_hash = { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + let mut hasher = DefaultHasher::new(); + new.hash(&mut hasher); + format!("{:x}", hasher.finish()) + }; + + if old_hash != new_hash { + changes.push("Signature changed".to_string()); + } + + // Add more specific change detection based on entity type + match (old, new) { + ( + SqlGraphEntitySnapshot::Function(old_fn), + SqlGraphEntitySnapshot::Function(new_fn), + ) => { + if old_fn.name != new_fn.name { + changes.push(format!("Name changed: {} -> {}", old_fn.name, new_fn.name)); + } + } + (SqlGraphEntitySnapshot::Type(old_type), SqlGraphEntitySnapshot::Type(new_type)) => { + if old_type.name != new_type.name { + changes + .push(format!("Type name changed: {} -> {}", old_type.name, new_type.name)); + } + } + (SqlGraphEntitySnapshot::Enum(old_enum), SqlGraphEntitySnapshot::Enum(new_enum)) => { + if old_enum.name != new_enum.name { + changes + .push(format!("Enum name changed: {} -> {}", old_enum.name, new_enum.name)); + } + if old_enum.variants != new_enum.variants { + changes.push("Enum variants changed".to_string()); + } + } + _ => {} + } + + if changes.is_empty() { + changes.push("Unknown change".to_string()); + } + + changes + } + + /// Extract dependencies for an entity from the snapshot. + fn extract_dependencies( + entity: &SqlGraphEntitySnapshot, + snapshot: &SchemaSnapshot, + ) -> Vec { + let mut deps = Vec::new(); + + // Find edges in the dependency graph where this entity is the source + let entity_identifier = entity.rust_identifier(); + + for edge in &snapshot.dependency_edges { + if edge.from == entity_identifier { + deps.push(edge.to.clone()); + } + } + + deps + } + + /// Check if the diff contains any breaking changes. + pub fn has_breaking_changes(&self) -> bool { + // Removals are always breaking + if !self.removed.is_empty() { + return true; + } + + // Modifications to functions or types are potentially breaking + for modification in &self.modified { + match &modification.new_entity { + SqlGraphEntitySnapshot::Function(_) + | SqlGraphEntitySnapshot::Type(_) + | SqlGraphEntitySnapshot::Enum(_) => { + return true; + } + _ => {} + } + } + + false + } + + /// Get a summary of the diff. + pub fn summary(&self) -> String { + format!( + "Schema changes from {} to {}: {} added, {} removed, {} modified, {} renamed", + self.from_version, + self.to_version, + self.added.len(), + self.removed.len(), + self.modified.len(), + self.renamed.len() + ) + } + + /// Get entities in dependency order for additions. + /// This ensures that dependencies are created before the entities that depend on them. + pub fn additions_in_dependency_order(&self) -> Vec<&EntityChange> { + let mut result = Vec::new(); + let mut added_identifiers = HashSet::new(); + + // Build a map of identifiers to EntityChange + let mut entity_map: HashMap = HashMap::new(); + for change in &self.added { + entity_map.insert(change.id.rust_identifier.clone(), change); + } + + // Topological sort + fn visit<'a>( + identifier: &str, + entity_map: &HashMap, + added_identifiers: &mut HashSet, + result: &mut Vec<&'a EntityChange>, + ) { + if added_identifiers.contains(identifier) { + return; + } + + if let Some(change) = entity_map.get(identifier) { + // Visit dependencies first + for dep in &change.dependencies { + visit(dep, entity_map, added_identifiers, result); + } + + added_identifiers.insert(identifier.to_string()); + result.push(change); + } + } + + // Visit all entities + for identifier in entity_map.keys() { + visit(identifier, &entity_map, &mut added_identifiers, &mut result); + } + + result + } + + /// Get entities in reverse dependency order for removals. + /// This ensures that entities are dropped before their dependencies. + pub fn removals_in_dependency_order(&self) -> Vec<&EntityChange> { + let mut result = Vec::new(); + let mut removed_identifiers = HashSet::new(); + + // Build a map of identifiers to EntityChange + let mut entity_map: HashMap = HashMap::new(); + for change in &self.removed { + entity_map.insert(change.id.rust_identifier.clone(), change); + } + + // Reverse topological sort (process dependents before dependencies) + fn visit<'a>( + identifier: &str, + entity_map: &HashMap, + all_changes: &[EntityChange], + removed_identifiers: &mut HashSet, + result: &mut Vec<&'a EntityChange>, + ) { + if removed_identifiers.contains(identifier) { + return; + } + + // Find entities that depend on this one + for change in all_changes { + if change.dependencies.contains(&identifier.to_string()) { + visit( + &change.id.rust_identifier, + entity_map, + all_changes, + removed_identifiers, + result, + ); + } + } + + if let Some(change) = entity_map.get(identifier) { + removed_identifiers.insert(identifier.to_string()); + result.push(change); + } + } + + // Visit all entities + for identifier in entity_map.keys() { + visit(identifier, &entity_map, &self.removed, &mut removed_identifiers, &mut result); + } + + result + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::SqlGraphEntity; + use crate::schema::entity::SchemaEntity; + use crate::snapshot_types::SqlGraphEntitySnapshot; + use std::time::SystemTime; + + #[test] + fn test_empty_diff() { + let snapshot1 = SchemaSnapshot { + version: "1.0.0".to_string(), + timestamp: SystemTime::now(), + extension_name: "test".to_string(), + entities: vec![], + dependency_edges: vec![], + versioned_so: false, + }; + + let snapshot2 = snapshot1.clone(); + + let diff = SchemaDiff::compare(&snapshot1, &snapshot2); + + assert_eq!(diff.added.len(), 0); + assert_eq!(diff.removed.len(), 0); + assert_eq!(diff.modified.len(), 0); + assert_eq!(diff.renamed.len(), 0); + } + + #[test] + fn test_addition() { + let snapshot1 = SchemaSnapshot { + version: "1.0.0".to_string(), + timestamp: SystemTime::now(), + extension_name: "test".to_string(), + entities: vec![], + dependency_edges: vec![], + versioned_so: false, + }; + + let schema_entity = SchemaEntity { + module_path: "test::schema", + name: "test_schema", + file: "src/lib.rs", + line: 10, + }; + + let mut snapshot2 = snapshot1.clone(); + snapshot2.version = "1.1.0".to_string(); + snapshot2.entities.push(SerializableEntity { + id: EntityId::from_entity(&SqlGraphEntity::Schema(schema_entity.clone())), + entity: SqlGraphEntitySnapshot::Schema(schema_entity), + node_index: Some(0), + }); + + let diff = SchemaDiff::compare(&snapshot1, &snapshot2); + + assert_eq!(diff.added.len(), 1); + assert_eq!(diff.removed.len(), 0); + assert_eq!(diff.modified.len(), 0); + } +} diff --git a/pgrx-sql-entity-graph/src/extension_sql/entity.rs b/pgrx-sql-entity-graph/src/extension_sql/entity.rs index f86d245bee..bbabddc3fc 100644 --- a/pgrx-sql-entity-graph/src/extension_sql/entity.rs +++ b/pgrx-sql-entity-graph/src/extension_sql/entity.rs @@ -25,13 +25,19 @@ use crate::{SqlGraphEntity, SqlGraphIdentifier}; use std::fmt::Display; /// The output of a [`ExtensionSql`](crate::ExtensionSql) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct ExtensionSqlEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub sql: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, pub bootstrap: bool, pub finalize: bool, @@ -108,7 +114,8 @@ impl ToSql for ExtensionSqlEntity { } } -#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct SqlDeclaredEntityData { sql: String, name: String, @@ -122,7 +129,8 @@ pub struct SqlDeclaredEntityData { varlena: String, pg_box: Vec, } -#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub enum SqlDeclaredEntity { Type(SqlDeclaredEntityData), Enum(SqlDeclaredEntityData), diff --git a/pgrx-sql-entity-graph/src/extern_args.rs b/pgrx-sql-entity-graph/src/extern_args.rs index d00f586a5b..4d6d28fe32 100644 --- a/pgrx-sql-entity-graph/src/extern_args.rs +++ b/pgrx-sql-entity-graph/src/extern_args.rs @@ -12,7 +12,7 @@ use proc_macro2::{TokenStream, TokenTree}; use quote::{ToTokens, TokenStreamExt, format_ident, quote}; use std::collections::HashSet; -#[derive(Debug, Hash, Eq, PartialEq, Clone, PartialOrd, Ord)] +#[derive(Debug, Hash, Eq, PartialEq, Clone, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] pub enum ExternArgs { CreateOrReplace, Immutable, diff --git a/pgrx-sql-entity-graph/src/lib.rs b/pgrx-sql-entity-graph/src/lib.rs index ebe260b278..98c39f92ca 100644 --- a/pgrx-sql-entity-graph/src/lib.rs +++ b/pgrx-sql-entity-graph/src/lib.rs @@ -20,6 +20,7 @@ pub use aggregate::{ AggregateType, AggregateTypeList, FinalizeModify, ParallelOption, PgAggregate, }; pub use control_file::ControlFile; +pub use diff::{EntityChange, EntityModification, EntityRename, SchemaDiff}; pub use enrich::CodeEnrichment; pub use extension_sql::entity::{ExtensionSqlEntity, SqlDeclaredEntity}; pub use extension_sql::{ExtensionSql, ExtensionSqlFile, SqlDeclared}; @@ -45,6 +46,76 @@ pub use postgres_type::PostgresTypeDerive; pub use postgres_type::entity::PostgresTypeEntity; pub use schema::Schema; pub use schema::entity::SchemaEntity; +pub use snapshot::{ + DependencyEdge, EntityId, EntityType, SchemaSnapshot, SerializableEntity, deserialize_snapshot, +}; +pub use snapshot_types::{ + PgAggregateEntitySnapshot, PostgresHashEntitySnapshot, PostgresOrdEntitySnapshot, + SqlGraphEntitySnapshot, +}; +pub use upgrade::{ + UpgradeConfig, generate_upgrade_file, generate_upgrade_script, generate_upgrade_script_with_sql, +}; + +// Marker type for TypeId placeholder value when converting snapshots back to runtime entities. +// +// This type is used ONLY when deserializing snapshot entities back into runtime entities +// (via `From for SqlGraphEntity`). Since snapshots don't contain +// TypeId fields (they're runtime-only), we need a placeholder value for roundtrip compatibility. +// +// This private type ensures the placeholder TypeId cannot collide with any user type. +// +// NOTE: The proper architectural fix has been implemented - snapshots now use separate +// types (SqlGraphEntitySnapshot, etc.) that don't contain TypeId at all. TypeId only +// exists in runtime entity types where it's actually used for runtime type checking. +pub(crate) struct __PgrxInternalTypeIdPlaceholder { + _private: (), +} + +// Helper module for serde deserialization of &'static str +pub(crate) mod serde_helpers { + use serde::{Deserialize, Deserializer}; + + pub fn deserialize_static_str<'de, D>(deserializer: D) -> Result<&'static str, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Box::leak(s.into_boxed_str())) + } + + pub fn deserialize_option_static_str<'de, D>( + deserializer: D, + ) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let opt = Option::::deserialize(deserializer)?; + Ok(opt.map(|s| Box::leak(s.into_boxed_str()) as &'static str)) + } + + pub fn deserialize_vec_static_str<'de, D>( + deserializer: D, + ) -> Result, D::Error> + where + D: Deserializer<'de>, + { + let vec = Vec::::deserialize(deserializer)?; + Ok(vec.into_iter().map(|s| Box::leak(s.into_boxed_str()) as &'static str).collect()) + } + + pub fn deserialize_option_vec_static_str<'de, D>( + deserializer: D, + ) -> Result>, D::Error> + where + D: Deserializer<'de>, + { + let opt = Option::>::deserialize(deserializer)?; + Ok(opt.map(|vec| { + vec.into_iter().map(|s| Box::leak(s.into_boxed_str()) as &'static str).collect() + })) + } +} pub use to_sql::entity::ToSqlConfigEntity; pub use to_sql::{ToSql, ToSqlConfig}; pub use used_type::{UsedType, UsedTypeEntity}; @@ -52,6 +123,7 @@ pub use used_type::{UsedType, UsedTypeEntity}; pub(crate) mod aggregate; pub(crate) mod composite_type; pub(crate) mod control_file; +pub(crate) mod diff; // Snapshot comparison for upgrade scripts pub(crate) mod enrich; pub(crate) mod extension_sql; pub(crate) mod extern_args; @@ -71,7 +143,10 @@ pub(crate) mod postgres_hash; pub(crate) mod postgres_ord; pub(crate) mod postgres_type; pub(crate) mod schema; +pub(crate) mod snapshot; // Snapshot infrastructure for upgrade scripts +pub(crate) mod snapshot_types; // Snapshot-only types without TypeId pub(crate) mod to_sql; +pub(crate) mod upgrade; // SQL upgrade script generation pub(crate) mod used_type; /// Able to produce a GraphViz DOT format identifier. @@ -97,7 +172,8 @@ pub trait SqlGraphIdentifier { pub use postgres_type::Alignment; /// An entity corresponding to some SQL required by the extension. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = "'de: 'static"))] pub enum SqlGraphEntity { ExtensionRoot(ControlFile), Schema(SchemaEntity), diff --git a/pgrx-sql-entity-graph/src/mapping.rs b/pgrx-sql-entity-graph/src/mapping.rs index f7eb27bdff..cdd7d87593 100644 --- a/pgrx-sql-entity-graph/src/mapping.rs +++ b/pgrx-sql-entity-graph/src/mapping.rs @@ -31,14 +31,19 @@ use core::any::TypeId; /// /// assert_eq!(constructed, raw); /// ``` -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] pub struct RustSqlMapping { // This is the **resolved** type, not the raw source. This means a Type Alias of `type Foo = u32` would appear as `u32`. pub rust: String, pub sql: String, + #[serde(skip, default = "default_type_id")] pub id: TypeId, } +fn default_type_id() -> TypeId { + TypeId::of::() +} + impl RustSqlMapping { pub fn of(sql: String) -> Self { Self { diff --git a/pgrx-sql-entity-graph/src/metadata/entity.rs b/pgrx-sql-entity-graph/src/metadata/entity.rs index 2bd59c2852..57c487cf5e 100644 --- a/pgrx-sql-entity-graph/src/metadata/entity.rs +++ b/pgrx-sql-entity-graph/src/metadata/entity.rs @@ -18,15 +18,19 @@ Function and type level metadata entities for Rust to SQL translation */ use super::{ArgumentError, Returns, ReturnsError, SqlMapping}; -#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct FunctionMetadataEntity { pub arguments: Vec, pub retval: FunctionMetadataTypeEntity, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub path: &'static str, } -#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct FunctionMetadataTypeEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub type_name: &'static str, pub argument_sql: Result, pub return_sql: Result, diff --git a/pgrx-sql-entity-graph/src/metadata/return_variant.rs b/pgrx-sql-entity-graph/src/metadata/return_variant.rs index 958dfc4ab8..4ec05de28d 100644 --- a/pgrx-sql-entity-graph/src/metadata/return_variant.rs +++ b/pgrx-sql-entity-graph/src/metadata/return_variant.rs @@ -22,14 +22,28 @@ use super::sql_translatable::SqlMapping; /// Describes the RETURNS of CREATE FUNCTION ... RETURNS ... /// See the PostgreSQL documentation for [CREATE FUNCTION] /// [CREATE FUNCTION]: -#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub enum Returns { One(SqlMapping), SetOf(SqlMapping), Table(Vec), } -#[derive(Clone, Copy, Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Error)] +#[derive( + Clone, + Copy, + Debug, + Hash, + Ord, + PartialOrd, + PartialEq, + Eq, + Error, + serde::Serialize, + serde::Deserialize +)] +#[serde(bound(deserialize = ""))] pub enum ReturnsError { #[error("Nested SetOfIterator in return type")] NestedSetOf, diff --git a/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs b/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs index 49ec4a5bfb..af820a7c94 100644 --- a/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs +++ b/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs @@ -23,7 +23,20 @@ use thiserror::Error; use super::return_variant::ReturnsError; use super::{FunctionMetadataTypeEntity, Returns}; -#[derive(Clone, Copy, Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Error)] +#[derive( + Clone, + Copy, + Debug, + Hash, + Ord, + PartialOrd, + PartialEq, + Eq, + Error, + serde::Serialize, + serde::Deserialize +)] +#[serde(bound(deserialize = ""))] pub enum ArgumentError { #[error("Cannot use SetOfIterator as an argument")] SetOf, @@ -36,11 +49,14 @@ pub enum ArgumentError { #[error("A Datum as an argument means that `sql = \"...\"` must be set in the declaration")] Datum, #[error("`{0}` is not able to be used as a function argument")] - NotValidAsArgument(&'static str), + NotValidAsArgument( + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] &'static str, + ), } /// Describes ways that Rust types are mapped into SQL -#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub enum SqlMapping { /// Explicit mappings provided by PGRX As(String), diff --git a/pgrx-sql-entity-graph/src/pg_extern/entity/argument.rs b/pgrx-sql-entity-graph/src/pg_extern/entity/argument.rs index c5848da6a5..0d8f6488a7 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/entity/argument.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/entity/argument.rs @@ -18,8 +18,10 @@ use crate::{SqlGraphIdentifier, UsedTypeEntity}; /// The output of a [`PgExternArgument`](crate::PgExternArgument) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgExternArgumentEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub pattern: &'static str, pub used_ty: UsedTypeEntity, } diff --git a/pgrx-sql-entity-graph/src/pg_extern/entity/cast.rs b/pgrx-sql-entity-graph/src/pg_extern/entity/cast.rs index 0ad15d9700..896d947d75 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/entity/cast.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/entity/cast.rs @@ -17,7 +17,7 @@ */ /// The output of a [`PgCast`](crate::PgCast) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] pub enum PgCastEntity { Default, Assignment, diff --git a/pgrx-sql-entity-graph/src/pg_extern/entity/mod.rs b/pgrx-sql-entity-graph/src/pg_extern/entity/mod.rs index 3f121b8133..23c2b629fc 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/entity/mod.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/entity/mod.rs @@ -35,19 +35,27 @@ use crate::{ExternArgs, SqlGraphEntity, SqlGraphIdentifier, TypeMatch}; use eyre::{WrapErr, eyre}; /// The output of a [`PgExtern`](crate::pg_extern::PgExtern) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgExternEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub unaliased_name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, pub metadata: crate::metadata::FunctionMetadataEntity, pub fn_args: Vec, pub fn_return: PgExternReturnEntity, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub schema: Option<&'static str>, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, pub extern_attrs: Vec, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_vec_static_str")] pub search_path: Option>, pub operator: Option, pub cast: Option, diff --git a/pgrx-sql-entity-graph/src/pg_extern/entity/operator.rs b/pgrx-sql-entity-graph/src/pg_extern/entity/operator.rs index 97bfd3c23d..f2914432d5 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/entity/operator.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/entity/operator.rs @@ -17,12 +17,18 @@ */ /// The output of a [`PgOperator`](crate::PgOperator) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgOperatorEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub opname: Option<&'static str>, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub commutator: Option<&'static str>, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub negator: Option<&'static str>, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub restrict: Option<&'static str>, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub join: Option<&'static str>, pub hashes: bool, pub merges: bool, diff --git a/pgrx-sql-entity-graph/src/pg_extern/entity/returning.rs b/pgrx-sql-entity-graph/src/pg_extern/entity/returning.rs index 33e33e7e99..68eba282b5 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/entity/returning.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/entity/returning.rs @@ -17,7 +17,8 @@ */ use crate::UsedTypeEntity; -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = "'de: 'static"))] pub enum PgExternReturnEntity { None, Type { ty: UsedTypeEntity }, @@ -26,8 +27,10 @@ pub enum PgExternReturnEntity { Trigger, } -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgExternReturnEntityIteratedItem { pub ty: UsedTypeEntity, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub name: Option<&'static str>, } diff --git a/pgrx-sql-entity-graph/src/pg_trigger/entity.rs b/pgrx-sql-entity-graph/src/pg_trigger/entity.rs index 98d41d6031..02658c3913 100644 --- a/pgrx-sql-entity-graph/src/pg_trigger/entity.rs +++ b/pgrx-sql-entity-graph/src/pg_trigger/entity.rs @@ -17,13 +17,18 @@ */ use crate::{PgrxSql, SqlGraphEntity, SqlGraphIdentifier, ToSql, ToSqlConfigEntity}; -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PgTriggerEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub function_name: &'static str, pub to_sql_config: ToSqlConfigEntity, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, } diff --git a/pgrx-sql-entity-graph/src/pgrx_sql.rs b/pgrx-sql-entity-graph/src/pgrx_sql.rs index e3d412d481..0dc55f0ee2 100644 --- a/pgrx-sql-entity-graph/src/pgrx_sql.rs +++ b/pgrx-sql-entity-graph/src/pgrx_sql.rs @@ -43,7 +43,7 @@ use crate::{SqlGraphEntity, SqlGraphIdentifier, TypeMatch}; use super::{PgExternReturnEntity, PgExternReturnEntityIteratedItem}; -#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord)] +#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, serde::Serialize, serde::Deserialize)] pub enum SqlGraphRequires { By, ByArg, diff --git a/pgrx-sql-entity-graph/src/positioning_ref.rs b/pgrx-sql-entity-graph/src/positioning_ref.rs index 6f568958c4..e8ab9e0546 100644 --- a/pgrx-sql-entity-graph/src/positioning_ref.rs +++ b/pgrx-sql-entity-graph/src/positioning_ref.rs @@ -19,7 +19,7 @@ use quote::{ToTokens, quote}; use std::fmt::Display; use syn::parse::{Parse, ParseStream}; -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] pub enum PositioningRef { FullPath(String), Name(String), diff --git a/pgrx-sql-entity-graph/src/postgres_enum/entity.rs b/pgrx-sql-entity-graph/src/postgres_enum/entity.rs index b3dd18ee7b..516016ceeb 100644 --- a/pgrx-sql-entity-graph/src/postgres_enum/entity.rs +++ b/pgrx-sql-entity-graph/src/postgres_enum/entity.rs @@ -23,14 +23,20 @@ use crate::{SqlGraphEntity, SqlGraphIdentifier, TypeMatch}; use std::collections::BTreeSet; /// The output of a [`PostgresEnum`](crate::postgres_enum::PostgresEnum) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)] +#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PostgresEnumEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, pub mappings: BTreeSet, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_vec_static_str")] pub variants: Vec<&'static str>, pub to_sql_config: ToSqlConfigEntity, } diff --git a/pgrx-sql-entity-graph/src/postgres_hash/entity.rs b/pgrx-sql-entity-graph/src/postgres_hash/entity.rs index b98f146ae2..70604e5523 100644 --- a/pgrx-sql-entity-graph/src/postgres_hash/entity.rs +++ b/pgrx-sql-entity-graph/src/postgres_hash/entity.rs @@ -21,17 +21,27 @@ use crate::to_sql::entity::ToSqlConfigEntity; use crate::{SqlGraphEntity, SqlGraphIdentifier}; /// The output of a [`PostgresHash`](crate::postgres_hash::PostgresHash) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PostgresHashEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(skip, default = "default_type_id")] pub id: core::any::TypeId, pub to_sql_config: ToSqlConfigEntity, } +fn default_type_id() -> core::any::TypeId { + core::any::TypeId::of::() +} + impl PostgresHashEntity { pub(crate) fn fn_name(&self) -> String { format!("{}_hash", self.name.to_lowercase()) diff --git a/pgrx-sql-entity-graph/src/postgres_ord/entity.rs b/pgrx-sql-entity-graph/src/postgres_ord/entity.rs index 7601cdd9b1..2751f846ec 100644 --- a/pgrx-sql-entity-graph/src/postgres_ord/entity.rs +++ b/pgrx-sql-entity-graph/src/postgres_ord/entity.rs @@ -21,17 +21,27 @@ use crate::to_sql::entity::ToSqlConfigEntity; use crate::{SqlGraphEntity, SqlGraphIdentifier}; /// The output of a [`PostgresOrd`](crate::postgres_ord::PostgresOrd) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PostgresOrdEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(skip, default = "default_type_id")] pub id: core::any::TypeId, pub to_sql_config: ToSqlConfigEntity, } +fn default_type_id() -> core::any::TypeId { + core::any::TypeId::of::() +} + impl PostgresOrdEntity { pub(crate) fn cmp_fn_name(&self) -> String { format!("{}_cmp", self.name.to_lowercase()) diff --git a/pgrx-sql-entity-graph/src/postgres_type/entity.rs b/pgrx-sql-entity-graph/src/postgres_type/entity.rs index 8207c63587..d4332868e0 100644 --- a/pgrx-sql-entity-graph/src/postgres_type/entity.rs +++ b/pgrx-sql-entity-graph/src/postgres_type/entity.rs @@ -28,7 +28,8 @@ use std::collections::BTreeSet; use syn::spanned::Spanned; use syn::{AttrStyle, Attribute, Lit}; -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub enum Alignment { On, Off, @@ -93,20 +94,29 @@ impl Alignment { } /// The output of a [`PostgresType`](crate::postgres_type::PostgresTypeDerive) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct PostgresTypeEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, pub mappings: BTreeSet, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub in_fn: &'static str, pub in_fn_module_path: String, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub out_fn: &'static str, pub out_fn_module_path: String, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub receive_fn: Option<&'static str>, pub receive_fn_module_path: Option, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub send_fn: Option<&'static str>, pub send_fn_module_path: Option, pub to_sql_config: ToSqlConfigEntity, diff --git a/pgrx-sql-entity-graph/src/schema/entity.rs b/pgrx-sql-entity-graph/src/schema/entity.rs index 7244ef39a5..899285a785 100644 --- a/pgrx-sql-entity-graph/src/schema/entity.rs +++ b/pgrx-sql-entity-graph/src/schema/entity.rs @@ -20,10 +20,14 @@ use crate::to_sql::ToSql; use crate::{SqlGraphEntity, SqlGraphIdentifier}; /// The output of a [`Schema`](crate::schema::Schema) from `quote::ToTokens::to_tokens`. -#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct SchemaEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub file: &'static str, pub line: u32, } diff --git a/pgrx-sql-entity-graph/src/snapshot.rs b/pgrx-sql-entity-graph/src/snapshot.rs new file mode 100644 index 0000000000..fa72a748e3 --- /dev/null +++ b/pgrx-sql-entity-graph/src/snapshot.rs @@ -0,0 +1,293 @@ +//LICENSE Portions Copyright 2019-2021 ZomboDB, LLC. +//LICENSE +//LICENSE Portions Copyright 2021-2023 Technology Concepts & Design, Inc. +//LICENSE +//LICENSE Portions Copyright 2023-2023 PgCentral Foundation, Inc. +//LICENSE +//LICENSE All rights reserved. +//LICENSE +//LICENSE Use of this source code is governed by the MIT license that can be found in the LICENSE file. + +//! Schema snapshot infrastructure for automatic upgrade script generation. +//! +//! This module provides data structures and functionality for: +//! - Capturing the current state of a pgrx extension schema +//! - Serializing/deserializing schema snapshots to/from JSON +//! - Comparing snapshots to detect changes between versions + +use crate::pgrx_sql::SqlGraphRequires; +use crate::snapshot_types::SqlGraphEntitySnapshot; +use crate::{PgrxSql, SqlGraphEntity}; +use petgraph::visit::{EdgeRef, IntoEdgeReferences}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::fs; +use std::path::Path; +use std::time::SystemTime; + +/// A snapshot of an extension's schema at a specific version. +/// +/// This captures all SQL entities and their dependencies, +/// allowing for comparison between different versions to +/// generate upgrade scripts. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(bound(deserialize = "'de: 'static"))] +pub struct SchemaSnapshot { + /// The extension version this snapshot represents + pub version: String, + + /// When this snapshot was created + #[serde(with = "systemtime_serde")] + pub timestamp: SystemTime, + + /// The extension name + pub extension_name: String, + + /// All entities in the schema + pub entities: Vec, + + /// Dependency edges between entities + pub dependency_edges: Vec, + + /// Whether the extension uses versioned shared objects + pub versioned_so: bool, +} + +/// A single entity with its identifier and SQL graph data. +/// +/// Note: This uses [`SqlGraphEntitySnapshot`] which excludes TypeId fields, +/// as TypeId values are not stable across compilations. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(bound(deserialize = "'de: 'static"))] +pub struct SerializableEntity { + /// Unique identifier for this entity + pub id: EntityId, + + /// The entity data (snapshot version without TypeId) + pub entity: SqlGraphEntitySnapshot, + + /// Node index in the original graph (for debugging) + #[serde(skip)] + pub node_index: Option, +} + +/// Unique identifier for an entity +#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)] +pub struct EntityId { + /// The type of entity (Function, Type, Enum, etc.) + pub entity_type: EntityType, + + /// The Rust identifier (module::path::name) + pub rust_identifier: String, + + /// Hash of the entity's signature (for fuzzy matching during renames) + pub signature_hash: String, +} + +/// Entity type discriminator +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Serialize, Deserialize)] +pub enum EntityType { + ExtensionRoot, + Schema, + CustomSql, + Function, + Type, + BuiltinType, + Enum, + Ord, + Hash, + Aggregate, + Trigger, +} + +/// A dependency edge between two entities +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DependencyEdge { + /// The depending entity (source) + pub from: String, // rust_identifier + + /// The dependency target + pub to: String, // rust_identifier + + /// The type of dependency + pub requires: SqlGraphRequires, +} + +/// Deserialize a SchemaSnapshot from a JSON string. +/// +/// This is a helper function to avoid exposing serde_json directly in generated code. +/// Note: The JSON string must have a 'static lifetime because SchemaSnapshot contains +/// &'static str fields that will be leaked from the deserialized strings. +pub fn deserialize_snapshot(json: &'static str) -> Result { + serde_json::from_str(json) +} + +impl SchemaSnapshot { + /// Create a snapshot from a PgrxSql graph + pub fn from_pgrx_sql(pgrx_sql: &PgrxSql) -> Self { + let mut entities = Vec::new(); + let mut dependency_edges = Vec::new(); + + // Collect all entities from the graph, converting to snapshot versions + for node_idx in pgrx_sql.graph.node_indices() { + let entity = &pgrx_sql.graph[node_idx]; + let id = EntityId::from_entity(entity); + + entities.push(SerializableEntity { + id, + entity: SqlGraphEntitySnapshot::from(entity), + node_index: Some(node_idx.index()), + }); + } + + // Collect all dependency edges + for edge in pgrx_sql.graph.edge_references() { + let from_entity = &pgrx_sql.graph[edge.source()]; + let to_entity = &pgrx_sql.graph[edge.target()]; + let from_id = EntityId::from_entity(from_entity); + let to_id = EntityId::from_entity(to_entity); + + dependency_edges.push(DependencyEdge { + from: from_id.rust_identifier.clone(), + to: to_id.rust_identifier.clone(), + requires: *edge.weight(), + }); + } + + SchemaSnapshot { + version: pgrx_sql.control.default_version.clone(), + timestamp: SystemTime::now(), + extension_name: pgrx_sql.extension_name.clone(), + entities, + dependency_edges, + versioned_so: pgrx_sql.versioned_so, + } + } + + /// Save the snapshot to a JSON file + pub fn save(&self, path: &Path) -> eyre::Result<()> { + // Ensure parent directory exists + if let Some(parent) = path.parent() { + fs::create_dir_all(parent)?; + } + + let json = serde_json::to_string_pretty(self)?; + fs::write(path, json)?; + Ok(()) + } + + /// Load a snapshot from a JSON file + /// + /// Note: This currently loads as JSON Value for comparison purposes. + /// Full deserialization with proper lifetimes will be implemented in Phase 3. + pub fn load_json(path: &Path) -> eyre::Result { + let json = fs::read_to_string(path)?; + let value: serde_json::Value = serde_json::from_str(&json)?; + Ok(value) + } + + /// Get an entity by its identifier + pub fn get_entity(&self, id: &EntityId) -> Option<&SerializableEntity> { + self.entities.iter().find(|e| &e.id == id) + } + + /// Build an index of entities by rust_identifier for fast lookup + pub fn build_entity_index(&self) -> HashMap { + self.entities.iter().map(|e| (e.id.rust_identifier.clone(), e)).collect() + } +} + +impl EntityId { + /// Create an EntityId from a SqlGraphEntity + pub fn from_entity(entity: &SqlGraphEntity) -> Self { + use crate::SqlGraphIdentifier; + + let entity_type = EntityType::from_entity(entity); + let rust_identifier = entity.rust_identifier(); + let signature_hash = Self::compute_signature_hash(entity); + + EntityId { entity_type, rust_identifier, signature_hash } + } + + /// Compute a hash of the entity's signature for fuzzy matching + fn compute_signature_hash(entity: &SqlGraphEntity) -> String { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + let mut hasher = DefaultHasher::new(); + + // Hash the entity itself (it implements Hash) + entity.hash(&mut hasher); + + format!("{:x}", hasher.finish()) + } +} + +impl EntityType { + /// Get the entity type from a SqlGraphEntity + pub fn from_entity(entity: &SqlGraphEntity) -> Self { + match entity { + SqlGraphEntity::ExtensionRoot(_) => EntityType::ExtensionRoot, + SqlGraphEntity::Schema(_) => EntityType::Schema, + SqlGraphEntity::CustomSql(_) => EntityType::CustomSql, + SqlGraphEntity::Function(_) => EntityType::Function, + SqlGraphEntity::Type(_) => EntityType::Type, + SqlGraphEntity::BuiltinType(_) => EntityType::BuiltinType, + SqlGraphEntity::Enum(_) => EntityType::Enum, + SqlGraphEntity::Ord(_) => EntityType::Ord, + SqlGraphEntity::Hash(_) => EntityType::Hash, + SqlGraphEntity::Aggregate(_) => EntityType::Aggregate, + SqlGraphEntity::Trigger(_) => EntityType::Trigger, + } + } +} + +// Custom serialization for SystemTime +mod systemtime_serde { + use serde::{Deserialize, Deserializer, Serialize, Serializer}; + use std::time::{SystemTime, UNIX_EPOCH}; + + pub fn serialize(time: &SystemTime, serializer: S) -> Result + where + S: Serializer, + { + let duration = time.duration_since(UNIX_EPOCH).map_err(serde::ser::Error::custom)?; + duration.as_secs().serialize(serializer) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let secs = u64::deserialize(deserializer)?; + Ok(UNIX_EPOCH + std::time::Duration::from_secs(secs)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_entity_id_equality() { + use crate::control_file::ControlFile; + + let control = ControlFile { + comment: "Test extension".to_string(), + default_version: "0.1.0".to_string(), + module_pathname: None, + relocatable: false, + superuser: false, + schema: None, + trusted: false, + }; + + let entity1 = SqlGraphEntity::ExtensionRoot(control.clone()); + let entity2 = SqlGraphEntity::ExtensionRoot(control); + + let id1 = EntityId::from_entity(&entity1); + let id2 = EntityId::from_entity(&entity2); + + assert_eq!(id1, id2); + } +} diff --git a/pgrx-sql-entity-graph/src/snapshot_types.rs b/pgrx-sql-entity-graph/src/snapshot_types.rs new file mode 100644 index 0000000000..bc4cd24fc2 --- /dev/null +++ b/pgrx-sql-entity-graph/src/snapshot_types.rs @@ -0,0 +1,356 @@ +//LICENSE Portions Copyright 2019-2021 ZomboDB, LLC. +//LICENSE +//LICENSE Portions Copyright 2021-2023 Technology Concepts & Design, Inc. +//LICENSE +//LICENSE Portions Copyright 2023-2023 PgCentral Foundation, Inc. +//LICENSE +//LICENSE All rights reserved. +//LICENSE +//LICENSE Use of this source code is governed by the MIT license that can be found in the LICENSE file. + +//! Snapshot-only versions of entity types for serialization. +//! +//! This module contains stripped-down versions of entity types that remove +//! TypeId fields, which are not stable across compilations and should not +//! be serialized. These types are used ONLY for snapshot serialization and +//! comparison, while the original types (with TypeId) are used at runtime. + +use crate::aggregate::entity::AggregateTypeEntity; +use crate::control_file::ControlFile; +use crate::extension_sql::entity::ExtensionSqlEntity; +use crate::pg_extern::entity::PgExternEntity; +use crate::pg_trigger::entity::PgTriggerEntity; +use crate::postgres_enum::entity::PostgresEnumEntity; +use crate::postgres_type::entity::PostgresTypeEntity; +use crate::schema::entity::SchemaEntity; +use crate::to_sql::entity::ToSqlConfigEntity; +use crate::{FinalizeModify, ParallelOption, SqlGraphEntity, UsedTypeEntity}; + +/// Snapshot version of [`crate::postgres_hash::entity::PostgresHashEntity`] without TypeId. +#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] +pub struct PostgresHashEntitySnapshot { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub file: &'static str, + pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub module_path: &'static str, + // Note: `id: TypeId` field is omitted - not needed for snapshots + pub to_sql_config: ToSqlConfigEntity, +} + +/// Snapshot version of [`crate::postgres_ord::entity::PostgresOrdEntity`] without TypeId. +#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] +pub struct PostgresOrdEntitySnapshot { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub name: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub file: &'static str, + pub line: u32, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub module_path: &'static str, + // Note: `id: TypeId` field is omitted - not needed for snapshots + pub to_sql_config: ToSqlConfigEntity, +} + +/// Snapshot version of [`crate::aggregate::entity::PgAggregateEntity`] without TypeId. +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] +pub struct PgAggregateEntitySnapshot { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub full_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub module_path: &'static str, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub file: &'static str, + pub line: u32, + // Note: `ty_id: TypeId` field is omitted - not needed for snapshots + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub name: &'static str, + + pub ordered_set: bool, + pub args: Vec, + pub direct_args: Option>, + pub stype: AggregateTypeEntity, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] + pub sfunc: &'static str, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub finalfunc: Option<&'static str>, + + pub finalfunc_modify: Option, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub combinefunc: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub serialfunc: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub deserialfunc: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub initcond: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub msfunc: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub minvfunc: Option<&'static str>, + + pub mstype: Option, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub mfinalfunc: Option<&'static str>, + + pub mfinalfunc_modify: Option, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub minitcond: Option<&'static str>, + + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] + pub sortop: Option<&'static str>, + + pub hypothetical: bool, + pub parallel: Option, + pub to_sql_config: ToSqlConfigEntity, +} + +/// Snapshot version of [`SqlGraphEntity`] for serialization without TypeId fields. +/// +/// This enum mirrors [`SqlGraphEntity`] but uses snapshot versions for variants +/// that contain TypeId fields (Ord, Hash, Aggregate). +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = "'de: 'static"))] +pub enum SqlGraphEntitySnapshot { + ExtensionRoot(ControlFile), + Schema(SchemaEntity), + CustomSql(ExtensionSqlEntity), + Function(PgExternEntity), + Type(PostgresTypeEntity), + BuiltinType(String), + Enum(PostgresEnumEntity), + Ord(PostgresOrdEntitySnapshot), + Hash(PostgresHashEntitySnapshot), + Aggregate(PgAggregateEntitySnapshot), + Trigger(PgTriggerEntity), +} + +/// Convert a runtime entity to its snapshot version (without TypeId). +impl From<&SqlGraphEntity> for SqlGraphEntitySnapshot { + fn from(entity: &SqlGraphEntity) -> Self { + match entity { + SqlGraphEntity::ExtensionRoot(e) => SqlGraphEntitySnapshot::ExtensionRoot(e.clone()), + SqlGraphEntity::Schema(e) => SqlGraphEntitySnapshot::Schema(e.clone()), + SqlGraphEntity::CustomSql(e) => SqlGraphEntitySnapshot::CustomSql(e.clone()), + SqlGraphEntity::Function(e) => SqlGraphEntitySnapshot::Function(e.clone()), + SqlGraphEntity::Type(e) => SqlGraphEntitySnapshot::Type(e.clone()), + SqlGraphEntity::BuiltinType(e) => SqlGraphEntitySnapshot::BuiltinType(e.clone()), + SqlGraphEntity::Enum(e) => SqlGraphEntitySnapshot::Enum(e.clone()), + + // These three need conversion to remove TypeId + SqlGraphEntity::Ord(e) => SqlGraphEntitySnapshot::Ord(PostgresOrdEntitySnapshot { + name: e.name, + file: e.file, + line: e.line, + full_path: e.full_path, + module_path: e.module_path, + to_sql_config: e.to_sql_config.clone(), + }), + + SqlGraphEntity::Hash(e) => SqlGraphEntitySnapshot::Hash(PostgresHashEntitySnapshot { + name: e.name, + file: e.file, + line: e.line, + full_path: e.full_path, + module_path: e.module_path, + to_sql_config: e.to_sql_config.clone(), + }), + + SqlGraphEntity::Aggregate(e) => { + SqlGraphEntitySnapshot::Aggregate(PgAggregateEntitySnapshot { + full_path: e.full_path, + module_path: e.module_path, + file: e.file, + line: e.line, + name: e.name, + ordered_set: e.ordered_set, + args: e.args.clone(), + direct_args: e.direct_args.clone(), + stype: e.stype.clone(), + sfunc: e.sfunc, + finalfunc: e.finalfunc, + finalfunc_modify: e.finalfunc_modify, + combinefunc: e.combinefunc, + serialfunc: e.serialfunc, + deserialfunc: e.deserialfunc, + initcond: e.initcond, + msfunc: e.msfunc, + minvfunc: e.minvfunc, + mstype: e.mstype.clone(), + mfinalfunc: e.mfinalfunc, + mfinalfunc_modify: e.mfinalfunc_modify, + minitcond: e.minitcond, + sortop: e.sortop, + hypothetical: e.hypothetical, + parallel: e.parallel, + to_sql_config: e.to_sql_config.clone(), + }) + } + + SqlGraphEntity::Trigger(e) => SqlGraphEntitySnapshot::Trigger(e.clone()), + } + } +} + +/// Convert snapshot back to runtime entity (TypeId will have placeholder value). +/// +/// Note: The TypeId fields in the returned entities will have placeholder values +/// and should not be used for runtime type checking. This is only for roundtrip +/// compatibility. +impl From for SqlGraphEntity { + fn from(snapshot: SqlGraphEntitySnapshot) -> Self { + match snapshot { + SqlGraphEntitySnapshot::ExtensionRoot(e) => SqlGraphEntity::ExtensionRoot(e), + SqlGraphEntitySnapshot::Schema(e) => SqlGraphEntity::Schema(e), + SqlGraphEntitySnapshot::CustomSql(e) => SqlGraphEntity::CustomSql(e), + SqlGraphEntitySnapshot::Function(e) => SqlGraphEntity::Function(e), + SqlGraphEntitySnapshot::Type(e) => SqlGraphEntity::Type(e), + SqlGraphEntitySnapshot::BuiltinType(e) => SqlGraphEntity::BuiltinType(e), + SqlGraphEntitySnapshot::Enum(e) => SqlGraphEntity::Enum(e), + + SqlGraphEntitySnapshot::Ord(e) => { + SqlGraphEntity::Ord(crate::postgres_ord::entity::PostgresOrdEntity { + name: e.name, + file: e.file, + line: e.line, + full_path: e.full_path, + module_path: e.module_path, + id: core::any::TypeId::of::(), + to_sql_config: e.to_sql_config, + }) + } + + SqlGraphEntitySnapshot::Hash(e) => { + SqlGraphEntity::Hash(crate::postgres_hash::entity::PostgresHashEntity { + name: e.name, + file: e.file, + line: e.line, + full_path: e.full_path, + module_path: e.module_path, + id: core::any::TypeId::of::(), + to_sql_config: e.to_sql_config, + }) + } + + SqlGraphEntitySnapshot::Aggregate(e) => { + SqlGraphEntity::Aggregate(crate::aggregate::entity::PgAggregateEntity { + full_path: e.full_path, + module_path: e.module_path, + file: e.file, + line: e.line, + ty_id: core::any::TypeId::of::(), + name: e.name, + ordered_set: e.ordered_set, + args: e.args, + direct_args: e.direct_args, + stype: e.stype, + sfunc: e.sfunc, + finalfunc: e.finalfunc, + finalfunc_modify: e.finalfunc_modify, + combinefunc: e.combinefunc, + serialfunc: e.serialfunc, + deserialfunc: e.deserialfunc, + initcond: e.initcond, + msfunc: e.msfunc, + minvfunc: e.minvfunc, + mstype: e.mstype, + mfinalfunc: e.mfinalfunc, + mfinalfunc_modify: e.mfinalfunc_modify, + minitcond: e.minitcond, + sortop: e.sortop, + hypothetical: e.hypothetical, + parallel: e.parallel, + to_sql_config: e.to_sql_config, + }) + } + + SqlGraphEntitySnapshot::Trigger(e) => SqlGraphEntity::Trigger(e), + } + } +} + +/// Implement SqlGraphIdentifier for SqlGraphEntitySnapshot +impl crate::SqlGraphIdentifier for SqlGraphEntitySnapshot { + fn dot_identifier(&self) -> String { + match self { + SqlGraphEntitySnapshot::ExtensionRoot(_) => "root".to_string(), + SqlGraphEntitySnapshot::Schema(e) => format!("schema {}", e.name), + SqlGraphEntitySnapshot::CustomSql(e) => format!("custom_sql {}:{}", e.file, e.line), + SqlGraphEntitySnapshot::Function(e) => format!("fn {}", e.name), + SqlGraphEntitySnapshot::Type(e) => format!("type {}", e.name), + SqlGraphEntitySnapshot::BuiltinType(e) => format!("builtin {}", e), + SqlGraphEntitySnapshot::Enum(e) => format!("enum {}", e.name), + SqlGraphEntitySnapshot::Ord(e) => format!("ord {}", e.name), + SqlGraphEntitySnapshot::Hash(e) => format!("hash {}", e.name), + SqlGraphEntitySnapshot::Aggregate(e) => format!("aggregate {}", e.name), + SqlGraphEntitySnapshot::Trigger(e) => format!("trigger {}", e.function_name), + } + } + + fn rust_identifier(&self) -> String { + match self { + SqlGraphEntitySnapshot::ExtensionRoot(_) => "extension_root".to_string(), + SqlGraphEntitySnapshot::Schema(e) => e.module_path.to_string(), + SqlGraphEntitySnapshot::CustomSql(e) => format!("{}::{}", e.file, e.line), + SqlGraphEntitySnapshot::Function(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::Type(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::BuiltinType(e) => e.clone(), + SqlGraphEntitySnapshot::Enum(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::Ord(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::Hash(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::Aggregate(e) => e.full_path.to_string(), + SqlGraphEntitySnapshot::Trigger(e) => e.module_path.to_string(), + } + } + + fn file(&self) -> Option<&'static str> { + match self { + SqlGraphEntitySnapshot::ExtensionRoot(_) => None, + SqlGraphEntitySnapshot::Schema(e) => Some(e.file), + SqlGraphEntitySnapshot::CustomSql(e) => Some(e.file), + SqlGraphEntitySnapshot::Function(e) => Some(e.file), + SqlGraphEntitySnapshot::Type(e) => Some(e.file), + SqlGraphEntitySnapshot::BuiltinType(_) => None, + SqlGraphEntitySnapshot::Enum(e) => Some(e.file), + SqlGraphEntitySnapshot::Ord(e) => Some(e.file), + SqlGraphEntitySnapshot::Hash(e) => Some(e.file), + SqlGraphEntitySnapshot::Aggregate(e) => Some(e.file), + SqlGraphEntitySnapshot::Trigger(e) => Some(e.file), + } + } + + fn line(&self) -> Option { + match self { + SqlGraphEntitySnapshot::ExtensionRoot(_) => None, + SqlGraphEntitySnapshot::Schema(e) => Some(e.line), + SqlGraphEntitySnapshot::CustomSql(e) => Some(e.line), + SqlGraphEntitySnapshot::Function(e) => Some(e.line), + SqlGraphEntitySnapshot::Type(e) => Some(e.line), + SqlGraphEntitySnapshot::BuiltinType(_) => None, + SqlGraphEntitySnapshot::Enum(e) => Some(e.line), + SqlGraphEntitySnapshot::Ord(e) => Some(e.line), + SqlGraphEntitySnapshot::Hash(e) => Some(e.line), + SqlGraphEntitySnapshot::Aggregate(e) => Some(e.line), + SqlGraphEntitySnapshot::Trigger(e) => Some(e.line), + } + } +} diff --git a/pgrx-sql-entity-graph/src/to_sql/entity.rs b/pgrx-sql-entity-graph/src/to_sql/entity.rs index 30f5564df8..ae955a8dad 100644 --- a/pgrx-sql-entity-graph/src/to_sql/entity.rs +++ b/pgrx-sql-entity-graph/src/to_sql/entity.rs @@ -33,10 +33,13 @@ use crate::to_sql::ToSqlFn; /// /// When `callback` has a value, the corresponding `ToSql` implementation should invoke the /// callback instead of performing their default behavior. -#[derive(Default, Clone)] +#[derive(Default, Clone, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct ToSqlConfigEntity { pub enabled: bool, + #[serde(skip)] pub callback: Option, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub content: Option<&'static str>, } impl ToSqlConfigEntity { diff --git a/pgrx-sql-entity-graph/src/upgrade.rs b/pgrx-sql-entity-graph/src/upgrade.rs new file mode 100644 index 0000000000..9c6f467ddc --- /dev/null +++ b/pgrx-sql-entity-graph/src/upgrade.rs @@ -0,0 +1,825 @@ +//LICENSE Portions Copyright 2019-2021 ZomboDB, LLC. +//LICENSE +//LICENSE Portions Copyright 2021-2023 Technology Concepts & Design, Inc. +//LICENSE +//LICENSE Portions Copyright 2023-2023 PgCentral Foundation, Inc. +//LICENSE +//LICENSE All rights reserved. +//LICENSE +//LICENSE Use of this source code is governed by the MIT license that can be found in the LICENSE file. + +//! SQL upgrade script generation from schema diffs. +//! +//! This module takes a SchemaDiff and generates PostgreSQL SQL statements +//! to upgrade from one version to another. + +use crate::SqlGraphIdentifier; +use crate::diff::{EntityChange, EntityModification, EntityRename, SchemaDiff}; +use crate::metadata::SqlMapping; +use crate::pg_extern::entity::PgExternEntity; +use crate::pgrx_sql::PgrxSql; +use crate::snapshot_types::SqlGraphEntitySnapshot; +use crate::to_sql::ToSql; +use std::fmt::Write as FmtWrite; + +type Result = std::result::Result; + +/// Generate the argument type list from metadata only (for removed functions). +/// This doesn't require the PgrxSql context, so it works for entities that no longer exist. +fn generate_function_arg_types_from_metadata(func: &PgExternEntity) -> String { + if func.fn_args.is_empty() { + return String::new(); + } + + let mut arg_types = Vec::new(); + + for (idx, _arg) in func.fn_args.iter().enumerate() { + let metadata_argument = &func.metadata.arguments[idx]; + + // Skip arguments that don't appear in SQL + if metadata_argument.argument_sql == Ok(SqlMapping::Skip) { + continue; + } + + let type_name = match &metadata_argument.argument_sql { + Ok(SqlMapping::As(sql)) => sql.clone(), + Ok(SqlMapping::Composite { .. }) => { + // For composite types, we'd need the context to get the full type name + // Just use the type name from metadata + metadata_argument.type_name.to_string() + } + Ok(SqlMapping::Skip) => continue, + Err(_) => { + // If we can't get the type, skip it with a comment + continue; + } + }; + + arg_types.push(type_name); + } + + arg_types.join(", ") +} + +/// Configuration for upgrade script generation. +#[derive(Debug, Clone)] +pub struct UpgradeConfig { + /// Whether to include safety comments + pub include_comments: bool, + /// Whether to wrap the script in a transaction + pub use_transaction: bool, + /// Whether to generate IF EXISTS/IF NOT EXISTS clauses + pub use_conditional_clauses: bool, + /// Whether to generate manual review markers for risky changes + pub mark_manual_review: bool, +} + +impl Default for UpgradeConfig { + fn default() -> Self { + Self { + include_comments: true, + use_transaction: false, // Transactions don't work well with DDL in all cases + use_conditional_clauses: true, + mark_manual_review: true, + } + } +} + +/// Generate an upgrade script from a schema diff. +pub fn generate_upgrade_script(diff: &SchemaDiff, config: &UpgradeConfig) -> Result { + let mut script = String::new(); + + // Header + if config.include_comments { + writeln!( + &mut script, + "-- Upgrade script from version {} to {}", + diff.from_version, diff.to_version + )?; + writeln!(&mut script, "-- Generated by pgrx automatic upgrade script generator")?; + writeln!(&mut script, "--")?; + writeln!(&mut script, "-- Summary: {}", diff.summary())?; + writeln!(&mut script)?; + + if diff.has_breaking_changes() { + writeln!(&mut script, "-- WARNING: This upgrade contains breaking changes!")?; + writeln!(&mut script, "-- Review carefully before applying to production.")?; + writeln!(&mut script)?; + } + } + + // Transaction begin + if config.use_transaction { + writeln!(&mut script, "BEGIN;")?; + writeln!(&mut script)?; + } + + // Process renames first (they're the trickiest) + if !diff.renamed.is_empty() { + if config.include_comments { + writeln!(&mut script, "-- Renamed entities")?; + } + for rename in &diff.renamed { + generate_rename_statement(&mut script, rename, config)?; + } + writeln!(&mut script)?; + } + + // Process removals (in reverse dependency order) + if !diff.removed.is_empty() { + if config.include_comments { + writeln!(&mut script, "-- Removed entities")?; + } + let removals = diff.removals_in_dependency_order(); + for removal in removals { + generate_drop_statement(&mut script, removal, config)?; + } + writeln!(&mut script)?; + } + + // Process modifications + if !diff.modified.is_empty() { + if config.include_comments { + writeln!(&mut script, "-- Modified entities")?; + } + for modification in &diff.modified { + generate_modify_statement(&mut script, modification, config)?; + } + writeln!(&mut script)?; + } + + // Process additions (in dependency order) + if !diff.added.is_empty() { + if config.include_comments { + writeln!(&mut script, "-- Added entities")?; + } + let additions = diff.additions_in_dependency_order(); + for addition in additions { + generate_create_statement(&mut script, addition, config)?; + } + writeln!(&mut script)?; + } + + // Transaction end + if config.use_transaction { + writeln!(&mut script, "COMMIT;")?; + } + + Ok(script) +} + +/// Generate a DROP statement for a removed entity. +fn generate_drop_statement( + script: &mut String, + change: &EntityChange, + config: &UpgradeConfig, +) -> Result<()> { + if config.include_comments { + writeln!(script, "-- Drop: {}", change.id.rust_identifier)?; + if let (Some(file), Some(line)) = (change.entity.file(), change.entity.line()) { + writeln!(script, "-- Source: {}:{}", file, line)?; + } + } + + match &change.entity { + SqlGraphEntitySnapshot::Function(func) => { + let if_exists = if config.use_conditional_clauses { "IF EXISTS " } else { "" }; + + writeln!(script, "DROP FUNCTION {}{}(...);", if_exists, func.name)?; + + if config.mark_manual_review { + writeln!( + script, + "-- MANUAL REVIEW: Verify function signature matches: {}", + change.id.rust_identifier + )?; + } + } + SqlGraphEntitySnapshot::Type(pg_type) => { + let if_exists = if config.use_conditional_clauses { "IF EXISTS " } else { "" }; + writeln!(script, "DROP TYPE {}{} CASCADE;", if_exists, pg_type.name)?; + + if config.mark_manual_review { + writeln!(script, "-- MANUAL REVIEW: CASCADE may drop dependent objects")?; + } + } + SqlGraphEntitySnapshot::Enum(enum_entity) => { + let if_exists = if config.use_conditional_clauses { "IF EXISTS " } else { "" }; + writeln!(script, "DROP TYPE {}{} CASCADE;", if_exists, enum_entity.name)?; + } + SqlGraphEntitySnapshot::Schema(schema) => { + let if_exists = if config.use_conditional_clauses { "IF EXISTS " } else { "" }; + writeln!(script, "DROP SCHEMA {}{} CASCADE;", if_exists, schema.name)?; + + if config.mark_manual_review { + writeln!(script, "-- MANUAL REVIEW: CASCADE will drop all objects in schema")?; + } + } + SqlGraphEntitySnapshot::Aggregate(agg) => { + let if_exists = if config.use_conditional_clauses { "IF EXISTS " } else { "" }; + writeln!(script, "DROP AGGREGATE {}{}(...);", if_exists, agg.name)?; + + if config.mark_manual_review { + writeln!(script, "-- MANUAL REVIEW: Verify aggregate signature")?; + } + } + SqlGraphEntitySnapshot::Trigger(trigger) => { + if config.mark_manual_review { + writeln!( + script, + "-- MANUAL REVIEW: Need table name to drop trigger: {}", + trigger.function_name + )?; + } + writeln!(script, "-- DROP TRIGGER {} ON ;", trigger.function_name)?; + } + _ => { + writeln!(script, "-- Unable to generate DROP for: {}", change.id.rust_identifier)?; + } + } + + writeln!(script)?; + Ok(()) +} + +/// Generate a CREATE statement for a new entity. +fn generate_create_statement( + script: &mut String, + change: &EntityChange, + config: &UpgradeConfig, +) -> Result<()> { + if config.include_comments { + writeln!(script, "-- Create: {}", change.id.rust_identifier)?; + if let (Some(file), Some(line)) = (change.entity.file(), change.entity.line()) { + writeln!(script, "-- Source: {}:{}", file, line)?; + } + } + + match &change.entity { + SqlGraphEntitySnapshot::Schema(schema) => { + writeln!(script, "CREATE SCHEMA IF NOT EXISTS {};", schema.name)?; + } + SqlGraphEntitySnapshot::Enum(enum_entity) => { + writeln!(script, "CREATE TYPE {} AS ENUM (", enum_entity.name)?; + for (i, variant) in enum_entity.variants.iter().enumerate() { + let comma = if i < enum_entity.variants.len() - 1 { "," } else { "" }; + writeln!(script, " '{}'{}", variant, comma)?; + } + writeln!(script, ");")?; + } + SqlGraphEntitySnapshot::Function(_) + | SqlGraphEntitySnapshot::Type(_) + | SqlGraphEntitySnapshot::Aggregate(_) => { + writeln!( + script, + "-- CREATE statement for {} must be generated from full context", + change.id.rust_identifier + )?; + if config.mark_manual_review { + writeln!( + script, + "-- MANUAL REVIEW: Add complete CREATE statement for this entity" + )?; + } + } + _ => { + writeln!(script, "-- Unable to generate CREATE for: {}", change.id.rust_identifier)?; + } + } + + writeln!(script)?; + Ok(()) +} + +/// Generate an ALTER or DROP/CREATE for a modified entity. +fn generate_modify_statement( + script: &mut String, + modification: &EntityModification, + config: &UpgradeConfig, +) -> Result<()> { + if config.include_comments { + writeln!(script, "-- Modify: {}", modification.id.rust_identifier)?; + if let (Some(file), Some(line)) = + (modification.new_entity.file(), modification.new_entity.line()) + { + writeln!(script, "-- Source: {}:{}", file, line)?; + } + writeln!(script, "-- Changes:")?; + for change in &modification.changes { + writeln!(script, "-- - {}", change)?; + } + } + + match (&modification.old_entity, &modification.new_entity) { + (SqlGraphEntitySnapshot::Function(_), SqlGraphEntitySnapshot::Function(new_func)) => { + // Functions typically need CREATE OR REPLACE + writeln!(script, "-- CREATE OR REPLACE FUNCTION {} ...", new_func.name)?; + if config.mark_manual_review { + writeln!(script, "-- MANUAL REVIEW: Generate complete function definition")?; + } + } + (SqlGraphEntitySnapshot::Enum(old_enum), SqlGraphEntitySnapshot::Enum(new_enum)) => { + // Enums are tricky - can only add values in PostgreSQL + let old_variants: std::collections::HashSet<_> = old_enum.variants.iter().collect(); + let new_variants: std::collections::HashSet<_> = new_enum.variants.iter().collect(); + + // Check for added variants + for variant in &new_enum.variants { + if !old_variants.contains(variant) { + writeln!( + script, + "ALTER TYPE {} ADD VALUE IF NOT EXISTS '{}';", + new_enum.name, variant + )?; + } + } + + // Check for removed variants + for variant in &old_enum.variants { + if !new_variants.contains(variant) && config.mark_manual_review { + writeln!( + script, + "-- MANUAL REVIEW: Cannot remove enum value '{}' from {} - requires type recreation", + variant, old_enum.name + )?; + } + } + } + (SqlGraphEntitySnapshot::Type(_old_type), SqlGraphEntitySnapshot::Type(new_type)) => { + // Types usually need to be dropped and recreated + writeln!( + script, + "-- Type {} was modified - may require DROP and recreate", + new_type.name + )?; + if config.mark_manual_review { + writeln!( + script, + "-- MANUAL REVIEW: Type modifications often require data migration" + )?; + } + } + _ => { + writeln!( + script, + "-- Unable to generate ALTER for: {}", + modification.id.rust_identifier + )?; + } + } + + writeln!(script)?; + Ok(()) +} + +/// Generate RENAME or DROP/CREATE for a renamed entity. +fn generate_rename_statement( + script: &mut String, + rename: &EntityRename, + config: &UpgradeConfig, +) -> Result<()> { + if config.include_comments { + writeln!( + script, + "-- Rename: {} -> {} (confidence: {:.0}%)", + rename.old_id.rust_identifier, + rename.new_id.rust_identifier, + rename.confidence * 100.0 + )?; + } + + if config.mark_manual_review { + writeln!(script, "-- MANUAL REVIEW: Verify this rename is correct")?; + } + + match (&rename.old_entity, &rename.new_entity) { + (SqlGraphEntitySnapshot::Function(old_fn), SqlGraphEntitySnapshot::Function(new_fn)) => { + writeln!(script, "-- ALTER FUNCTION {}(...) RENAME TO {};", old_fn.name, new_fn.name)?; + writeln!(script, "-- Note: Function signature must match exactly")?; + } + (SqlGraphEntitySnapshot::Type(old_type), SqlGraphEntitySnapshot::Type(new_type)) => { + writeln!(script, "ALTER TYPE {} RENAME TO {};", old_type.name, new_type.name)?; + } + (SqlGraphEntitySnapshot::Enum(old_enum), SqlGraphEntitySnapshot::Enum(new_enum)) => { + writeln!(script, "ALTER TYPE {} RENAME TO {};", old_enum.name, new_enum.name)?; + } + ( + SqlGraphEntitySnapshot::Schema(old_schema), + SqlGraphEntitySnapshot::Schema(new_schema), + ) => { + writeln!(script, "ALTER SCHEMA {} RENAME TO {};", old_schema.name, new_schema.name)?; + } + _ => { + writeln!( + script, + "-- Unable to generate RENAME for: {} -> {}", + rename.old_id.rust_identifier, rename.new_id.rust_identifier + )?; + } + } + + writeln!(script)?; + Ok(()) +} + +/// Generate a complete upgrade script file with proper header and footer. +pub fn generate_upgrade_file( + from_version: &str, + to_version: &str, + diff: &SchemaDiff, + config: &UpgradeConfig, +) -> Result { + let mut output = String::new(); + + // Extension upgrade file header + writeln!( + &mut output, + "-- Upgrade script for extension from {} to {}", + from_version, to_version + )?; + writeln!(&mut output)?; + + // Generate the script content + let script = generate_upgrade_script(diff, config)?; + output.push_str(&script); + + Ok(output) +} + +/// Generate an upgrade script with actual SQL using the PgrxSql context. +/// +/// This version can generate complete CREATE statements for functions, types, etc. +/// by using the ToSql trait implementations. +pub fn generate_upgrade_script_with_sql( + from_version: &str, + to_version: &str, + diff: &SchemaDiff, + pgrx_sql: &PgrxSql, +) -> eyre::Result { + let mut script = String::new(); + + // Header + writeln!( + &mut script, + "-- Upgrade script for extension from {} to {}", + from_version, to_version + ) + .map_err(|e| eyre::eyre!("Failed to write header: {}", e))?; + writeln!(&mut script, "-- Generated by pgrx automatic upgrade script generator") + .map_err(|e| eyre::eyre!("Failed to write header: {}", e))?; + writeln!(&mut script, "--").map_err(|e| eyre::eyre!("Failed to write header: {}", e))?; + writeln!(&mut script, "-- Summary: {}", diff.summary()) + .map_err(|e| eyre::eyre!("Failed to write summary: {}", e))?; + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + + if diff.has_breaking_changes() { + writeln!(&mut script, "-- WARNING: This upgrade contains breaking changes!") + .map_err(|e| eyre::eyre!("Failed to write warning: {}", e))?; + writeln!(&mut script, "-- Review carefully before applying to production.") + .map_err(|e| eyre::eyre!("Failed to write warning: {}", e))?; + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + } + + // Process renames first + if !diff.renamed.is_empty() { + writeln!(&mut script, "-- Renamed entities") + .map_err(|e| eyre::eyre!("Failed to write section header: {}", e))?; + for rename in &diff.renamed { + generate_rename_sql(&mut script, rename, pgrx_sql)?; + } + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + } + + // Process removals (in reverse dependency order) + if !diff.removed.is_empty() { + writeln!(&mut script, "-- Removed entities") + .map_err(|e| eyre::eyre!("Failed to write section header: {}", e))?; + let removals = diff.removals_in_dependency_order(); + for removal in removals { + generate_drop_sql(&mut script, removal, pgrx_sql)?; + } + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + } + + // Process modifications + if !diff.modified.is_empty() { + writeln!(&mut script, "-- Modified entities") + .map_err(|e| eyre::eyre!("Failed to write section header: {}", e))?; + for modification in &diff.modified { + generate_modify_sql(&mut script, modification, pgrx_sql)?; + } + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + } + + // Process additions (in dependency order) + if !diff.added.is_empty() { + writeln!(&mut script, "-- Added entities") + .map_err(|e| eyre::eyre!("Failed to write section header: {}", e))?; + let additions = diff.additions_in_dependency_order(); + for addition in additions { + generate_create_sql(&mut script, addition, pgrx_sql)?; + } + writeln!(&mut script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + } + + Ok(script) +} + +/// Generate a DROP statement with SQL context. +fn generate_drop_sql( + script: &mut String, + change: &EntityChange, + _pgrx_sql: &PgrxSql, +) -> eyre::Result<()> { + writeln!(script, "-- Drop: {}", change.id.rust_identifier) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + if let (Some(file), Some(line)) = (change.entity.file(), change.entity.line()) { + writeln!(script, "-- Source: {}:{}", file, line) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + + match &change.entity { + SqlGraphEntitySnapshot::Function(func) => { + // For removed functions, try to generate argument types from metadata + // without requiring the current context (since the function was removed) + let arg_types = generate_function_arg_types_from_metadata(func); + + writeln!(script, "DROP FUNCTION IF EXISTS {}({});", func.name, arg_types) + .map_err(|e| eyre::eyre!("Failed to write DROP FUNCTION: {}", e))?; + + if !func.fn_args.is_empty() && arg_types.is_empty() { + writeln!( + script, + "-- MANUAL REVIEW: Function had {} argument(s), but types couldn't be determined. Update signature.", + func.fn_args.len() + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + } + SqlGraphEntitySnapshot::Type(pg_type) => { + writeln!(script, "DROP TYPE IF EXISTS {} CASCADE;", pg_type.name) + .map_err(|e| eyre::eyre!("Failed to write DROP TYPE: {}", e))?; + writeln!(script, "-- MANUAL REVIEW: CASCADE may drop dependent objects") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + SqlGraphEntitySnapshot::Enum(enum_entity) => { + writeln!(script, "DROP TYPE IF EXISTS {} CASCADE;", enum_entity.name) + .map_err(|e| eyre::eyre!("Failed to write DROP TYPE: {}", e))?; + } + SqlGraphEntitySnapshot::Schema(schema) => { + writeln!(script, "DROP SCHEMA IF EXISTS {} CASCADE;", schema.name) + .map_err(|e| eyre::eyre!("Failed to write DROP SCHEMA: {}", e))?; + writeln!(script, "-- MANUAL REVIEW: CASCADE will drop all objects in schema") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + SqlGraphEntitySnapshot::Aggregate(agg) => { + writeln!(script, "DROP AGGREGATE IF EXISTS {}(...);", agg.name) + .map_err(|e| eyre::eyre!("Failed to write DROP AGGREGATE: {}", e))?; + writeln!(script, "-- MANUAL REVIEW: Verify aggregate signature") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + SqlGraphEntitySnapshot::Trigger(trigger) => { + writeln!( + script, + "-- MANUAL REVIEW: Need table name to drop trigger: {}", + trigger.function_name + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + writeln!(script, "-- DROP TRIGGER {} ON ;", trigger.function_name) + .map_err(|e| eyre::eyre!("Failed to write DROP TRIGGER: {}", e))?; + } + _ => { + writeln!(script, "-- Unable to generate DROP for: {}", change.id.rust_identifier) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + } + + writeln!(script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + Ok(()) +} + +/// Generate a CREATE statement using the entity's ToSql implementation. +fn generate_create_sql( + script: &mut String, + change: &EntityChange, + pgrx_sql: &PgrxSql, +) -> eyre::Result<()> { + use crate::SqlGraphEntity; + + writeln!(script, "-- Create: {}", change.id.rust_identifier) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + if let (Some(file), Some(line)) = (change.entity.file(), change.entity.line()) { + writeln!(script, "-- Source: {}:{}", file, line) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + + // Convert snapshot entity back to runtime entity for ToSql + let runtime_entity = SqlGraphEntity::from(change.entity.clone()); + + // Use the entity's ToSql implementation to generate the actual SQL + let sql = runtime_entity.to_sql(pgrx_sql)?; + writeln!(script, "{}", sql).map_err(|e| eyre::eyre!("Failed to write SQL: {}", e))?; + + writeln!(script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + Ok(()) +} + +/// Generate an ALTER or DROP/CREATE for a modified entity. +fn generate_modify_sql( + script: &mut String, + modification: &EntityModification, + pgrx_sql: &PgrxSql, +) -> eyre::Result<()> { + writeln!(script, "-- Modify: {}", modification.id.rust_identifier) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + if let (Some(file), Some(line)) = + (modification.new_entity.file(), modification.new_entity.line()) + { + writeln!(script, "-- Source: {}:{}", file, line) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + writeln!(script, "-- Changes:").map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + for change in &modification.changes { + writeln!(script, "-- - {}", change) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + + match (&modification.old_entity, &modification.new_entity) { + (SqlGraphEntitySnapshot::Function(_), SqlGraphEntitySnapshot::Function(new_func)) => { + // Functions support CREATE OR REPLACE + let sql = new_func.to_sql(pgrx_sql)?; + writeln!(script, "{}", sql).map_err(|e| eyre::eyre!("Failed to write SQL: {}", e))?; + } + (SqlGraphEntitySnapshot::Enum(old_enum), SqlGraphEntitySnapshot::Enum(new_enum)) => { + // Enums can only add values in PostgreSQL + let old_variants: std::collections::HashSet<_> = old_enum.variants.iter().collect(); + let new_variants: std::collections::HashSet<_> = new_enum.variants.iter().collect(); + + // Check for added variants + for variant in &new_enum.variants { + if !old_variants.contains(variant) { + writeln!( + script, + "ALTER TYPE {} ADD VALUE IF NOT EXISTS '{}';", + new_enum.name, variant + ) + .map_err(|e| eyre::eyre!("Failed to write ALTER TYPE: {}", e))?; + } + } + + // Check for removed variants + for variant in &old_enum.variants { + if !new_variants.contains(variant) { + writeln!( + script, + "-- MANUAL REVIEW: Cannot remove enum value '{}' from {} - requires type recreation", + variant, old_enum.name + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + } + } + (SqlGraphEntitySnapshot::Type(_old_type), SqlGraphEntitySnapshot::Type(new_type)) => { + // Types usually need to be dropped and recreated + writeln!( + script, + "-- Type {} was modified - may require DROP and recreate", + new_type.name + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + writeln!(script, "-- MANUAL REVIEW: Type modifications often require data migration") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + _ => { + writeln!( + script, + "-- Unable to generate ALTER for: {}", + modification.id.rust_identifier + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + } + + writeln!(script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + Ok(()) +} + +/// Generate RENAME or DROP/CREATE for a renamed entity. +fn generate_rename_sql( + script: &mut String, + rename: &EntityRename, + _pgrx_sql: &PgrxSql, +) -> eyre::Result<()> { + writeln!( + script, + "-- Rename: {} -> {} (confidence: {:.0}%)", + rename.old_id.rust_identifier, + rename.new_id.rust_identifier, + rename.confidence * 100.0 + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + writeln!(script, "-- MANUAL REVIEW: Verify this rename is correct") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + + match (&rename.old_entity, &rename.new_entity) { + (SqlGraphEntitySnapshot::Function(old_fn), SqlGraphEntitySnapshot::Function(new_fn)) => { + writeln!(script, "-- ALTER FUNCTION {}(...) RENAME TO {};", old_fn.name, new_fn.name) + .map_err(|e| eyre::eyre!("Failed to write ALTER FUNCTION: {}", e))?; + writeln!(script, "-- Note: Function signature must match exactly") + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + (SqlGraphEntitySnapshot::Type(old_type), SqlGraphEntitySnapshot::Type(new_type)) => { + writeln!(script, "ALTER TYPE {} RENAME TO {};", old_type.name, new_type.name) + .map_err(|e| eyre::eyre!("Failed to write ALTER TYPE: {}", e))?; + } + (SqlGraphEntitySnapshot::Enum(old_enum), SqlGraphEntitySnapshot::Enum(new_enum)) => { + writeln!(script, "ALTER TYPE {} RENAME TO {};", old_enum.name, new_enum.name) + .map_err(|e| eyre::eyre!("Failed to write ALTER TYPE: {}", e))?; + } + ( + SqlGraphEntitySnapshot::Schema(old_schema), + SqlGraphEntitySnapshot::Schema(new_schema), + ) => { + writeln!(script, "ALTER SCHEMA {} RENAME TO {};", old_schema.name, new_schema.name) + .map_err(|e| eyre::eyre!("Failed to write ALTER SCHEMA: {}", e))?; + } + _ => { + writeln!( + script, + "-- Unable to generate RENAME for: {} -> {}", + rename.old_id.rust_identifier, rename.new_id.rust_identifier + ) + .map_err(|e| eyre::eyre!("Failed to write comment: {}", e))?; + } + } + + writeln!(script).map_err(|e| eyre::eyre!("Failed to write newline: {}", e))?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::diff::SchemaDiff; + use crate::schema::entity::SchemaEntity; + use crate::snapshot::{EntityId, SchemaSnapshot, SerializableEntity}; + use std::time::SystemTime; + + #[test] + fn test_empty_upgrade_script() { + let snapshot1 = SchemaSnapshot { + version: "1.0.0".to_string(), + timestamp: SystemTime::now(), + extension_name: "test".to_string(), + entities: vec![], + dependency_edges: vec![], + versioned_so: false, + }; + + let snapshot2 = snapshot1.clone(); + + let diff = SchemaDiff::compare(&snapshot1, &snapshot2); + let config = UpgradeConfig::default(); + + let script = generate_upgrade_script(&diff, &config).unwrap(); + + assert!(script.contains("from version 1.0.0 to 1.0.0")); + assert!(!script.contains("DROP")); + assert!(!script.contains("CREATE")); + } + + #[test] + fn test_schema_addition() { + let snapshot1 = SchemaSnapshot { + version: "1.0.0".to_string(), + timestamp: SystemTime::now(), + extension_name: "test".to_string(), + entities: vec![], + dependency_edges: vec![], + versioned_so: false, + }; + + let schema_entity = SchemaEntity { + module_path: "test::schema", + name: "test_schema", + file: "src/lib.rs", + line: 10, + }; + + let mut snapshot2 = snapshot1.clone(); + snapshot2.version = "1.1.0".to_string(); + snapshot2.entities.push(SerializableEntity { + id: EntityId::from_entity(&crate::SqlGraphEntity::Schema(schema_entity.clone())), + entity: SqlGraphEntitySnapshot::Schema(schema_entity), + node_index: Some(0), + }); + + let diff = SchemaDiff::compare(&snapshot1, &snapshot2); + let config = UpgradeConfig::default(); + + let script = generate_upgrade_script(&diff, &config).unwrap(); + + assert!(script.contains("CREATE SCHEMA")); + assert!(script.contains("test_schema")); + } +} diff --git a/pgrx-sql-entity-graph/src/used_type.rs b/pgrx-sql-entity-graph/src/used_type.rs index 4c6f421fec..d9984e84aa 100644 --- a/pgrx-sql-entity-graph/src/used_type.rs +++ b/pgrx-sql-entity-graph/src/used_type.rs @@ -309,20 +309,30 @@ impl UsedType { } } -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] +#[serde(bound(deserialize = ""))] pub struct UsedTypeEntity { + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub ty_source: &'static str, + #[serde(skip, default = "default_type_id")] pub ty_id: core::any::TypeId, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_static_str")] pub full_path: &'static str, pub module_path: String, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub composite_type: Option<&'static str>, pub variadic: bool, + #[serde(deserialize_with = "crate::serde_helpers::deserialize_option_static_str")] pub default: Option<&'static str>, /// Set via the type being an `Option`. pub optional: bool, pub metadata: FunctionMetadataTypeEntity, } +fn default_type_id() -> core::any::TypeId { + core::any::TypeId::of::() +} + impl crate::TypeIdentifiable for UsedTypeEntity { fn ty_id(&self) -> &core::any::TypeId { &self.ty_id diff --git a/pgrx-tests/sql/snapshots/pgrx_tests--1.0.json b/pgrx-tests/sql/snapshots/pgrx_tests--1.0.json new file mode 100644 index 0000000000..781e849596 --- /dev/null +++ b/pgrx-tests/sql/snapshots/pgrx_tests--1.0.json @@ -0,0 +1,104538 @@ +{ + "version": "1.0", + "timestamp": 1762203038, + "extension_name": "pgrx_tests", + "entities": [ + { + "id": { + "entity_type": "ExtensionRoot", + "rust_identifier": "root", + "signature_hash": "c9bcaf65777ae2c" + }, + "entity": { + "ExtensionRoot": { + "comment": "tests: Created by pgrx", + "default_version": "1.0", + "module_pathname": "pgrx_tests", + "relocatable": false, + "superuser": false, + "schema": null, + "trusted": false + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "create_complex_shell_type", + "signature_hash": "425aad273be5f25" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::complex", + "full_path": "pgrx-tests/src/tests/complex.rs:37", + "sql": "CREATE TYPE complex;", + "file": "pgrx-tests/src/tests/complex.rs", + "line": 37, + "name": "create_complex_shell_type", + "bootstrap": false, + "finalize": false, + "requires": [], + "creates": [ + { + "Type": { + "sql": "Complex", + "name": "pgrx_tests::tests::complex::Complex", + "option": "Option", + "vec": "Vec", + "vec_option": "Vec>", + "option_vec": "Option>", + "option_vec_option": "Option>", + "array": "Array", + "option_array": "Option", + "varlena": "Varlena", + "pg_box": [ + "pgrx::pgbox::PgBox", + "pgrx::pgbox::PgBox", + "pgrx::pgbox::PgBox" + ] + } + } + ] + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "create_complex_type", + "signature_hash": "a0e8c611f160b947" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::complex", + "full_path": "pgrx-tests/src/tests/complex.rs:77", + "sql": "\nCREATE TYPE complex (\n internallength = 16,\n input = complex_in,\n output = complex_out,\n alignment = double\n);\n", + "file": "pgrx-tests/src/tests/complex.rs", + "line": 77, + "name": "create_complex_type", + "bootstrap": false, + "finalize": false, + "requires": [ + { + "Name": "create_complex_shell_type" + }, + { + "FullPath": "complex_in" + }, + { + "FullPath": "complex_out" + } + ], + "creates": [] + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "issue1293", + "signature_hash": "ea5cc8e8964e1d1" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::composite_type_tests", + "full_path": "pgrx-tests/src/tests/composite_type_tests.rs:3", + "sql": "\n CREATE TYPE entity AS (id INT, lang TEXT);\n CREATE TYPE result AS (score DOUBLE PRECISION, entities entity[]);\n ", + "file": "pgrx-tests/src/tests/composite_type_tests.rs", + "line": 3, + "name": "issue1293", + "bootstrap": false, + "finalize": false, + "requires": [], + "creates": [] + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "test_funcs", + "signature_hash": "754bed4c4168e6eb" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx-tests/src/tests/fn_call_tests.rs:30", + "sql": "\n CREATE FUNCTION tests.sql_int4eq(int4, int4) RETURNS bool STRICT LANGUAGE sql AS $$ SELECT $1 = $2; $$;\n \n CREATE FUNCTION tests.with_only_default(int4 DEFAULT 0) RETURNS text STRICT LANGUAGE sql AS $$ SELECT 'int4'; $$;\n CREATE FUNCTION tests.with_only_default(int8 DEFAULT 0) RETURNS text STRICT LANGUAGE sql AS $$ SELECT 'int8'; $$;\n \n CREATE FUNCTION tests.with_default(int4, int4 DEFAULT 0) RETURNS int4 STRICT LANGUAGE sql AS $$ SELECT $1 + $2; $$;\n \n CREATE FUNCTION tests.with_two_defaults(int4 DEFAULT 0, int4 DEFAULT 0) RETURNS int4 STRICT LANGUAGE sql AS $$ SELECT $1 + $2; $$;\n \n CREATE FUNCTION tests.with_arg_and_two_defaults(int4, int4 DEFAULT 1, int4 DEFAULT 2) RETURNS int4 STRICT LANGUAGE sql AS $$ SELECT $1 + $2 + $3; $$;\n \n CREATE FUNCTION tests.with_null_default(text DEFAULT NULL) RETURNS text STRICT LANGUAGE sql AS $$ SELECT $1; $$;\n \n CREATE FUNCTION tests.n() RETURNS text IMMUTABLE LANGUAGE sql AS $$ SELECT NULL; $$;\n CREATE FUNCTION tests.with_functional_default(text DEFAULT tests.n()) RETURNS text STRICT LANGUAGE sql AS $$ SELECT $1; $$;\n \n CREATE FUNCTION tests.fcall_raise_error(e text) RETURNS void LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION '%', e; END; $$;\n ", + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 30, + "name": "test_funcs", + "bootstrap": false, + "finalize": false, + "requires": [ + { + "FullPath": "tests" + } + ], + "creates": [] + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "create_composites", + "signature_hash": "b0756a523e56ae25" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::heap_tuple", + "full_path": "pgrx-tests/src/tests/heap_tuple.rs:17", + "sql": "\nCREATE TYPE Dog AS (\n name TEXT,\n scritches INT\n);\n\nCREATE TYPE Cat AS (\n name TEXT,\n boops INT\n);\n\nCREATE TYPE Fish AS (\n name TEXT,\n bloops INT\n);\n\nCREATE TYPE AnimalFriendshipEdge AS (\n friend_1_name TEXT,\n friend_2_name TEXT\n);\n", + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 17, + "name": "create_composites", + "bootstrap": true, + "finalize": false, + "requires": [], + "creates": [] + } + } + }, + { + "id": { + "entity_type": "CustomSql", + "rust_identifier": "pgrx_module_qualification_test", + "signature_hash": "b950faec90fe126d" + }, + "entity": { + "CustomSql": { + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx-tests/src/tests/pgrx_module_qualification.rs:36", + "sql": "SELECT 1;", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 36, + "name": "pgrx_module_qualification_test", + "bootstrap": false, + "finalize": false, + "requires": [], + "creates": [] + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema", + "signature_hash": "6d7895f4fcb335f3" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "name": "demo_schema", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 159 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests", + "signature_hash": "2006ff9e07f60cd1" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 282 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::anyarray_tests::tests", + "signature_hash": "4c0007f9835e8df" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::anyarray_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/anyarray_tests.rs", + "line": 30 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::anyelement_tests::tests", + "signature_hash": "ec918b635a17a811" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::anyelement_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/anyelement_tests.rs", + "line": 9 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::anynumeric_tests::tests", + "signature_hash": "26141655c43d267b" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::anynumeric_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/anynumeric_tests.rs", + "line": 9 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::array_tests::tests", + "signature_hash": "859ff2f4dd1a0205" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::array_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 187 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::attributes_tests::tests", + "signature_hash": "e1f8cbfd78a14b79" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::attributes_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/attributes_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests", + "signature_hash": "160ef704f75ee280" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 87 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests", + "signature_hash": "993649a9dfe2efa4" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 58 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests", + "signature_hash": "addbc276114df5ad" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::cfg_tests::tests", + "signature_hash": "e925e9637f4511db" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::cfg_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/cfg_tests.rs", + "line": 22 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::composite_type_tests::tests", + "signature_hash": "bd9383423cb0f65e" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::composite_type_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/composite_type_tests.rs", + "line": 27 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests", + "signature_hash": "a7a9f0ae97496b51" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 89 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests", + "signature_hash": "95f8a619f8307cfc" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 28 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::enum_type_tests::tests", + "signature_hash": "cde10527948c49aa" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::enum_type_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/enum_type_tests.rs", + "line": 28 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests", + "signature_hash": "57c022a08ab15d2" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 180 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests", + "signature_hash": "3221015136aa97b8" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::from_into_datum_tests::tests", + "signature_hash": "fbd73dab8661fa20" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::from_into_datum_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/from_into_datum_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::geo_tests::tests", + "signature_hash": "8cb0ce0b617bb705" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::geo_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/geo_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests", + "signature_hash": "63bc4bf3acdc157d" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::guc_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests", + "signature_hash": "1769c8b6580285ae" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 580 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::inet_tests::tests", + "signature_hash": "a0b7d0d39c20a103" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::inet_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/inet_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::internal_tests::tests", + "signature_hash": "348f39226dd5697d" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::internal_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/internal_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::json_tests::tests", + "signature_hash": "42fc379a7af2c366" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::json_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 24 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::list_tests::tests", + "signature_hash": "bfbe208a3e0ed63e" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::list_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/list_tests.rs", + "line": 8 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::log_tests::tests", + "signature_hash": "4fba700d0189aeb9" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::log_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests", + "signature_hash": "91156579f7da1c2d" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::name_tests::tests", + "signature_hash": "df91156ca412eff1" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::name_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/name_tests.rs", + "line": 16 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests", + "signature_hash": "5e4f5a7d4e188dc3" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::oid_tests::tests", + "signature_hash": "c130f4586d08f77" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::oid_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/oid_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "signature_hash": "abbadd6edb68f111" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "name": "pg_catalog", + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 12 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests", + "signature_hash": "13c1b496dcf27898" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 56 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "signature_hash": "550063143ce536c3" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "name": "support_fn_schema", + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 13 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests", + "signature_hash": "adb08aae175b62b1" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 58 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_guard_tests::tests", + "signature_hash": "4ae5a4b246f06049" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_guard_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pg_guard_tests.rs", + "line": 46 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "signature_hash": "c2fa04c1369f250d" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "name": "pg_catalog", + "file": "pgrx-tests/src/tests/pg_operator_tests.rs", + "line": 12 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_operator_tests::tests", + "signature_hash": "737d003c55d15ab0" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_operator_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pg_operator_tests.rs", + "line": 24 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests", + "signature_hash": "3d3699c2a264cf54" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 48 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pgbox_tests::tests", + "signature_hash": "4b31955d8388e7ad" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pgbox_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/pgbox_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_schema", + "signature_hash": "f50754fd6be857e1" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_schema", + "name": "foo_schema", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 124 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests", + "signature_hash": "c31c05b86cb9cba7" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 163 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::proptests::tests", + "signature_hash": "bf9e0c4b5ccb8579" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::proptests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::range_tests::tests", + "signature_hash": "3b44274e87fb0eb1" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::range_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 115 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::rel_tests::tests", + "signature_hash": "bfb1456b50b61632" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::rel_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/rel_tests.rs", + "line": 18 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::result_tests::tests", + "signature_hash": "277ca035977c06" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::result_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 31 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests", + "signature_hash": "340c01a33a549587" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 40 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema", + "signature_hash": "37745df5f10cad94" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "name": "test_schema", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 12 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests", + "signature_hash": "ae47897fe32964fe" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::schema_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 90 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::shmem_tests::tests", + "signature_hash": "3de5e7642818f124" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::shmem_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/shmem_tests.rs", + "line": 32 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests", + "signature_hash": "7b2950e18eb56cc5" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::spi_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests", + "signature_hash": "dba0dd0d3c7d2f23" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::srf_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 146 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::struct_type_tests::tests", + "signature_hash": "43bdb37cf64a3775" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::struct_type_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/struct_type_tests.rs", + "line": 13 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests", + "signature_hash": "66a75cabc4bf4b80" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "signature_hash": "4fdba4b18e7917bb" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "name": "trigger_signature_compile_tests", + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 22 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::uuid_tests::tests", + "signature_hash": "90ba18126794539a" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::uuid_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 33 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::variadic_tests::test", + "signature_hash": "183cea2cd683cfe4" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::variadic_tests::test", + "name": "test", + "file": "pgrx-tests/src/tests/variadic_tests.rs", + "line": 10 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::variadic_tests::tests", + "signature_hash": "e08ee033b27779a5" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::variadic_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/variadic_tests.rs", + "line": 25 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::xact_callback_tests::tests", + "signature_hash": "2a17cf00d87b27fc" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::xact_callback_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/xact_callback_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::xid64_tests::tests", + "signature_hash": "cbdaabfee7b56b5d" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::xid64_tests::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/xid64_tests.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Schema", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "signature_hash": "432a3674bdcd16ae" + }, + "entity": { + "Schema": { + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "name": "tests", + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 11 + } + } + }, + { + "id": { + "entity_type": "Enum", + "rust_identifier": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "signature_hash": "8774059288ecd775" + }, + "entity": { + "Enum": { + "name": "ArrayTestEnum", + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 153, + "full_path": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "module_path": "pgrx_tests::tests::array_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum" + }, + { + "rust": "&mut pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "&pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum" + }, + { + "rust": "&pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::array_tests::ArrayTestEnum>", + "sql": "ArrayTestEnum" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::array_tests::ArrayTestEnum>", + "sql": "ArrayTestEnum" + }, + { + "rust": "core::option::Option>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "core::option::Option", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::array_tests::ArrayTestEnum>", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::array_tests::ArrayTestEnum>", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum" + }, + { + "rust": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "sql": "ArrayTestEnum[]" + } + ], + "variants": [ + "One", + "Two", + "Three" + ], + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Enum", + "rust_identifier": "pgrx_tests::tests::enum_type_tests::Foo", + "signature_hash": "6d7463391678b8bc" + }, + "entity": { + "Enum": { + "name": "Foo", + "file": "pgrx-tests/src/tests/enum_type_tests.rs", + "line": 12, + "full_path": "pgrx_tests::tests::enum_type_tests::Foo", + "module_path": "pgrx_tests::tests::enum_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo" + }, + { + "rust": "&mut pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo[]" + }, + { + "rust": "&pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo" + }, + { + "rust": "&pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "Foo[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "Foo[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::enum_type_tests::Foo>", + "sql": "Foo" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::enum_type_tests::Foo>", + "sql": "Foo" + }, + { + "rust": "core::option::Option>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option>", + "sql": "Foo[]" + }, + { + "rust": "core::option::Option", + "sql": "Foo" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "Foo[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "Foo[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::enum_type_tests::Foo>", + "sql": "Foo" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::enum_type_tests::Foo>", + "sql": "Foo" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "Foo" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "Foo" + }, + { + "rust": "pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo" + }, + { + "rust": "pgrx_tests::tests::enum_type_tests::Foo", + "sql": "Foo[]" + } + ], + "variants": [ + "One", + "Two", + "Three" + ], + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "signature_hash": "5c0fd21ddb5e6bef" + }, + "entity": { + "Type": { + "name": "CustomTextFormatSerializedEnumType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 110, + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "core::option::Option", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "sql": "CustomTextFormatSerializedEnumType[]" + } + ], + "in_fn": "customtextformatserializedenumtype_in", + "in_fn_module_path": "", + "out_fn": "customtextformatserializedenumtype_out", + "out_fn_module_path": "", + "receive_fn": "customtextformatserializedenumtype_recv", + "receive_fn_module_path": "", + "send_fn": "customtextformatserializedenumtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "signature_hash": "6c94a52aefddf1e7" + }, + "entity": { + "Type": { + "name": "CustomTextFormatSerializedType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 75, + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "core::option::Option", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "sql": "CustomTextFormatSerializedType[]" + } + ], + "in_fn": "customtextformatserializedtype_in", + "in_fn_module_path": "", + "out_fn": "customtextformatserializedtype_out", + "out_fn_module_path": "", + "receive_fn": "customtextformatserializedtype_recv", + "receive_fn_module_path": "", + "send_fn": "customtextformatserializedtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::CustomType", + "signature_hash": "d411ff9196735d9d" + }, + "entity": { + "Type": { + "name": "CustomType", + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 15, + "full_path": "pgrx_tests::tests::lifetime_tests::CustomType", + "module_path": "pgrx_tests::tests::lifetime_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType" + }, + { + "rust": "&mut pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType[]" + }, + { + "rust": "&pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType" + }, + { + "rust": "&pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::lifetime_tests::CustomType>", + "sql": "CustomType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::lifetime_tests::CustomType>", + "sql": "CustomType" + }, + { + "rust": "core::option::Option>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option>", + "sql": "CustomType[]" + }, + { + "rust": "core::option::Option", + "sql": "CustomType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "CustomType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "CustomType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::lifetime_tests::CustomType>", + "sql": "CustomType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::lifetime_tests::CustomType>", + "sql": "CustomType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "CustomType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "CustomType" + }, + { + "rust": "pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType" + }, + { + "rust": "pgrx_tests::tests::lifetime_tests::CustomType", + "sql": "CustomType[]" + } + ], + "in_fn": "customtype_in", + "in_fn_module_path": "", + "out_fn": "customtype_out", + "out_fn_module_path": "", + "receive_fn": null, + "receive_fn_module_path": null, + "send_fn": null, + "send_fn_module_path": null, + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "signature_hash": "bde4406430d24b5f" + }, + "entity": { + "Type": { + "name": "DemoCustomState", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 170, + "full_path": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "module_path": "pgrx_tests::tests::aggregate_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState" + }, + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState[]" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoCustomState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoCustomState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::aggregate_tests::DemoCustomState>", + "sql": "DemoCustomState" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::aggregate_tests::DemoCustomState>", + "sql": "DemoCustomState" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState" + }, + { + "rust": "core::option::Option>", + "sql": "DemoCustomState" + }, + { + "rust": "core::option::Option", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "DemoCustomState[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "DemoCustomState[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::aggregate_tests::DemoCustomState>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::aggregate_tests::DemoCustomState>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::aggregate_tests::DemoCustomState>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "sql": "DemoCustomState[]" + } + ], + "in_fn": "democustomstate_in", + "in_fn_module_path": "", + "out_fn": "democustomstate_out", + "out_fn_module_path": "", + "receive_fn": "democustomstate_recv", + "receive_fn_module_path": "", + "send_fn": "democustomstate_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoOps", + "signature_hash": "5f8c07cefb41e476" + }, + "entity": { + "Type": { + "name": "DemoOps", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 14, + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps" + }, + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps[]" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoOps[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoOps[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::aggregate_tests::DemoOps>", + "sql": "DemoOps" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::aggregate_tests::DemoOps>", + "sql": "DemoOps" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps" + }, + { + "rust": "core::option::Option>", + "sql": "DemoOps" + }, + { + "rust": "core::option::Option", + "sql": "DemoOps" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "DemoOps[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "DemoOps[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::aggregate_tests::DemoOps>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::aggregate_tests::DemoOps>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::aggregate_tests::DemoOps>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoOps" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "DemoOps" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoOps", + "sql": "DemoOps[]" + } + ], + "in_fn": "demoops_in", + "in_fn_module_path": "", + "out_fn": "demoops_out", + "out_fn_module_path": "", + "receive_fn": "demoops_recv", + "receive_fn_module_path": "", + "send_fn": "demoops_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "signature_hash": "bb1ef8f21f3b75d7" + }, + "entity": { + "Type": { + "name": "DemoPercentileDisc", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 122, + "full_path": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "module_path": "pgrx_tests::tests::aggregate_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc" + }, + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::aggregate_tests::DemoPercentileDisc>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::aggregate_tests::DemoPercentileDisc>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "core::option::Option>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "core::option::Option", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::aggregate_tests::DemoPercentileDisc>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::aggregate_tests::DemoPercentileDisc>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::aggregate_tests::DemoPercentileDisc>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "sql": "DemoPercentileDisc[]" + } + ], + "in_fn": "demopercentiledisc_in", + "in_fn_module_path": "", + "out_fn": "demopercentiledisc_out", + "out_fn_module_path": "", + "receive_fn": "demopercentiledisc_recv", + "receive_fn_module_path": "", + "send_fn": "demopercentiledisc_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "signature_hash": "36b3b15d63ec28ef" + }, + "entity": { + "Type": { + "name": "DemoState", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 164, + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState" + }, + { + "rust": "&mut pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState[]" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState" + }, + { + "rust": "&pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoState[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::aggregate_tests::demo_schema::DemoState>", + "sql": "DemoState" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::aggregate_tests::demo_schema::DemoState>", + "sql": "DemoState" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState[]" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState" + }, + { + "rust": "core::option::Option>", + "sql": "DemoState" + }, + { + "rust": "core::option::Option", + "sql": "DemoState" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "DemoState[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "DemoState[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::aggregate_tests::demo_schema::DemoState>", + "sql": "DemoState" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::aggregate_tests::demo_schema::DemoState>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::aggregate_tests::demo_schema::DemoState>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "DemoState" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "DemoState" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState" + }, + { + "rust": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "sql": "DemoState[]" + } + ], + "in_fn": "demostate_in", + "in_fn_module_path": "", + "out_fn": "demostate_out", + "out_fn_module_path": "", + "receive_fn": "demostate_recv", + "receive_fn_module_path": "", + "send_fn": "demostate_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "signature_hash": "2e11bf547572f175" + }, + "entity": { + "Type": { + "name": "ElidedType", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 31, + "full_path": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType" + }, + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType[]" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ElidedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ElidedType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::schema_tests::test_schema::ElidedType>", + "sql": "ElidedType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::schema_tests::test_schema::ElidedType>", + "sql": "ElidedType" + }, + { + "rust": "core::option::Option>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option>", + "sql": "ElidedType[]" + }, + { + "rust": "core::option::Option", + "sql": "ElidedType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "ElidedType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "ElidedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::schema_tests::test_schema::ElidedType>", + "sql": "ElidedType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::schema_tests::test_schema::ElidedType>", + "sql": "ElidedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ElidedType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "ElidedType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "sql": "ElidedType[]" + } + ], + "in_fn": "elidedtype_in", + "in_fn_module_path": "", + "out_fn": "elidedtype_out", + "out_fn_module_path": "", + "receive_fn": "elidedtype_recv", + "receive_fn_module_path": "", + "send_fn": "elidedtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": false, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "signature_hash": "a930fcc04b9a4c35" + }, + "entity": { + "Type": { + "name": "JsonEnumType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 154, + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::JsonEnumType>", + "sql": "JsonEnumType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::JsonEnumType>", + "sql": "JsonEnumType" + }, + { + "rust": "core::option::Option>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonEnumType[]" + }, + { + "rust": "core::option::Option", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "JsonEnumType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "JsonEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::JsonEnumType>", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::JsonEnumType>", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "sql": "JsonEnumType[]" + } + ], + "in_fn": "jsonenumtype_in", + "in_fn_module_path": "", + "out_fn": "jsonenumtype_out", + "out_fn_module_path": "", + "receive_fn": "jsonenumtype_recv", + "receive_fn_module_path": "", + "send_fn": "jsonenumtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::JsonType", + "signature_hash": "fc0c36c402d6fec2" + }, + "entity": { + "Type": { + "name": "JsonType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 146, + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::JsonType>", + "sql": "JsonType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::JsonType>", + "sql": "JsonType" + }, + { + "rust": "core::option::Option>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option>", + "sql": "JsonType[]" + }, + { + "rust": "core::option::Option", + "sql": "JsonType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "JsonType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "JsonType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::JsonType>", + "sql": "JsonType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::JsonType>", + "sql": "JsonType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "JsonType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "JsonType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::JsonType", + "sql": "JsonType[]" + } + ], + "in_fn": "jsontype_in", + "in_fn_module_path": "", + "out_fn": "jsontype_out", + "out_fn_module_path": "", + "receive_fn": "jsontype_recv", + "receive_fn_module_path": "", + "send_fn": "jsontype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::NullError", + "signature_hash": "7d77274f55c7aec3" + }, + "entity": { + "Type": { + "name": "NullError", + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 161, + "full_path": "pgrx_tests::tests::fcinfo_tests::NullError", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError" + }, + { + "rust": "&mut pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError[]" + }, + { + "rust": "&pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError" + }, + { + "rust": "&pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullError[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullError[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::fcinfo_tests::NullError>", + "sql": "NullError" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::fcinfo_tests::NullError>", + "sql": "NullError" + }, + { + "rust": "core::option::Option>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullError[]" + }, + { + "rust": "core::option::Option", + "sql": "NullError" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "NullError[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "NullError[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::fcinfo_tests::NullError>", + "sql": "NullError" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::fcinfo_tests::NullError>", + "sql": "NullError" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullError" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "NullError" + }, + { + "rust": "pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError" + }, + { + "rust": "pgrx_tests::tests::fcinfo_tests::NullError", + "sql": "NullError[]" + } + ], + "in_fn": "nullerror_in", + "in_fn_module_path": "", + "out_fn": "nullerror_out", + "out_fn_module_path": "", + "receive_fn": "nullerror_recv", + "receive_fn_module_path": "", + "send_fn": "nullerror_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "signature_hash": "f33fd68c716e8279" + }, + "entity": { + "Type": { + "name": "NullStrict", + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 144, + "full_path": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict" + }, + { + "rust": "&mut pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict[]" + }, + { + "rust": "&pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict" + }, + { + "rust": "&pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullStrict[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullStrict[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::fcinfo_tests::NullStrict>", + "sql": "NullStrict" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::fcinfo_tests::NullStrict>", + "sql": "NullStrict" + }, + { + "rust": "core::option::Option>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option>", + "sql": "NullStrict[]" + }, + { + "rust": "core::option::Option", + "sql": "NullStrict" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "NullStrict[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "NullStrict[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::fcinfo_tests::NullStrict>", + "sql": "NullStrict" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::fcinfo_tests::NullStrict>", + "sql": "NullStrict" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "NullStrict" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "NullStrict" + }, + { + "rust": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict" + }, + { + "rust": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "sql": "NullStrict[]" + } + ], + "in_fn": "nullstrict_in", + "in_fn_module_path": "", + "out_fn": "nullstrict_out", + "out_fn_module_path": "", + "receive_fn": "nullstrict_recv", + "receive_fn_module_path": "", + "send_fn": "nullstrict_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "signature_hash": "639b837f18c22e31" + }, + "entity": { + "Type": { + "name": "OtherType", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 36, + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType" + }, + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType[]" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OtherType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OtherType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::schema_tests::test_schema::OtherType>", + "sql": "OtherType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::schema_tests::test_schema::OtherType>", + "sql": "OtherType" + }, + { + "rust": "core::option::Option>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OtherType[]" + }, + { + "rust": "core::option::Option", + "sql": "OtherType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "OtherType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "OtherType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::schema_tests::test_schema::OtherType>", + "sql": "OtherType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::schema_tests::test_schema::OtherType>", + "sql": "OtherType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OtherType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "OtherType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "sql": "OtherType[]" + } + ], + "in_fn": "othertype_in", + "in_fn_module_path": "", + "out_fn": "othertype_out", + "out_fn_module_path": "", + "receive_fn": "othertype_recv", + "receive_fn_module_path": "", + "send_fn": "othertype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "signature_hash": "f4692ee862eff159" + }, + "entity": { + "Type": { + "name": "OverriddenType", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 41, + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType" + }, + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType[]" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OverriddenType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OverriddenType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::schema_tests::test_schema::OverriddenType>", + "sql": "OverriddenType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::schema_tests::test_schema::OverriddenType>", + "sql": "OverriddenType" + }, + { + "rust": "core::option::Option>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option>", + "sql": "OverriddenType[]" + }, + { + "rust": "core::option::Option", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "OverriddenType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "OverriddenType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::schema_tests::test_schema::OverriddenType>", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::schema_tests::test_schema::OverriddenType>", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "OverriddenType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "OverriddenType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "sql": "OverriddenType[]" + } + ], + "in_fn": "overriddentype_in", + "in_fn_module_path": "", + "out_fn": "overriddentype_out", + "out_fn_module_path": "", + "receive_fn": "overriddentype_recv", + "receive_fn_module_path": "", + "send_fn": "overriddentype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": "CREATE TYPE test_schema.ManuallyRenderedType;" + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "signature_hash": "70aba0ee57a676ab" + }, + "entity": { + "Type": { + "name": "PgrxModuleQualificationTest", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 44, + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "&mut pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "&pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "&pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "core::option::Option>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "core::option::Option", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest" + }, + { + "rust": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "sql": "PgrxModuleQualificationTest[]" + } + ], + "in_fn": "pgrxmodulequalificationtest_in", + "in_fn_module_path": "", + "out_fn": "pgrxmodulequalificationtest_out", + "out_fn_module_path": "", + "receive_fn": null, + "receive_fn_module_path": null, + "send_fn": null, + "send_fn_module_path": null, + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "signature_hash": "1336ee2681dcf830" + }, + "entity": { + "Type": { + "name": "ProximityPart", + "file": "pgrx-tests/src/tests/derive_pgtype_lifetimes.rs", + "line": 19, + "full_path": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "module_path": "pgrx_tests::tests::derive_pgtype_lifetimes", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart" + }, + { + "rust": "&mut pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart[]" + }, + { + "rust": "&pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart" + }, + { + "rust": "&pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ProximityPart[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ProximityPart[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart>", + "sql": "ProximityPart" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart>", + "sql": "ProximityPart" + }, + { + "rust": "core::option::Option>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option>", + "sql": "ProximityPart[]" + }, + { + "rust": "core::option::Option", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "ProximityPart[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "ProximityPart[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart>", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart>", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ProximityPart" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "ProximityPart" + }, + { + "rust": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart" + }, + { + "rust": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "sql": "ProximityPart[]" + } + ], + "in_fn": "proximitypart_in", + "in_fn_module_path": "", + "out_fn": "proximitypart_out", + "out_fn_module_path": "", + "receive_fn": null, + "receive_fn_module_path": null, + "send_fn": null, + "send_fn_module_path": null, + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::RandomData", + "signature_hash": "acdf31f803ed220c" + }, + "entity": { + "Type": { + "name": "RandomData", + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 6, + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData" + }, + { + "rust": "&mut pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData[]" + }, + { + "rust": "&pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData" + }, + { + "rust": "&pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "RandomData[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "RandomData[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::roundtrip_tests::RandomData>", + "sql": "RandomData" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::roundtrip_tests::RandomData>", + "sql": "RandomData" + }, + { + "rust": "core::option::Option>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option>", + "sql": "RandomData[]" + }, + { + "rust": "core::option::Option", + "sql": "RandomData" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "RandomData[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "RandomData[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::roundtrip_tests::RandomData>", + "sql": "RandomData" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::roundtrip_tests::RandomData>", + "sql": "RandomData" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "RandomData" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "RandomData" + }, + { + "rust": "pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData" + }, + { + "rust": "pgrx_tests::tests::roundtrip_tests::RandomData", + "sql": "RandomData[]" + } + ], + "in_fn": "randomdata_in", + "in_fn_module_path": "", + "out_fn": "randomdata_out", + "out_fn_module_path": "", + "receive_fn": "randomdata_recv", + "receive_fn_module_path": "", + "send_fn": "randomdata_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::result_tests::ResultTestsA", + "signature_hash": "a766ab764d98512b" + }, + "entity": { + "Type": { + "name": "ResultTestsA", + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 21, + "full_path": "pgrx_tests::tests::result_tests::ResultTestsA", + "module_path": "pgrx_tests::tests::result_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA" + }, + { + "rust": "&mut pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA[]" + }, + { + "rust": "&pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA" + }, + { + "rust": "&pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ResultTestsA[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ResultTestsA[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::result_tests::ResultTestsA>", + "sql": "ResultTestsA" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::result_tests::ResultTestsA>", + "sql": "ResultTestsA" + }, + { + "rust": "core::option::Option>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option>", + "sql": "ResultTestsA[]" + }, + { + "rust": "core::option::Option", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "ResultTestsA[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "ResultTestsA[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::result_tests::ResultTestsA>", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::result_tests::ResultTestsA>", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA" + }, + { + "rust": "pgrx_tests::tests::result_tests::ResultTestsA", + "sql": "ResultTestsA[]" + } + ], + "in_fn": "resulttestsa_in", + "in_fn_module_path": "", + "out_fn": "resulttestsa_out", + "out_fn_module_path": "", + "receive_fn": "resulttestsa_recv", + "receive_fn_module_path": "", + "send_fn": "resulttestsa_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "signature_hash": "df4b968b08cc6740" + }, + "entity": { + "Type": { + "name": "TestCastType", + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 32, + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType" + }, + { + "rust": "&mut pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType[]" + }, + { + "rust": "&pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType" + }, + { + "rust": "&pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestCastType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestCastType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType>", + "sql": "TestCastType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType>", + "sql": "TestCastType" + }, + { + "rust": "core::option::Option>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestCastType[]" + }, + { + "rust": "core::option::Option", + "sql": "TestCastType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "TestCastType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "TestCastType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType>", + "sql": "TestCastType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType>", + "sql": "TestCastType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestCastType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "TestCastType" + }, + { + "rust": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType" + }, + { + "rust": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "sql": "TestCastType[]" + } + ], + "in_fn": "testcasttype_in", + "in_fn_module_path": "", + "out_fn": "testcasttype_out", + "out_fn_module_path": "", + "receive_fn": "testcasttype_recv", + "receive_fn_module_path": "", + "send_fn": "testcasttype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "signature_hash": "74104dffecfb7da" + }, + "entity": { + "Type": { + "name": "TestType", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 27, + "full_path": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType" + }, + { + "rust": "&mut pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType[]" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType" + }, + { + "rust": "&pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::schema_tests::test_schema::TestType>", + "sql": "TestType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::schema_tests::test_schema::TestType>", + "sql": "TestType" + }, + { + "rust": "core::option::Option>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option>", + "sql": "TestType[]" + }, + { + "rust": "core::option::Option", + "sql": "TestType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "TestType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "TestType[]" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::schema_tests::test_schema::TestType>", + "sql": "TestType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::schema_tests::test_schema::TestType>", + "sql": "TestType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "TestType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "TestType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType" + }, + { + "rust": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "sql": "TestType[]" + } + ], + "in_fn": "testtype_in", + "in_fn_module_path": "", + "out_fn": "testtype_out", + "out_fn_module_path": "", + "receive_fn": "testtype_recv", + "receive_fn_module_path": "", + "send_fn": "testtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "signature_hash": "a2963c2a7f881a9a" + }, + "entity": { + "Type": { + "name": "VarlenaEnumType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 42, + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::VarlenaEnumType>", + "sql": "VarlenaEnumType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::VarlenaEnumType>", + "sql": "VarlenaEnumType" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaEnumType" + }, + { + "rust": "core::option::Option", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::postgres_type_tests::VarlenaEnumType>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::VarlenaEnumType>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::VarlenaEnumType>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "sql": "VarlenaEnumType[]" + } + ], + "in_fn": "varlenaenumtype_in", + "in_fn_module_path": "", + "out_fn": "varlenaenumtype_out", + "out_fn_module_path": "", + "receive_fn": "varlenaenumtype_recv", + "receive_fn_module_path": "", + "send_fn": "varlenaenumtype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Type", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "signature_hash": "71b080814c76b2b6" + }, + "entity": { + "Type": { + "name": "VarlenaType", + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 16, + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "mappings": [ + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType" + }, + { + "rust": "&mut pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType[]" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType" + }, + { + "rust": "&pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaType[]" + }, + { + "rust": "alloc::vec::Vec>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option<&mut pgrx_tests::tests::postgres_type_tests::VarlenaType>", + "sql": "VarlenaType" + }, + { + "rust": "core::option::Option<&pgrx_tests::tests::postgres_type_tests::VarlenaType>", + "sql": "VarlenaType" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType[]" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType" + }, + { + "rust": "core::option::Option>", + "sql": "VarlenaType" + }, + { + "rust": "core::option::Option", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::datum::array::Array", + "sql": "VarlenaType[]" + }, + { + "rust": "pgrx::datum::array::VariadicArray", + "sql": "VarlenaType[]" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena<&pgrx_tests::tests::postgres_type_tests::VarlenaType>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::datum::varlena::PgVarlena", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox<&mut pgrx_tests::tests::postgres_type_tests::VarlenaType>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox<&pgrx_tests::tests::postgres_type_tests::VarlenaType>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType[]" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox>", + "sql": "VarlenaType" + }, + { + "rust": "pgrx::pgbox::PgBox", + "sql": "VarlenaType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType" + }, + { + "rust": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "sql": "VarlenaType[]" + } + ], + "in_fn": "varlenatype_in", + "in_fn_module_path": "", + "out_fn": "varlenatype_out", + "out_fn_module_path": "", + "receive_fn": "varlenatype_recv", + "receive_fn_module_path": "", + "send_fn": "varlenatype_send", + "send_fn_module_path": "", + "to_sql_config": { + "enabled": true, + "content": null + }, + "alignment": null + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_date", + "signature_hash": "db677ff8491deebb" + }, + "entity": { + "Function": { + "name": "accept_date", + "unaliased_name": "accept_date", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_date", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::date::Date) -> pgrx::datum::date::Date" + }, + "fn_args": [ + { + "pattern": "d", + "used_ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 12, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::date::Date", + "signature_hash": "796f237f6dd86c95" + }, + "entity": { + "BuiltinType": "pgrx::datum::date::Date" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "signature_hash": "54c38224bed0b326" + }, + "entity": { + "Function": { + "name": "accept_date_round_trip", + "unaliased_name": "accept_date_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::date::Date) -> pgrx::datum::date::Date" + }, + "fn_args": [ + { + "pattern": "d", + "used_ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 17, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_interval", + "signature_hash": "ad2dca27cd2090d" + }, + "entity": { + "Function": { + "name": "accept_interval", + "unaliased_name": "accept_interval", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_interval", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::interval::Interval) -> pgrx::datum::interval::Interval" + }, + "fn_args": [ + { + "pattern": "interval", + "used_ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::interval::Interval", + "signature_hash": "9a74a509203073cc" + }, + "entity": { + "BuiltinType": "pgrx::datum::interval::Interval" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "signature_hash": "cf683df44ee08d95" + }, + "entity": { + "Function": { + "name": "accept_interval_round_trip", + "unaliased_name": "accept_interval_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::interval::Interval) -> pgrx::datum::interval::Interval" + }, + "fn_args": [ + { + "pattern": "interval", + "used_ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 83, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_date", + "signature_hash": "8021af91e5d9d3c4" + }, + "entity": { + "Function": { + "name": "accept_range_date", + "unaliased_name": "accept_range_date", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_date", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "5ca57bcb12638b7c" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_date_array", + "signature_hash": "31a6c851996a306d" + }, + "entity": { + "Function": { + "name": "accept_range_date_array", + "unaliased_name": "accept_range_date_array", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_date_array", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array>", + "argument_sql": { + "Ok": { + "As": "daterange[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "daterange[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < Range < Date > >", + "full_path": "pgrx::datum::array::Array>", + "module_path": "pgrx::datum::array::Array>", + "argument_sql": { + "Ok": { + "As": "daterange[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Range < Date > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "daterange[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::Array>", + "signature_hash": "55f76c3d9c4c4f04" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::Array>" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "2fbb5395fe5e5503" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_i32", + "signature_hash": "4fb05506cb51613a" + }, + "entity": { + "Function": { + "name": "accept_range_i32", + "unaliased_name": "accept_range_i32", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_i32", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 12, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "ef682a92f4838cb" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_i64", + "signature_hash": "6bb2186bea03712c" + }, + "entity": { + "Function": { + "name": "accept_range_i64", + "unaliased_name": "accept_range_i64", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_i64", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 17, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "61afd6d609c29e2c" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_numeric", + "signature_hash": "2febd9ca7018ea44" + }, + "entity": { + "Function": { + "name": "accept_range_numeric", + "unaliased_name": "accept_range_numeric", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_numeric", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "1f760082cf08ab7c" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_ts", + "signature_hash": "7681b3edf1b584c" + }, + "entity": { + "Function": { + "name": "accept_range_ts", + "unaliased_name": "accept_range_ts", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_ts", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 37, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "537d242c4449e3c7" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::accept_range_tstz", + "signature_hash": "d82adc5d0664aafd" + }, + "entity": { + "Function": { + "name": "accept_range_tstz", + "unaliased_name": "accept_range_tstz", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::accept_range_tstz", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tstzrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tstzrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tstzrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tstzrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < TimestampWithTimeZone >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tstzrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tstzrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < TimestampWithTimeZone >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tstzrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tstzrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 42, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::range::Range", + "signature_hash": "4d03320eeb0b4d3d" + }, + "entity": { + "BuiltinType": "pgrx::datum::range::Range" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::rel_tests::accept_relation", + "signature_hash": "b0d865ce7e16d15" + }, + "entity": { + "Function": { + "name": "accept_relation", + "unaliased_name": "accept_relation", + "module_path": "pgrx_tests::tests::rel_tests", + "full_path": "pgrx_tests::tests::rel_tests::accept_relation", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::rel::PgRelation", + "argument_sql": { + "Ok": { + "As": "regclass" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "regclass" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::rel::PgRelation)" + }, + "fn_args": [ + { + "pattern": "rel", + "used_ty": { + "ty_source": "PgRelation", + "full_path": "pgrx::rel::PgRelation", + "module_path": "pgrx::rel", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::rel::PgRelation", + "argument_sql": { + "Ok": { + "As": "regclass" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "regclass" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/rel_tests.rs", + "line": 12, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::rel::PgRelation", + "signature_hash": "3b12215e695117cd" + }, + "entity": { + "BuiltinType": "pgrx::rel::PgRelation" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_time", + "signature_hash": "3a00d9152e49bcf4" + }, + "entity": { + "Function": { + "name": "accept_time", + "unaliased_name": "accept_time", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_time", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time::Time) -> pgrx::datum::time::Time" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::time::Time", + "signature_hash": "8d1b55f658b70580" + }, + "entity": { + "BuiltinType": "pgrx::datum::time::Time" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "signature_hash": "97342a4af2f448a3" + }, + "entity": { + "Function": { + "name": "accept_time_with_time_zone", + "unaliased_name": "accept_time_with_time_zone", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_with_timezone::TimeWithTimeZone) -> pgrx::datum::time_with_timezone::TimeWithTimeZone" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "TimeWithTimeZone", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimeWithTimeZone", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "signature_hash": "33d05d42f9aa31ce" + }, + "entity": { + "BuiltinType": "pgrx::datum::time_with_timezone::TimeWithTimeZone" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "signature_hash": "2b3aa77e2b4f2ae0" + }, + "entity": { + "Function": { + "name": "accept_timestamp", + "unaliased_name": "accept_timestamp", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp::Timestamp) -> pgrx::datum::time_stamp::Timestamp" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 37, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::time_stamp::Timestamp", + "signature_hash": "e9104a51f96b9018" + }, + "entity": { + "BuiltinType": "pgrx::datum::time_stamp::Timestamp" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "signature_hash": "a58b31bebc6490c3" + }, + "entity": { + "Function": { + "name": "accept_timestamp_with_time_zone", + "unaliased_name": "accept_timestamp_with_time_zone", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone) -> pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 42, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "signature_hash": "5ae66547c22b20ea" + }, + "entity": { + "BuiltinType": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "signature_hash": "5b1a2f960e8427d5" + }, + "entity": { + "Function": { + "name": "accept_timestamp_with_time_zone_datetime_round_trip", + "unaliased_name": "accept_timestamp_with_time_zone_datetime_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone) -> pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 54, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "signature_hash": "55dc2971b80220c9" + }, + "entity": { + "Function": { + "name": "accept_timestamp_with_time_zone_offset_round_trip", + "unaliased_name": "accept_timestamp_with_time_zone_offset_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone) -> pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 47, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::accept_uuid", + "signature_hash": "84c0a9176bb413a1" + }, + "entity": { + "Function": { + "name": "accept_uuid", + "unaliased_name": "accept_uuid", + "module_path": "pgrx_tests::tests::uuid_tests", + "full_path": "pgrx_tests::tests::uuid_tests::accept_uuid", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::uuid::Uuid) -> pgrx::datum::uuid::Uuid" + }, + "fn_args": [ + { + "pattern": "uuid", + "used_ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 17, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::uuid::Uuid", + "signature_hash": "43a1f70a85238bde" + }, + "entity": { + "BuiltinType": "pgrx::datum::uuid::Uuid" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "signature_hash": "5cdefdb8f14bfdc5" + }, + "entity": { + "Function": { + "name": "add_two_numbers", + "unaliased_name": "add_two_numbers", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32) -> i32" + }, + "fn_args": [ + { + "pattern": "a", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "b", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 15, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "i32", + "signature_hash": "9f6b7b3e27aa3c9a" + }, + "entity": { + "BuiltinType": "i32" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_custom_state", + "signature_hash": "a691017da489cf25" + }, + "entity": { + "Function": { + "name": "aggregate_demo_custom_state", + "unaliased_name": "aggregate_demo_custom_state", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_custom_state", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 340, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_percentile_disc", + "signature_hash": "6e9b93e40d3ae1dd" + }, + "entity": { + "Function": { + "name": "aggregate_demo_percentile_disc", + "unaliased_name": "aggregate_demo_percentile_disc", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_percentile_disc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 326, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sub", + "signature_hash": "2a41515e8eda701e" + }, + "entity": { + "Function": { + "name": "aggregate_demo_sub", + "unaliased_name": "aggregate_demo_sub", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sub", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 307, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sum", + "signature_hash": "a123f27223ef0bce" + }, + "entity": { + "Function": { + "name": "aggregate_demo_sum", + "unaliased_name": "aggregate_demo_sum", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 288, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "signature_hash": "f7f33f6dc7b7732" + }, + "entity": { + "Function": { + "name": "aggregate_first_anyelement", + "unaliased_name": "aggregate_first_anyelement", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 380, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result<(), pgrx::spi::SpiError>", + "signature_hash": "c43dd5dc09a1cc85" + }, + "entity": { + "BuiltinType": "core::result::Result<(), pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "signature_hash": "addaf9f2387301ae" + }, + "entity": { + "Function": { + "name": "aggregate_first_json", + "unaliased_name": "aggregate_first_json", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 348, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "signature_hash": "d5242ab1e173661b" + }, + "entity": { + "Function": { + "name": "aggregate_first_jsonb", + "unaliased_name": "aggregate_first_jsonb", + "module_path": "pgrx_tests::tests::aggregate_tests::tests", + "full_path": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 364, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "signature_hash": "870dbde444d5b15" + }, + "entity": { + "Function": { + "name": "anyarray_arg", + "unaliased_name": "anyarray_arg", + "module_path": "pgrx_tests::tests::anyarray_tests", + "full_path": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyarray::AnyArray) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "array", + "used_ty": { + "ty_source": "AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyarray_tests.rs", + "line": 13, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::anyarray::AnyArray", + "signature_hash": "97e4e80a9c6888fc" + }, + "entity": { + "BuiltinType": "pgrx::datum::anyarray::AnyArray" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::json::Json", + "signature_hash": "b96b9f7ae681950f" + }, + "entity": { + "BuiltinType": "pgrx::datum::json::Json" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "signature_hash": "29a95b980b457f2f" + }, + "entity": { + "Function": { + "name": "anyarray_iter_arg", + "unaliased_name": "anyarray_iter_arg", + "module_path": "pgrx_tests::tests::anyarray_tests", + "full_path": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyarray::AnyArray) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "array", + "used_ty": { + "ty_source": "AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyarray_tests.rs", + "line": 19, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "signature_hash": "18ae2910a9c16330" + }, + "entity": { + "Function": { + "name": "anyele_type", + "unaliased_name": "anyele_type", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyelement::AnyElement) -> pgrx_pg_sys::submodules::oids::Oid" + }, + "fn_args": [ + { + "pattern": "x", + "used_ty": { + "ty_source": "pgrx :: datum :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 160, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::anyelement::AnyElement", + "signature_hash": "87e3a742f662c119" + }, + "entity": { + "BuiltinType": "pgrx::datum::anyelement::AnyElement" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx_pg_sys::submodules::oids::Oid", + "signature_hash": "a5d60b722db5a0b2" + }, + "entity": { + "BuiltinType": "pgrx_pg_sys::submodules::oids::Oid" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "signature_hash": "1f9a312c9a54f63" + }, + "entity": { + "Function": { + "name": "anyelement_arg", + "unaliased_name": "anyelement_arg", + "module_path": "pgrx_tests::tests::anyelement_tests", + "full_path": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyelement::AnyElement) -> pgrx::datum::anyelement::AnyElement" + }, + "fn_args": [ + { + "pattern": "element", + "used_ty": { + "ty_source": "AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyelement_tests.rs", + "line": 3, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "signature_hash": "55ec9bcdde6f2a39" + }, + "entity": { + "Function": { + "name": "anynumeric_arg", + "unaliased_name": "anynumeric_arg", + "module_path": "pgrx_tests::tests::anynumeric_tests", + "full_path": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::numeric::AnyNumeric) -> pgrx::datum::numeric::AnyNumeric" + }, + "fn_args": [ + { + "pattern": "numeric", + "used_ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anynumeric_tests.rs", + "line": 3, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::numeric::AnyNumeric", + "signature_hash": "acdc302616695517" + }, + "entity": { + "BuiltinType": "pgrx::datum::numeric::AnyNumeric" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "signature_hash": "5d893969ae6162d2" + }, + "entity": { + "Function": { + "name": "arg_might_be_null", + "unaliased_name": "arg_might_be_null", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "v", + "used_ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 25, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option", + "signature_hash": "669a731ffb4c88c" + }, + "entity": { + "BuiltinType": "core::option::Option" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::arr_into_vec", + "signature_hash": "8faa4ed4128ea01e" + }, + "entity": { + "Function": { + "name": "arr_into_vec", + "unaliased_name": "arr_into_vec", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::arr_into_vec", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < i32 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 138, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::Array", + "signature_hash": "6ed5b1994dede9d0" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::Array" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec", + "signature_hash": "996375575fd65d21" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "signature_hash": "c4f13fff3637a30" + }, + "entity": { + "Function": { + "name": "arr_mapped_vec", + "unaliased_name": "arr_mapped_vec", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < i32 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 132, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "signature_hash": "f4c62c5bf54396eb" + }, + "entity": { + "Function": { + "name": "arr_sort_uniq", + "unaliased_name": "arr_sort_uniq", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < i32 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 144, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_func_is_immutable", + "signature_hash": "da65deecf15ff4e4" + }, + "entity": { + "Function": { + "name": "assert_cast_func_is_immutable", + "unaliased_name": "assert_cast_func_is_immutable", + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "full_path": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_func_is_immutable", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 87, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_is_implicit", + "signature_hash": "5e441e5caf50ab83" + }, + "entity": { + "Function": { + "name": "assert_cast_is_implicit", + "unaliased_name": "assert_cast_is_implicit", + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "full_path": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_is_implicit", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 95, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_add_field", + "signature_hash": "c676b62816e83ebc" + }, + "entity": { + "Function": { + "name": "before_insert_add_field", + "unaliased_name": "before_insert_add_field", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_add_field", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 159, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_field_update", + "signature_hash": "6e09ae3f7da98c6" + }, + "entity": { + "Function": { + "name": "before_insert_field_update", + "unaliased_name": "before_insert_field_update", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_field_update", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 113, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_has_sql_option_set", + "signature_hash": "c97f8be8a5a3b10" + }, + "entity": { + "Function": { + "name": "before_insert_has_sql_option_set", + "unaliased_name": "before_insert_has_sql_option_set", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_has_sql_option_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 506, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "signature_hash": "7139cbb9de977189" + }, + "entity": { + "Function": { + "name": "before_insert_metadata", + "unaliased_name": "before_insert_metadata", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 287, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "signature_hash": "1c407d84953d450f" + }, + "entity": { + "Function": { + "name": "before_insert_metadata_safe", + "unaliased_name": "before_insert_metadata_safe", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 398, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_postgres", + "signature_hash": "40c65b0f9ed163bf" + }, + "entity": { + "Function": { + "name": "before_insert_noop_postgres", + "unaliased_name": "before_insert_noop_postgres", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_postgres", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 544, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_rust", + "signature_hash": "f7e0ef5f03b775e9" + }, + "entity": { + "Function": { + "name": "before_insert_noop_rust", + "unaliased_name": "before_insert_noop_rust", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_rust", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 582, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::before_update_skip", + "signature_hash": "3078e592e305b7da" + }, + "entity": { + "Function": { + "name": "before_update_skip", + "unaliased_name": "before_update_skip", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::before_update_skip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 209, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::blank_function", + "signature_hash": "e31a56ecde28c580" + }, + "entity": { + "Function": { + "name": "blank_function", + "unaliased_name": "blank_function", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::blank_function", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 206, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "signature_hash": "3b084d1bf39655e2" + }, + "entity": { + "Function": { + "name": "can_return_borrowed_str", + "unaliased_name": "can_return_borrowed_str", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 545, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result<(), alloc::boxed::Box>", + "signature_hash": "3556666fdc44ce3d" + }, + "entity": { + "BuiltinType": "core::result::Result<(), alloc::boxed::Box>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "signature_hash": "a4912e7b07887ae2" + }, + "entity": { + "Function": { + "name": "clone_bool", + "unaliased_name": "clone_bool", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "metadata": { + "arguments": [ + { + "type_name": "&bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&bool) -> bool" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ bool", + "full_path": "&bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 66, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&bool", + "signature_hash": "494cba0957ebc257" + }, + "entity": { + "BuiltinType": "&bool" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "bool", + "signature_hash": "2dc59526b9095ef9" + }, + "entity": { + "BuiltinType": "bool" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "signature_hash": "67e2c7b500ccc0c3" + }, + "entity": { + "Function": { + "name": "clone_f64", + "unaliased_name": "clone_f64", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "metadata": { + "arguments": [ + { + "type_name": "&f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&f64) -> f64" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ f64", + "full_path": "&f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 70, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&f64", + "signature_hash": "e808d5577dcfe393" + }, + "entity": { + "BuiltinType": "&f64" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "f64", + "signature_hash": "96f3d68933cc3de6" + }, + "entity": { + "BuiltinType": "f64" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "signature_hash": "63b0cf83591e1134" + }, + "entity": { + "Function": { + "name": "clone_i16", + "unaliased_name": "clone_i16", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "metadata": { + "arguments": [ + { + "type_name": "&i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&i16) -> i16" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ i16", + "full_path": "&i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i16", + "full_path": "i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 68, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&i16", + "signature_hash": "9651ddc8dfa09744" + }, + "entity": { + "BuiltinType": "&i16" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "i16", + "signature_hash": "4abe73e1886e75e3" + }, + "entity": { + "BuiltinType": "i16" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "signature_hash": "aed2b61b527dd9c5" + }, + "entity": { + "Function": { + "name": "clone_i32", + "unaliased_name": "clone_i32", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "metadata": { + "arguments": [ + { + "type_name": "&i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&i32) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ i32", + "full_path": "&i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 69, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&i32", + "signature_hash": "1f93f347bb135c5" + }, + "entity": { + "BuiltinType": "&i32" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "signature_hash": "f07637c144829aba" + }, + "entity": { + "Function": { + "name": "clone_i8", + "unaliased_name": "clone_i8", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "metadata": { + "arguments": [ + { + "type_name": "&i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&i8) -> i8" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ i8", + "full_path": "&i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i8", + "full_path": "i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 67, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&i8", + "signature_hash": "5856f0fb2502944c" + }, + "entity": { + "BuiltinType": "&i8" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "i8", + "signature_hash": "9923f068253ef506" + }, + "entity": { + "BuiltinType": "i8" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "signature_hash": "ab1185e2ae6f1c95" + }, + "entity": { + "Function": { + "name": "clone_oid", + "unaliased_name": "clone_oid", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "metadata": { + "arguments": [ + { + "type_name": "&pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&pgrx_pg_sys::submodules::oids::Oid) -> pgrx_pg_sys::submodules::oids::Oid" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ pg_sys :: Oid", + "full_path": "&pgrx_pg_sys::submodules::oids::Oid", + "module_path": "&pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&pgrx_pg_sys::submodules::oids::Oid", + "signature_hash": "95754d722792dd94" + }, + "entity": { + "BuiltinType": "&pgrx_pg_sys::submodules::oids::Oid" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "signature_hash": "4c78b9d18c2b0b7f" + }, + "entity": { + "Function": { + "name": "clone_point", + "unaliased_name": "clone_point", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "metadata": { + "arguments": [ + { + "type_name": "&pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&pgrx_pg_sys::include::pg18::Point) -> pgrx_pg_sys::include::pg18::Point" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ pg_sys :: Point", + "full_path": "&pgrx_pg_sys::include::pg18::Point", + "module_path": "&pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Point", + "full_path": "pgrx_pg_sys::include::pg18::Point", + "module_path": "pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 71, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&pgrx_pg_sys::include::pg18::Point", + "signature_hash": "5f736021802abe37" + }, + "entity": { + "BuiltinType": "&pgrx_pg_sys::include::pg18::Point" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx_pg_sys::include::pg18::Point", + "signature_hash": "de5fe396e229b682" + }, + "entity": { + "BuiltinType": "pgrx_pg_sys::include::pg18::Point" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "signature_hash": "a4ab38acd5c0267e" + }, + "entity": { + "Function": { + "name": "clone_str", + "unaliased_name": "clone_str", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "metadata": { + "arguments": [ + { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&core::ffi::c_str::CStr) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 77, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&core::ffi::c_str::CStr", + "signature_hash": "185d6085821b5708" + }, + "entity": { + "BuiltinType": "&core::ffi::c_str::CStr" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::ffi::c_str::CString", + "signature_hash": "ce6faa114e4153f4" + }, + "entity": { + "BuiltinType": "alloc::ffi::c_str::CString" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::complex::complex_in", + "signature_hash": "4f104592a7dd491b" + }, + "entity": { + "Function": { + "name": "complex_in", + "unaliased_name": "complex_in", + "module_path": "pgrx_tests::tests::complex", + "full_path": "pgrx_tests::tests::complex::complex_in", + "metadata": { + "arguments": [ + { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&core::ffi::c_str::CStr) -> pgrx::pgbox::PgBox" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "& CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "PgBox < Complex, AllocatedByRust >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/complex.rs", + "line": 53, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::pgbox::PgBox", + "signature_hash": "d3a07a36535a33ca" + }, + "entity": { + "BuiltinType": "pgrx::pgbox::PgBox" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::complex::complex_out", + "signature_hash": "4fd83432af4cb65f" + }, + "entity": { + "Function": { + "name": "complex_out", + "unaliased_name": "complex_out", + "module_path": "pgrx_tests::tests::complex", + "full_path": "pgrx_tests::tests::complex::complex_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::pgbox::PgBox) -> &core::ffi::c_str::CStr" + }, + "fn_args": [ + { + "pattern": "complex", + "used_ty": { + "ty_source": "PgBox < Complex >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/complex.rs", + "line": 70, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::pgbox::PgBox", + "signature_hash": "29c0c3e227671c1" + }, + "entity": { + "BuiltinType": "pgrx::pgbox::PgBox" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "signature_hash": "1ce3cd02495da4f0" + }, + "entity": { + "Function": { + "name": "concat_strings", + "unaliased_name": "concat_strings", + "module_path": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "metadata": { + "arguments": [ + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(alloc::string::String, alloc::string::String) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_operator_tests.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": { + "opname": "==>", + "commutator": null, + "negator": null, + "restrict": null, + "join": null, + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::string::String", + "signature_hash": "439c87dc1fadcb56" + }, + "entity": { + "BuiltinType": "alloc::string::String" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "signature_hash": "3921cf15e44774f" + }, + "entity": { + "Function": { + "name": "convert_timetz_to_time", + "unaliased_name": "convert_timetz_to_time", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_with_timezone::TimeWithTimeZone) -> pgrx::datum::time::Time" + }, + "fn_args": [ + { + "pattern": "t", + "used_ty": { + "ty_source": "TimeWithTimeZone", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::count_nulls", + "signature_hash": "a464d368e5c0d8f5" + }, + "entity": { + "Function": { + "name": "count_nulls", + "unaliased_name": "count_nulls", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::count_nulls", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i32" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 44, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::count_true", + "signature_hash": "1cf0d3665032f663" + }, + "entity": { + "Function": { + "name": "count_true", + "unaliased_name": "count_true", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::count_true", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i32" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < bool >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 39, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::Array", + "signature_hash": "34f36fbd7922166a" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::Array" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::crash", + "signature_hash": "6d500f5b16b2e5fa" + }, + "entity": { + "Function": { + "name": "crash", + "unaliased_name": "crash", + "module_path": "pgrx_tests::tests::pg_try_tests", + "full_path": "pgrx_tests::tests::pg_try_tests::crash", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 15, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "signature_hash": "4835fd5eeb9e03d1" + }, + "entity": { + "Function": { + "name": "create_dog", + "unaliased_name": "create_dog", + "module_path": "pgrx_tests::tests::heap_tuple::returning::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "metadata": { + "arguments": [ + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(alloc::string::String, i32) -> pgrx::heap_tuple::PgHeapTuple" + }, + "fn_args": [ + { + "pattern": "name", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "scritches", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 315, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::heap_tuple::PgHeapTuple", + "signature_hash": "1c7f92283582b1b7" + }, + "entity": { + "BuiltinType": "pgrx::heap_tuple::PgHeapTuple" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "signature_hash": "814ca2ebe1104c3" + }, + "entity": { + "Function": { + "name": "create_or_replace_method", + "unaliased_name": "create_or_replace_method", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "metadata": { + "arguments": [], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> bool" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 138, + "extern_attrs": [ + "CreateOrReplace", + { + "Requires": [ + { + "FullPath": "create_or_replace_method_first" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "signature_hash": "98484c0208dad140" + }, + "entity": { + "Function": { + "name": "create_or_replace_method_first", + "unaliased_name": "create_or_replace_method_first", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "metadata": { + "arguments": [], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> bool" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 125, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": "\n CREATE FUNCTION tests.\"create_or_replace_method\"() RETURNS bool\n STRICT\n LANGUAGE c /* Rust */\n AS '@MODULE_PATHNAME@', 'create_or_replace_method_first_wrapper';\n \n" + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "signature_hash": "7adc45e8ff64e5dc" + }, + "entity": { + "Function": { + "name": "create_or_replace_method_other", + "unaliased_name": "create_or_replace_method_other", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "metadata": { + "arguments": [], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> i32" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 145, + "extern_attrs": [ + "CreateOrReplace" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::composite_type_tests::create_result", + "signature_hash": "f6110d15ead35145" + }, + "entity": { + "Function": { + "name": "create_result", + "unaliased_name": "create_result", + "module_path": "pgrx_tests::tests::composite_type_tests", + "full_path": "pgrx_tests::tests::composite_type_tests::create_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::heap_tuple::PgHeapTuple" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/composite_type_tests.rs", + "line": 11, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "issue1293" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "signature_hash": "22b3e2bfe389df97" + }, + "entity": { + "Function": { + "name": "cstring_roundtrip", + "unaliased_name": "cstring_roundtrip", + "module_path": "pgrx_tests::tests::from_into_datum_tests::tests", + "full_path": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "metadata": { + "arguments": [ + { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&core::ffi::c_str::CStr) -> &core::ffi::c_str::CStr" + }, + "fn_args": [ + { + "pattern": "s", + "used_ty": { + "ty_source": "& CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/from_into_datum_tests.rs", + "line": 36, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::custom_handwritten_to_sql_type", + "signature_hash": "b31f631de736447c" + }, + "entity": { + "Function": { + "name": "custom_handwritten_to_sql_type", + "unaliased_name": "custom_handwritten_to_sql_type", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::custom_handwritten_to_sql_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 162, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "signature_hash": "7fb4a202a205bf29" + }, + "entity": { + "Function": { + "name": "custom_name", + "unaliased_name": "fn_custom", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "metadata": { + "arguments": [], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> bool" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 172, + "extern_attrs": [ + { + "Name": "custom_name" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_extern", + "signature_hash": "9c145ab3b2c60ac9" + }, + "entity": { + "Function": { + "name": "custom_to_sql_extern", + "unaliased_name": "custom_to_sql_extern", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_extern", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 142, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_type", + "signature_hash": "19261b3eecc5db42" + }, + "entity": { + "Function": { + "name": "custom_to_sql_type", + "unaliased_name": "custom_to_sql_type", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 153, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "signature_hash": "792c6cce63ef088d" + }, + "entity": { + "Function": { + "name": "customtextformatserializedenumtype_in", + "unaliased_name": "customtextformatserializedenumtype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < CustomTextFormatSerializedEnumType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 110, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option<&core::ffi::c_str::CStr>", + "signature_hash": "cacaa6f31b2377ca" + }, + "entity": { + "BuiltinType": "core::option::Option<&core::ffi::c_str::CStr>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "signature_hash": "737598ed8c6d77ef" + }, + "entity": { + "Function": { + "name": "customtextformatserializedenumtype_out", + "unaliased_name": "customtextformatserializedenumtype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "CustomTextFormatSerializedEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 110, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "signature_hash": "c0530baf8b44f64d" + }, + "entity": { + "Function": { + "name": "customtextformatserializedenumtype_recv", + "unaliased_name": "customtextformatserializedenumtype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "CustomTextFormatSerializedEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 110, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::internal::Internal", + "signature_hash": "b5b9521d5e503429" + }, + "entity": { + "BuiltinType": "pgrx::datum::internal::Internal" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "signature_hash": "cd55e160f2c3fbae" + }, + "entity": { + "Function": { + "name": "customtextformatserializedenumtype_send", + "unaliased_name": "customtextformatserializedenumtype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "CustomTextFormatSerializedEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 110, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec", + "signature_hash": "fb13d837ebb062ca" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "signature_hash": "3133807d812eb807" + }, + "entity": { + "Function": { + "name": "customtextformatserializedtype_in", + "unaliased_name": "customtextformatserializedtype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < CustomTextFormatSerializedType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 75, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "signature_hash": "c4318df3d0d6bbee" + }, + "entity": { + "Function": { + "name": "customtextformatserializedtype_out", + "unaliased_name": "customtextformatserializedtype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "CustomTextFormatSerializedType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 75, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "signature_hash": "25d798bfffe3842d" + }, + "entity": { + "Function": { + "name": "customtextformatserializedtype_recv", + "unaliased_name": "customtextformatserializedtype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "CustomTextFormatSerializedType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 75, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "signature_hash": "286eb8dc6ad2ff3c" + }, + "entity": { + "Function": { + "name": "customtextformatserializedtype_send", + "unaliased_name": "customtextformatserializedtype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "CustomTextFormatSerializedType", + "full_path": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 75, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::customtype_in", + "signature_hash": "f1b19b990b83fb1d" + }, + "entity": { + "Function": { + "name": "customtype_in", + "unaliased_name": "customtype_in", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::customtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < CustomType < '_ > >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 15, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::customtype_out", + "signature_hash": "4b39807019dc1dee" + }, + "entity": { + "Function": { + "name": "customtype_out", + "unaliased_name": "customtype_out", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::customtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::lifetime_tests::CustomType", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::lifetime_tests::CustomType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "CustomType < '_ >", + "full_path": "pgrx_tests::tests::lifetime_tests::CustomType", + "module_path": "pgrx_tests::tests::lifetime_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::lifetime_tests::CustomType", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 15, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::date_literal_spi_roundtrip", + "signature_hash": "cfe5976749c5a1a" + }, + "entity": { + "Function": { + "name": "date_literal_spi_roundtrip", + "unaliased_name": "date_literal_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::date_literal_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::date_spi_roundtrip", + "signature_hash": "b0854bb6ff69dc18" + }, + "entity": { + "Function": { + "name": "date_spi_roundtrip", + "unaliased_name": "date_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::date_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "signature_hash": "8720c33133827c0b" + }, + "entity": { + "Function": { + "name": "default_argument", + "unaliased_name": "default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32) -> i32" + }, + "fn_args": [ + { + "pattern": "a", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": "99", + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 17, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "signature_hash": "244e6adb740529d1" + }, + "entity": { + "Function": { + "name": "demo_custom_state_demo_custom_state_finalize", + "unaliased_name": "demo_custom_state_demo_custom_state_finalize", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Option < demo_schema :: DemoState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 179, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "signature_hash": "181374f8cf8a7401" + }, + "entity": { + "BuiltinType": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "signature_hash": "e24456f0962b6ffc" + }, + "entity": { + "Function": { + "name": "demo_custom_state_demo_custom_state_state", + "unaliased_name": "demo_custom_state_demo_custom_state_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Option < demo_schema :: DemoState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < demo_schema :: DemoState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 179, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "signature_hash": "80a9f5e9e922fdfe" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sub_name_combine", + "unaliased_name": "demo_ops_demo_sub_name_combine", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "v", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 76, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "signature_hash": "350cf57aa28877cd" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sub_name_moving_state", + "unaliased_name": "demo_ops_demo_sub_name_moving_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "mstate", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 76, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "signature_hash": "88d26a561836b1d8" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sub_name_moving_state_inverse", + "unaliased_name": "demo_ops_demo_sub_name_moving_state_inverse", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "mstate", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 76, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "signature_hash": "4fe6c2019306d1fd" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sub_name_state", + "unaliased_name": "demo_ops_demo_sub_name_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 76, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "signature_hash": "19e23d5651d20605" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sum_name_combine", + "unaliased_name": "demo_ops_demo_sum_name_combine", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "v", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "signature_hash": "52cd36ca1076ed85" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sum_name_moving_state", + "unaliased_name": "demo_ops_demo_sum_name_moving_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "mstate", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "signature_hash": "d93cabadfb0f617a" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sum_name_moving_state_inverse", + "unaliased_name": "demo_ops_demo_sum_name_moving_state_inverse", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "mstate", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "signature_hash": "d33efc40645cd393" + }, + "entity": { + "Function": { + "name": "demo_ops_demo_sum_name_state", + "unaliased_name": "demo_ops_demo_sum_name_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "signature_hash": "bf7ff50b6aeca357" + }, + "entity": { + "Function": { + "name": "demo_percentile_disc_demo_percentile_disc_finalize", + "unaliased_name": "demo_percentile_disc_demo_percentile_disc_finalize", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal, f64, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "percentile", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 126, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "signature_hash": "fb36b2fa28550ffa" + }, + "entity": { + "Function": { + "name": "demo_percentile_disc_demo_percentile_disc_state", + "unaliased_name": "demo_percentile_disc_demo_percentile_disc_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::internal::Internal, i32, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::internal::Internal" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "input", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 126, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "signature_hash": "520904d0d9937282" + }, + "entity": { + "Function": { + "name": "democustomstate_in", + "unaliased_name": "democustomstate_in", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < DemoCustomState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 170, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "signature_hash": "423320af93b9e561" + }, + "entity": { + "Function": { + "name": "democustomstate_out", + "unaliased_name": "democustomstate_out", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoCustomState) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoCustomState", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 170, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "signature_hash": "a6537a255a0b4c52" + }, + "entity": { + "Function": { + "name": "democustomstate_recv", + "unaliased_name": "democustomstate_recv", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::aggregate_tests::DemoCustomState" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "DemoCustomState", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 170, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "signature_hash": "ef6e66017e363e50" + }, + "entity": { + "Function": { + "name": "democustomstate_send", + "unaliased_name": "democustomstate_send", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoCustomState) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoCustomState", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "argument_sql": { + "Ok": { + "As": "DemoCustomState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoCustomState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 170, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demoops_in", + "signature_hash": "1efb58d9f58381c7" + }, + "entity": { + "Function": { + "name": "demoops_in", + "unaliased_name": "demoops_in", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demoops_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < DemoOps >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 14, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demoops_out", + "signature_hash": "b63548ab90b6f6b1" + }, + "entity": { + "Function": { + "name": "demoops_out", + "unaliased_name": "demoops_out", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demoops_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoOps) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoOps", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 14, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "signature_hash": "8b2dcdba2648c90b" + }, + "entity": { + "Function": { + "name": "demoops_recv", + "unaliased_name": "demoops_recv", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::aggregate_tests::DemoOps" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "DemoOps", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 14, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demoops_send", + "signature_hash": "e45dbfb5a5e2b3a4" + }, + "entity": { + "Function": { + "name": "demoops_send", + "unaliased_name": "demoops_send", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demoops_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoOps) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoOps", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoOps", + "argument_sql": { + "Ok": { + "As": "DemoOps" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoOps" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 14, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "signature_hash": "3c87877216b71bee" + }, + "entity": { + "Function": { + "name": "demopercentiledisc_in", + "unaliased_name": "demopercentiledisc_in", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < DemoPercentileDisc >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 122, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "signature_hash": "ae9e61dd86661240" + }, + "entity": { + "Function": { + "name": "demopercentiledisc_out", + "unaliased_name": "demopercentiledisc_out", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoPercentileDisc) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoPercentileDisc", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 122, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "signature_hash": "3c2bc97effe08570" + }, + "entity": { + "Function": { + "name": "demopercentiledisc_recv", + "unaliased_name": "demopercentiledisc_recv", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::aggregate_tests::DemoPercentileDisc" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "DemoPercentileDisc", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 122, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "signature_hash": "2e935c089bebedf9" + }, + "entity": { + "Function": { + "name": "demopercentiledisc_send", + "unaliased_name": "demopercentiledisc_send", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::DemoPercentileDisc) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoPercentileDisc", + "full_path": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "module_path": "pgrx_tests::tests::aggregate_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "argument_sql": { + "Ok": { + "As": "DemoPercentileDisc" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoPercentileDisc" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 122, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "signature_hash": "8c4b4fa1a476536a" + }, + "entity": { + "Function": { + "name": "demostate_in", + "unaliased_name": "demostate_in", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < DemoState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 164, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "signature_hash": "b36f3bfaacddb7f9" + }, + "entity": { + "Function": { + "name": "demostate_out", + "unaliased_name": "demostate_out", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::demo_schema::DemoState) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoState", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 164, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "signature_hash": "acbaab227b982361" + }, + "entity": { + "Function": { + "name": "demostate_recv", + "unaliased_name": "demostate_recv", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::aggregate_tests::demo_schema::DemoState" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "DemoState", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 164, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "signature_hash": "40c7ee9cc8942008" + }, + "entity": { + "Function": { + "name": "demostate_send", + "unaliased_name": "demostate_send", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::aggregate_tests::demo_schema::DemoState) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "DemoState", + "full_path": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "module_path": "pgrx_tests::tests::aggregate_tests::demo_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 164, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "signature_hash": "3e2c759db4ce23cb" + }, + "entity": { + "Function": { + "name": "display_get_arr_nullbitmap", + "unaliased_name": "display_get_arr_nullbitmap", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 109, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::display_uuid", + "signature_hash": "eb6e83f6213b0e2b" + }, + "entity": { + "Function": { + "name": "display_uuid", + "unaliased_name": "display_uuid", + "module_path": "pgrx_tests::tests::uuid_tests", + "full_path": "pgrx_tests::tests::uuid_tests::display_uuid", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::uuid::Uuid) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "uuid", + "used_ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::do_panic", + "signature_hash": "662b8a0a77bdcab8" + }, + "entity": { + "Function": { + "name": "do_panic", + "unaliased_name": "do_panic", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::do_panic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 157, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::dont_delete", + "signature_hash": "8ce85cbfa18faa93" + }, + "entity": { + "Function": { + "name": "dont_delete", + "unaliased_name": "dont_delete", + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::dont_delete", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 620, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::elided_extern_is_elided", + "signature_hash": "d14f26aafdfff89f" + }, + "entity": { + "Function": { + "name": "elided_extern_is_elided", + "unaliased_name": "elided_extern_is_elided", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::elided_extern_is_elided", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 112, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::elided_type_is_elided", + "signature_hash": "d8c6b2350c6be0f0" + }, + "entity": { + "Function": { + "name": "elided_type_is_elided", + "unaliased_name": "elided_type_is_elided", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::elided_type_is_elided", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 127, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "signature_hash": "ab5189644b552cec" + }, + "entity": { + "Function": { + "name": "elidedtype_in", + "unaliased_name": "elidedtype_in", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < ElidedType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 31, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "signature_hash": "e9d2175442d6d3ec" + }, + "entity": { + "Function": { + "name": "elidedtype_out", + "unaliased_name": "elidedtype_out", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::ElidedType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "ElidedType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 31, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "signature_hash": "e4090e4eb42961aa" + }, + "entity": { + "Function": { + "name": "elidedtype_recv", + "unaliased_name": "elidedtype_recv", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::schema_tests::test_schema::ElidedType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "ElidedType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 31, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "signature_hash": "6c41bdfaf38702ef" + }, + "entity": { + "Function": { + "name": "elidedtype_send", + "unaliased_name": "elidedtype_send", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::ElidedType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "ElidedType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "argument_sql": { + "Ok": { + "As": "ElidedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ElidedType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 31, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "signature_hash": "404070d26e7b551c" + }, + "entity": { + "Function": { + "name": "enum_array_roundtrip", + "unaliased_name": "enum_array_roundtrip", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "ArrayTestEnum[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ArrayTestEnum[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "ArrayTestEnum[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ArrayTestEnum[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::array::Array) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "a", + "used_ty": { + "ty_source": "Array < ArrayTestEnum >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "ArrayTestEnum[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ArrayTestEnum[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < ArrayTestEnum > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "ArrayTestEnum[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ArrayTestEnum[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 160, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::err", + "signature_hash": "b97ace6d510fd761" + }, + "entity": { + "Function": { + "name": "err", + "unaliased_name": "err", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::err", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 137, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::example_composite_set", + "signature_hash": "1c818b5a5a2bf919" + }, + "entity": { + "Function": { + "name": "example_composite_set", + "unaliased_name": "example_composite_set", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::example_composite_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, &str)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32, &str)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"idx\"" + }, + { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"value\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "& '_ str", + "signature_hash": "11486efcedb19752" + }, + "entity": { + "BuiltinType": "& '_ str" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::example_generate_series", + "signature_hash": "d63ec523fd6439a9" + }, + "entity": { + "Function": { + "name": "example_generate_series", + "unaliased_name": "example_generate_series", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::example_generate_series", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::iter::SetOfIterator", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32, i32) -> pgrx::iter::SetOfIterator" + }, + "fn_args": [ + { + "pattern": "start", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "end", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "step", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": "1", + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 12, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_guard_tests::extern_func", + "signature_hash": "56483c56643d6b86" + }, + "entity": { + "Function": { + "name": "extern_func", + "unaliased_name": "extern_func", + "module_path": "pgrx_tests::tests::pg_guard_tests", + "full_path": "pgrx_tests::tests::pg_guard_tests::extern_func", + "metadata": { + "arguments": [], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> bool" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_guard_tests.rs", + "line": 13, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "signature_hash": "83cda312d15240e0" + }, + "entity": { + "Function": { + "name": "fake_foo_operator", + "unaliased_name": "fake_foo_operator", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "_a", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "_b", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 114, + "extern_attrs": [], + "search_path": null, + "operator": { + "opname": "=<>=", + "commutator": null, + "negator": null, + "restrict": null, + "join": null, + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "signature_hash": "14e0400e6758bf2c" + }, + "entity": { + "Function": { + "name": "fcinfo_not_named_no_arg", + "unaliased_name": "fcinfo_not_named_no_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "metadata": { + "arguments": [ + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": "pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 138, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "signature_hash": "cb73327560af42bf" + }, + "entity": { + "Function": { + "name": "fcinfo_not_named_one_arg", + "unaliased_name": "fcinfo_not_named_one_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::pgbox::PgBox, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::pgbox::PgBox" + }, + "fn_args": [ + { + "pattern": "_x", + "used_ty": { + "ty_source": "PgBox < pg_sys :: IndexAmRoutine >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": "pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "PgBox < pg_sys :: IndexAmRoutine >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 129, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::pgbox::PgBox", + "signature_hash": "d403591158337da5" + }, + "entity": { + "BuiltinType": "pgrx::pgbox::PgBox" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "signature_hash": "901800efee7d510e" + }, + "entity": { + "Function": { + "name": "fcinfo_renamed_no_arg", + "unaliased_name": "fcinfo_renamed_no_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "metadata": { + "arguments": [ + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "_fcinfo", + "used_ty": { + "ty_source": "pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 124, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "signature_hash": "e00c2010be911b35" + }, + "entity": { + "Function": { + "name": "fcinfo_renamed_one_arg", + "unaliased_name": "fcinfo_renamed_one_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::pgbox::PgBox, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::pgbox::PgBox" + }, + "fn_args": [ + { + "pattern": "_x", + "used_ty": { + "ty_source": "PgBox < pg_sys :: IndexAmRoutine >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "_fcinfo", + "used_ty": { + "ty_source": "pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "PgBox < pg_sys :: IndexAmRoutine >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 116, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::fdw_handler_return", + "signature_hash": "2b2a7d00c714a76" + }, + "entity": { + "Function": { + "name": "fdw_handler_return", + "unaliased_name": "fdw_handler_return", + "module_path": "pgrx_tests::tests::pg_extern_tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::fdw_handler_return", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "fdw_handler" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "fdw_handler" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::pgbox::PgBox" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "PgBox < pg_sys :: FdwRoutine >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "fdw_handler" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "fdw_handler" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 31, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::pgbox::PgBox", + "signature_hash": "5feddb5b0afc0330" + }, + "entity": { + "BuiltinType": "pgrx::pgbox::PgBox" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "signature_hash": "916db3e22660ba20" + }, + "entity": { + "Function": { + "name": "first_any_array_first_any_array_state", + "unaliased_name": "first_any_array_first_any_array_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyarray::AnyArray, pgrx::datum::anyarray::AnyArray, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::anyarray::AnyArray" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "pgrx :: AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "value", + "used_ty": { + "ty_source": "pgrx :: AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pgrx :: AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 248, + "extern_attrs": [ + "ParallelSafe", + "Immutable", + "Strict" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "signature_hash": "8641c99f98b7aa43" + }, + "entity": { + "Function": { + "name": "first_any_element_first_any_element_state", + "unaliased_name": "first_any_element_first_any_element_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::anyelement::AnyElement, pgrx::datum::anyelement::AnyElement, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::anyelement::AnyElement" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "pgrx :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "value", + "used_ty": { + "ty_source": "pgrx :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pgrx :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 266, + "extern_attrs": [ + "ParallelSafe", + "Immutable", + "Strict" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "signature_hash": "f6ebf7532ba2c620" + }, + "entity": { + "Function": { + "name": "first_json_b_first_json_b_state", + "unaliased_name": "first_json_b_first_json_b_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::json::JsonB, pgrx::datum::json::JsonB, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::json::JsonB" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "pgrx :: JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "value", + "used_ty": { + "ty_source": "pgrx :: JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pgrx :: JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 230, + "extern_attrs": [ + "ParallelSafe", + "Immutable", + "Strict" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::json::JsonB", + "signature_hash": "bba0cc1e3f03840c" + }, + "entity": { + "BuiltinType": "pgrx::datum::json::JsonB" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "signature_hash": "4552ae65ba8a054f" + }, + "entity": { + "Function": { + "name": "first_json_first_json_state", + "unaliased_name": "first_json_first_json_state", + "module_path": "pgrx_tests::tests::aggregate_tests", + "full_path": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::json::Json, pgrx::datum::json::Json, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "value", + "used_ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 212, + "extern_attrs": [ + "ParallelSafe", + "Immutable", + "Strict" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::fn_raises_error", + "signature_hash": "6865a44a6dd4ec52" + }, + "entity": { + "Function": { + "name": "fn_raises_error", + "unaliased_name": "fn_raises_error", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::fn_raises_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 219, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "signature_hash": "f3691b86bfdaf01e" + }, + "entity": { + "Function": { + "name": "fn_takes_option", + "unaliased_name": "fn_takes_option", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < CustomTextFormatSerializedType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 101, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "signature_hash": "84a04339cdb7be2f" + }, + "entity": { + "Function": { + "name": "fn_takes_option_enum", + "unaliased_name": "fn_takes_option_enum", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < CustomTextFormatSerializedEnumType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomTextFormatSerializedEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomTextFormatSerializedEnumType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 137, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo", + "signature_hash": "4393f2edd6293d93" + }, + "entity": { + "Function": { + "name": "foo", + "unaliased_name": "foo", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 62, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_composite", + "signature_hash": "6a616f2d017196cc" + }, + "entity": { + "Function": { + "name": "foo_composite", + "unaliased_name": "foo_composite", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_composite", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::heap_tuple::PgHeapTuple" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_default_arg", + "signature_hash": "feea21ce2bf25e6c" + }, + "entity": { + "Function": { + "name": "foo_default_arg", + "unaliased_name": "foo_default_arg", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_default_arg", + "metadata": { + "arguments": [ + { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i64)" + }, + "fn_args": [ + { + "pattern": "_a", + "used_ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": "1", + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 83, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "i64", + "signature_hash": "78570cec398c57dd" + }, + "entity": { + "BuiltinType": "i64" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "signature_hash": "9810575e6c32e936" + }, + "entity": { + "Function": { + "name": "foo_foo_finalize", + "unaliased_name": "foo_foo_finalize", + "module_path": "pgrx_tests::tests::issue1134", + "full_path": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal, f64, f64, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> f64" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "a", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "b", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/issue1134.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::issue1134::foo_foo_state", + "signature_hash": "9bcc4a61ff123efc" + }, + "entity": { + "Function": { + "name": "foo_foo_state", + "unaliased_name": "foo_foo_state", + "module_path": "pgrx_tests::tests::issue1134", + "full_path": "pgrx_tests::tests::issue1134::foo_foo_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::internal::Internal, f64, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::internal::Internal" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "arg_one", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/issue1134.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_i32", + "signature_hash": "d94f59a0effa8d3f" + }, + "entity": { + "Function": { + "name": "foo_i32", + "unaliased_name": "foo_i32", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> i32" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 65, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_option_set", + "signature_hash": "a28c9c3391042f52" + }, + "entity": { + "Function": { + "name": "foo_result_option_set", + "unaliased_name": "foo_result_option_set", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_option_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, alloc::boxed::Box>", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 107, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_set", + "signature_hash": "efe5cefe0397c2bb" + }, + "entity": { + "Function": { + "name": "foo_result_set", + "unaliased_name": "foo_result_set", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, alloc::boxed::Box>", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 100, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_return_null", + "signature_hash": "86ff13be131d916c" + }, + "entity": { + "Function": { + "name": "foo_return_null", + "unaliased_name": "foo_return_null", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_return_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 73, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_set", + "signature_hash": "568305acdd0844e8" + }, + "entity": { + "Function": { + "name": "foo_set", + "unaliased_name": "foo_set", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::SetOfIterator", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::SetOfIterator" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 95, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "signature_hash": "a73d928ba0691662" + }, + "entity": { + "Function": { + "name": "foo_table", + "unaliased_name": "foo_table", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, f64)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "double precision" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32, f64)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"index\"" + }, + { + "ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"value\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 88, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "signature_hash": "72269cf60b31dcb6" + }, + "entity": { + "Function": { + "name": "foo_two_args_return_void", + "unaliased_name": "foo_two_args_return_void", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, alloc::string::String)" + }, + "fn_args": [ + { + "pattern": "_a", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "_b", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 70, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::func_elided_from_schema", + "signature_hash": "5773e8062f3f57dd" + }, + "entity": { + "Function": { + "name": "func_elided_from_schema", + "unaliased_name": "func_elided_from_schema", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::func_elided_from_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": false, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::func_generated_with_custom_sql", + "signature_hash": "80ede273982d7e6c" + }, + "entity": { + "Function": { + "name": "func_generated_with_custom_sql", + "unaliased_name": "func_generated_with_custom_sql", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::func_generated_with_custom_sql", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 24, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::func_in_diff_schema", + "signature_hash": "9bd0e5b2876ab8af" + }, + "entity": { + "Function": { + "name": "func_in_diff_schema", + "unaliased_name": "func_in_diff_schema", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::func_in_diff_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::func_in_diff_schema2", + "signature_hash": "231005962cda868e" + }, + "entity": { + "Function": { + "name": "func_in_diff_schema2", + "unaliased_name": "func_in_diff_schema2", + "module_path": "pgrx_tests::tests::schema_tests", + "full_path": "pgrx_tests::tests::schema_tests::func_in_diff_schema2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": "test_schema", + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 81, + "extern_attrs": [ + { + "Schema": "test_schema" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::cfg_tests::func_test_cfg", + "signature_hash": "76da9151218f5b9f" + }, + "entity": { + "Function": { + "name": "func_test_cfg", + "unaliased_name": "func_test_cfg", + "module_path": "pgrx_tests::tests::cfg_tests", + "full_path": "pgrx_tests::tests::cfg_tests::func_test_cfg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/cfg_tests.rs", + "line": 14, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "signature_hash": "27c45c33bcd4605a" + }, + "entity": { + "Function": { + "name": "func_with_variadic_array_args", + "unaliased_name": "func_with_variadic_array_args", + "module_path": "pgrx_tests::tests::variadic_tests::test", + "full_path": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx::datum::array::VariadicArray<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": true, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str, pgrx::datum::array::VariadicArray<&str>) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "_field", + "used_ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "values", + "used_ty": { + "ty_source": "VariadicArray < '_, & '_ str >", + "full_path": "pgrx::datum::array::VariadicArray<&str>", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": true, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::VariadicArray<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": true, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/variadic_tests.rs", + "line": 15, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&str", + "signature_hash": "fe0fe9a2c2465e46" + }, + "entity": { + "BuiltinType": "&str" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::VariadicArray<&str>", + "signature_hash": "786b7b207c179b23" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::VariadicArray<&str>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::generate_lots_of_dogs", + "signature_hash": "7ce07adaa1e609e0" + }, + "entity": { + "Function": { + "name": "generate_lots_of_dogs", + "unaliased_name": "generate_lots_of_dogs", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::generate_lots_of_dogs", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::SetOfIterator>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::SetOfIterator>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 558, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "signature_hash": "2c2729c3945ced0e" + }, + "entity": { + "Function": { + "name": "get_arr_data_ptr_nth_elem", + "unaliased_name": "get_arr_data_ptr_nth_elem", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::array::Array, i32) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "elem", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 98, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::get_arr_ndim", + "signature_hash": "d2a645cc034f6409" + }, + "entity": { + "Function": { + "name": "get_arr_ndim", + "unaliased_name": "get_arr_ndim", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::get_arr_ndim", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i32" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "libc :: c_int", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 124, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::get_arr_nelems", + "signature_hash": "6ed4d7d907d65a34" + }, + "entity": { + "Function": { + "name": "get_arr_nelems", + "unaliased_name": "get_arr_nelems", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::get_arr_nelems", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i32" + }, + "fn_args": [ + { + "pattern": "arr", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "libc :: c_int", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 92, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "signature_hash": "d13d9a0c76c6ee59" + }, + "entity": { + "Function": { + "name": "get_relation_name", + "unaliased_name": "get_relation_name", + "module_path": "pgrx_tests::tests::pg_try_tests", + "full_path": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::submodules::oids::Oid) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "oid", + "used_ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 31, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "signature_hash": "5b79f1b677c8c00f" + }, + "entity": { + "Function": { + "name": "gets_name_field", + "unaliased_name": "gets_name_field", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "dog", + "used_ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < String >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 53, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option>", + "signature_hash": "d8cc2a142585214b" + }, + "entity": { + "BuiltinType": "core::option::Option>" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option", + "signature_hash": "6525bdb5ea64551b" + }, + "entity": { + "BuiltinType": "core::option::Option" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "signature_hash": "bee71fdab72270d2" + }, + "entity": { + "Function": { + "name": "gets_name_field_default", + "unaliased_name": "gets_name_field_default", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::heap_tuple::PgHeapTuple) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "dog", + "used_ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 61, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "signature_hash": "1324eaf22551342d" + }, + "entity": { + "Function": { + "name": "gets_name_field_default_variadic", + "unaliased_name": "gets_name_field_default_variadic", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::VariadicArray>) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "dogs", + "used_ty": { + "ty_source": ":: pgrx :: datum :: VariadicArray < '_, :: pgrx :: heap_tuple :: PgHeapTuple <\n'_, :: pgrx :: pgbox :: AllocatedByRust > >", + "full_path": "pgrx::datum::array::VariadicArray>", + "module_path": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < String >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 106, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::VariadicArray>", + "signature_hash": "815d95e0f33fd441" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::VariadicArray>" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec", + "signature_hash": "c31506bb8dfff3ed" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "signature_hash": "e3ad96627db9d69b" + }, + "entity": { + "Function": { + "name": "gets_name_field_strict", + "unaliased_name": "gets_name_field_strict", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::heap_tuple::PgHeapTuple) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "dog", + "used_ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 71, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "signature_hash": "8e1919af3ad7a284" + }, + "entity": { + "Function": { + "name": "gets_name_field_strict_variadic", + "unaliased_name": "gets_name_field_strict_variadic", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::VariadicArray>) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "dogs", + "used_ty": { + "ty_source": ":: pgrx :: datum :: VariadicArray < '_, :: pgrx :: heap_tuple :: PgHeapTuple <\n'_, :: pgrx :: pgbox :: AllocatedByRust > >", + "full_path": "pgrx::datum::array::VariadicArray>", + "module_path": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < String >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 125, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "signature_hash": "8d6ecd68a3547164" + }, + "entity": { + "Function": { + "name": "gets_name_field_variadic", + "unaliased_name": "gets_name_field_variadic", + "module_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array", + "full_path": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::VariadicArray>) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "dogs", + "used_ty": { + "ty_source": ":: pgrx :: datum :: VariadicArray < '_, :: pgrx :: heap_tuple :: PgHeapTuple <\n'_, :: pgrx :: pgbox :: AllocatedByRust > >", + "full_path": "pgrx::datum::array::VariadicArray>", + "module_path": "pgrx::datum::array::VariadicArray>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": true, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < String >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 89, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "signature_hash": "dd23481facdbdc87" + }, + "entity": { + "Function": { + "name": "int4_from_json", + "unaliased_name": "int4_from_json", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::json::Json) -> i32" + }, + "fn_args": [ + { + "pattern": "value", + "used_ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": "Implicit", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert", + "signature_hash": "855db6a1f0033b88" + }, + "entity": { + "Function": { + "name": "internal_get_or_insert", + "unaliased_name": "internal_get_or_insert", + "module_path": "pgrx_tests::tests::internal_tests::tests", + "full_path": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/internal_tests.rs", + "line": 45, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_default", + "signature_hash": "8d934145b10ea9ab" + }, + "entity": { + "Function": { + "name": "internal_get_or_insert_default", + "unaliased_name": "internal_get_or_insert_default", + "module_path": "pgrx_tests::tests::internal_tests::tests", + "full_path": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/internal_tests.rs", + "line": 34, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_with", + "signature_hash": "5c26773f1638dc5f" + }, + "entity": { + "Function": { + "name": "internal_get_or_insert_with", + "unaliased_name": "internal_get_or_insert_with", + "module_path": "pgrx_tests::tests::internal_tests::tests", + "full_path": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_with", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/internal_tests.rs", + "line": 56, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::internal_tests::tests::internal_insert", + "signature_hash": "dbad0f4c8db68bcf" + }, + "entity": { + "Function": { + "name": "internal_insert", + "unaliased_name": "internal_insert", + "module_path": "pgrx_tests::tests::internal_tests::tests", + "full_path": "pgrx_tests::tests::internal_tests::tests::internal_insert", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/internal_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::invalid_identifier", + "signature_hash": "b69b724e7cd7acd7" + }, + "entity": { + "Function": { + "name": "invalid_identifier", + "unaliased_name": "invalid_identifier", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::invalid_identifier", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 212, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::is_definer", + "signature_hash": "23a1b00765745e79" + }, + "entity": { + "Function": { + "name": "is_definer", + "unaliased_name": "is_definer", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::is_definer", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 96, + "extern_attrs": [ + "SecurityDefiner" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::is_immutable", + "signature_hash": "250ffefcb97b7284" + }, + "entity": { + "Function": { + "name": "is_immutable", + "unaliased_name": "is_immutable", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::is_immutable", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 74, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::is_invoker", + "signature_hash": "f8e94bc107e9c5c3" + }, + "entity": { + "Function": { + "name": "is_invoker", + "unaliased_name": "is_invoker", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::is_invoker", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 85, + "extern_attrs": [ + "SecurityInvoker" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "signature_hash": "5813bdf3bab0e1c3" + }, + "entity": { + "Function": { + "name": "iterable_named_table", + "unaliased_name": "iterable_named_table", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple, pgrx::heap_tuple::PgHeapTuple)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + }, + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple, pgrx::heap_tuple::PgHeapTuple)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 448, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "signature_hash": "9ccab13046a92716" + }, + "entity": { + "BuiltinType": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "signature_hash": "118ec73d6612456b" + }, + "entity": { + "Function": { + "name": "iterable_named_table_array_elems", + "unaliased_name": "iterable_named_table_array_elems", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(alloc::vec::Vec>, alloc::vec::Vec>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": true + } + }, + { + "Composite": { + "array_brackets": true + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(alloc::vec::Vec>, alloc::vec::Vec>)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 470, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "signature_hash": "91edfd759fe63a2b" + }, + "entity": { + "BuiltinType": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "signature_hash": "7a63b61eec29b77f" + }, + "entity": { + "Function": { + "name": "iterable_named_table_optional_array_elems", + "unaliased_name": "iterable_named_table_optional_array_elems", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(core::option::Option>>, core::option::Option>>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": true + } + }, + { + "Composite": { + "array_brackets": true + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(core::option::Option>>, core::option::Option>>)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >", + "full_path": "core::option::Option>>", + "module_path": "core::option::Option>>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >", + "full_path": "core::option::Option>>", + "module_path": "core::option::Option>>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 481, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >", + "signature_hash": "e0b63d649a612d2f" + }, + "entity": { + "BuiltinType": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "signature_hash": "bf52acb26122720c" + }, + "entity": { + "Function": { + "name": "iterable_named_table_optional_array_optional_elems", + "unaliased_name": "iterable_named_table_optional_array_optional_elems", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(core::option::Option>>>, core::option::Option>>>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": true + } + }, + { + "Composite": { + "array_brackets": true + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(core::option::Option>>>, core::option::Option>>>)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >", + "full_path": "core::option::Option>>>", + "module_path": "core::option::Option>>>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >", + "full_path": "core::option::Option>>>", + "module_path": "core::option::Option>>>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": true + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": true + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 492, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >", + "signature_hash": "51df0a0b7c334c5c" + }, + "entity": { + "BuiltinType": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "signature_hash": "fb4dc73de5b69c90" + }, + "entity": { + "Function": { + "name": "iterable_named_table_optional_elems", + "unaliased_name": "iterable_named_table_optional_elems", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(core::option::Option>, core::option::Option>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + }, + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(core::option::Option>, core::option::Option>)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 459, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "signature_hash": "46efb89cce94c3f" + }, + "entity": { + "BuiltinType": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::iterate_array_with_deny_null", + "signature_hash": "643cbbbee215ce95" + }, + "entity": { + "Function": { + "name": "iterate_array_with_deny_null", + "unaliased_name": "iterate_array_with_deny_null", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::iterate_array_with_deny_null", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array)" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 54, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::json_arg", + "signature_hash": "4ad92d8e4db9ea80" + }, + "entity": { + "Function": { + "name": "json_arg", + "unaliased_name": "json_arg", + "module_path": "pgrx_tests::tests::json_tests", + "full_path": "pgrx_tests::tests::json_tests::json_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::json::Json) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "json", + "used_ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 13, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::jsonb_arg", + "signature_hash": "97ff408496c5d2e0" + }, + "entity": { + "Function": { + "name": "jsonb_arg", + "unaliased_name": "jsonb_arg", + "module_path": "pgrx_tests::tests::json_tests", + "full_path": "pgrx_tests::tests::json_tests::jsonb_arg", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::json::JsonB) -> pgrx::datum::json::JsonB" + }, + "fn_args": [ + { + "pattern": "json", + "used_ty": { + "ty_source": "JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "signature_hash": "1119a0fd9057811b" + }, + "entity": { + "Function": { + "name": "jsonenumtype_in", + "unaliased_name": "jsonenumtype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < JsonEnumType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 154, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "signature_hash": "591c391ba4863cc5" + }, + "entity": { + "Function": { + "name": "jsonenumtype_out", + "unaliased_name": "jsonenumtype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::JsonEnumType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "JsonEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 154, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "signature_hash": "76379e36faaeebd5" + }, + "entity": { + "Function": { + "name": "jsonenumtype_recv", + "unaliased_name": "jsonenumtype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::JsonEnumType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "JsonEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 154, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "signature_hash": "a211fcbb27c4cd08" + }, + "entity": { + "Function": { + "name": "jsonenumtype_send", + "unaliased_name": "jsonenumtype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::JsonEnumType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "JsonEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "argument_sql": { + "Ok": { + "As": "JsonEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 154, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "signature_hash": "7a12e2cac73293bf" + }, + "entity": { + "Function": { + "name": "jsontype_in", + "unaliased_name": "jsontype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < JsonType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 146, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "signature_hash": "e62fe8ffa8991f9b" + }, + "entity": { + "Function": { + "name": "jsontype_out", + "unaliased_name": "jsontype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::JsonType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "JsonType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 146, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "signature_hash": "f294fe3c323eed1f" + }, + "entity": { + "Function": { + "name": "jsontype_recv", + "unaliased_name": "jsontype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::JsonType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "JsonType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 146, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "signature_hash": "aea9eabcf033402a" + }, + "entity": { + "Function": { + "name": "jsontype_send", + "unaliased_name": "jsontype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::JsonType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "JsonType", + "full_path": "pgrx_tests::tests::postgres_type_tests::JsonType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::JsonType", + "argument_sql": { + "Ok": { + "As": "JsonType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "JsonType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 146, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::list_tests::tests::list_length_10", + "signature_hash": "9475d16c937aea9a" + }, + "entity": { + "Function": { + "name": "list_length_10", + "unaliased_name": "list_length_10", + "module_path": "pgrx_tests::tests::list_tests::tests", + "full_path": "pgrx_tests::tests::list_tests::tests::list_length_10", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/list_tests.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::list_tests::tests::list_length_1000", + "signature_hash": "b795aed50a69aafe" + }, + "entity": { + "Function": { + "name": "list_length_1000", + "unaliased_name": "list_length_1000", + "module_path": "pgrx_tests::tests::list_tests::tests", + "full_path": "pgrx_tests::tests::list_tests::tests::list_length_1000", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/list_tests.rs", + "line": 28, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::list_tests::tests::list_length_drained", + "signature_hash": "79077363abdd2fbc" + }, + "entity": { + "Function": { + "name": "list_length_drained", + "unaliased_name": "list_length_drained", + "module_path": "pgrx_tests::tests::list_tests::tests", + "full_path": "pgrx_tests::tests::list_tests::tests::list_length_drained", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/list_tests.rs", + "line": 40, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "signature_hash": "7c261a93290ea06e" + }, + "entity": { + "Function": { + "name": "local_support_fn", + "unaliased_name": "local_support_fn", + "module_path": "pgrx_tests::tests::pg_extern_tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx::datum::internal::Internal" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 45, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "signature_hash": "6ca0035c67498e75" + }, + "entity": { + "Function": { + "name": "my_int4eq", + "unaliased_name": "my_int4eq", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32, i32) -> bool" + }, + "fn_args": [ + { + "pattern": "l", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "r", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 20, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "signature_hash": "af6aa9a309c49dd6" + }, + "entity": { + "Function": { + "name": "negative_default_argument", + "unaliased_name": "negative_default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": "-1", + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 12, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::nop_date", + "signature_hash": "548f74d641e12121" + }, + "entity": { + "Function": { + "name": "nop_date", + "unaliased_name": "nop_date", + "module_path": "pgrx_tests::tests::proptests", + "full_path": "pgrx_tests::tests::proptests::nop_date", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::date::Date) -> pgrx::datum::date::Date" + }, + "fn_args": [ + { + "pattern": "datetime", + "used_ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::nop_time", + "signature_hash": "c9f418dfe8966698" + }, + "entity": { + "Function": { + "name": "nop_time", + "unaliased_name": "nop_time", + "module_path": "pgrx_tests::tests::proptests", + "full_path": "pgrx_tests::tests::proptests::nop_time", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time::Time) -> pgrx::datum::time::Time" + }, + "fn_args": [ + { + "pattern": "datetime", + "used_ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::nop_timestamp", + "signature_hash": "e5816cdf24dd0c23" + }, + "entity": { + "Function": { + "name": "nop_timestamp", + "unaliased_name": "nop_timestamp", + "module_path": "pgrx_tests::tests::proptests", + "full_path": "pgrx_tests::tests::proptests::nop_timestamp", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp::Timestamp) -> pgrx::datum::time_stamp::Timestamp" + }, + "fn_args": [ + { + "pattern": "datetime", + "used_ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::nop_timetz", + "signature_hash": "653979591612f98" + }, + "entity": { + "Function": { + "name": "nop_timetz", + "unaliased_name": "nop_timetz", + "module_path": "pgrx_tests::tests::proptests", + "full_path": "pgrx_tests::tests::proptests::nop_timetz", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_with_timezone::TimeWithTimeZone) -> pgrx::datum::time_with_timezone::TimeWithTimeZone" + }, + "fn_args": [ + { + "pattern": "datetime", + "used_ty": { + "ty_source": "TimeTz", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimeTz", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::from_into_datum_tests::tests::null_string_is_none", + "signature_hash": "ad0feb115a4f077e" + }, + "entity": { + "Function": { + "name": "null_string_is_none", + "unaliased_name": "null_string_is_none", + "module_path": "pgrx_tests::tests::from_into_datum_tests::tests", + "full_path": "pgrx_tests::tests::from_into_datum_tests::tests::null_string_is_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/from_into_datum_tests.rs", + "line": 50, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "signature_hash": "5ab7177b775efa42" + }, + "entity": { + "Function": { + "name": "nullerror_in", + "unaliased_name": "nullerror_in", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < NullError >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 161, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "signature_hash": "4332c06c1ce2aa63" + }, + "entity": { + "Function": { + "name": "nullerror_out", + "unaliased_name": "nullerror_out", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::fcinfo_tests::NullError) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "NullError", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullError", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 161, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "signature_hash": "ad99cca54cf7125b" + }, + "entity": { + "Function": { + "name": "nullerror_recv", + "unaliased_name": "nullerror_recv", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::fcinfo_tests::NullError" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "NullError", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullError", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 161, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "signature_hash": "2f26b95773006340" + }, + "entity": { + "Function": { + "name": "nullerror_send", + "unaliased_name": "nullerror_send", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::fcinfo_tests::NullError) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "NullError", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullError", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullError", + "argument_sql": { + "Ok": { + "As": "NullError" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullError" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 161, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "signature_hash": "610700d40a883808" + }, + "entity": { + "Function": { + "name": "nullstrict_in", + "unaliased_name": "nullstrict_in", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < NullStrict >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 144, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "signature_hash": "e7f6211d9f6547a0" + }, + "entity": { + "Function": { + "name": "nullstrict_out", + "unaliased_name": "nullstrict_out", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::fcinfo_tests::NullStrict) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "NullStrict", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 144, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "signature_hash": "6a56bd6e3e157ef5" + }, + "entity": { + "Function": { + "name": "nullstrict_recv", + "unaliased_name": "nullstrict_recv", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::fcinfo_tests::NullStrict" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "NullStrict", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 144, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "signature_hash": "701006ec5cbbfd00" + }, + "entity": { + "Function": { + "name": "nullstrict_send", + "unaliased_name": "nullstrict_send", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::fcinfo_tests::NullStrict) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "NullStrict", + "full_path": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "argument_sql": { + "Ok": { + "As": "NullStrict" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NullStrict" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 144, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "signature_hash": "cd7725620736999e" + }, + "entity": { + "Function": { + "name": "oid_roundtrip", + "unaliased_name": "oid_roundtrip", + "module_path": "pgrx_tests::tests::oid_tests::tests", + "full_path": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::submodules::oids::Oid) -> pgrx_pg_sys::submodules::oids::Oid" + }, + "fn_args": [ + { + "pattern": "oid", + "used_ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/oid_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::one_col", + "signature_hash": "6dd06ef5ec63c3e9" + }, + "entity": { + "Function": { + "name": "one_col", + "unaliased_name": "one_col", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::one_col", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32,)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32,)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 123, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::one_col_option", + "signature_hash": "af14c51eb54b3f5b" + }, + "entity": { + "Function": { + "name": "one_col_option", + "unaliased_name": "one_col_option", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::one_col_option", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32,)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32,)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 128, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::one_col_result", + "signature_hash": "59659822d730d7" + }, + "entity": { + "Function": { + "name": "one_col_result", + "unaliased_name": "one_col_result", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::one_col_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 133, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::one_col_result_option", + "signature_hash": "97d52634e8ca61c9" + }, + "entity": { + "Function": { + "name": "one_col_result_option", + "unaliased_name": "one_col_result_option", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::one_col_result_option", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 139, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "signature_hash": "3864369723fd1305" + }, + "entity": { + "Function": { + "name": "option_default_argument", + "unaliased_name": "option_default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option<&str>) -> &str" + }, + "fn_args": [ + { + "pattern": "a", + "used_ty": { + "ty_source": "Option < & str >", + "full_path": "core::option::Option<&str>", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": "NULL", + "optional": true, + "metadata": { + "type_name": "core::option::Option<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option<&str>", + "signature_hash": "4eff6ad374196adf" + }, + "entity": { + "BuiltinType": "core::option::Option<&str>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::optional_array_arg", + "signature_hash": "2e0c8ce10482f685" + }, + "entity": { + "Function": { + "name": "optional_array_arg", + "unaliased_name": "optional_array_arg", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::optional_array_arg", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option>) -> f32" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": ":: std :: option :: Option < Array < f32 > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f32", + "full_path": "f32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 49, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option>", + "signature_hash": "bdaab07d8883f151" + }, + "entity": { + "BuiltinType": "core::option::Option>" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "f32", + "signature_hash": "1b28e5877e23d0fd" + }, + "entity": { + "BuiltinType": "f32" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::optional_array_with_default", + "signature_hash": "48b91bb2fd5f149d" + }, + "entity": { + "Function": { + "name": "optional_array_with_default", + "unaliased_name": "optional_array_with_default", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::optional_array_with_default", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option>) -> i32" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": ":: std :: option :: Option < Array < i32 > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 61, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::option::Option>", + "signature_hash": "180362b28bd7562" + }, + "entity": { + "BuiltinType": "core::option::Option>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "signature_hash": "3d30148f13931c0d" + }, + "entity": { + "Function": { + "name": "othertype_in", + "unaliased_name": "othertype_in", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < OtherType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 36, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "signature_hash": "ec1cc090df2dbeab" + }, + "entity": { + "Function": { + "name": "othertype_out", + "unaliased_name": "othertype_out", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::OtherType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "OtherType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 36, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "signature_hash": "4cd27ebf190df3ca" + }, + "entity": { + "Function": { + "name": "othertype_recv", + "unaliased_name": "othertype_recv", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::schema_tests::test_schema::OtherType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "OtherType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 36, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "signature_hash": "21ba33e2e3cdc052" + }, + "entity": { + "Function": { + "name": "othertype_send", + "unaliased_name": "othertype_send", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::OtherType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "OtherType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "argument_sql": { + "Ok": { + "As": "OtherType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OtherType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 36, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "signature_hash": "91fd2092fa29d883" + }, + "entity": { + "Function": { + "name": "overridden_sql_with_fn_name", + "unaliased_name": "overridden_sql_with_fn_name", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "metadata": { + "arguments": [], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> bool" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 108, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": "\n CREATE FUNCTION tests.\"overridden_sql_with_fn_name\"() RETURNS boolean\n STRICT\n LANGUAGE c /* Rust */\n AS '@MODULE_PATHNAME@', 'overridden_sql_with_fn_name_wrapper';\n \n" + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "signature_hash": "b2d2f50d652b542e" + }, + "entity": { + "Function": { + "name": "overriddentype_in", + "unaliased_name": "overriddentype_in", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < OverriddenType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 41, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "signature_hash": "eee3a6d7b8db25f7" + }, + "entity": { + "Function": { + "name": "overriddentype_out", + "unaliased_name": "overriddentype_out", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::OverriddenType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "OverriddenType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 41, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "signature_hash": "4ada74df8b172efd" + }, + "entity": { + "Function": { + "name": "overriddentype_recv", + "unaliased_name": "overriddentype_recv", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::schema_tests::test_schema::OverriddenType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "OverriddenType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 41, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "signature_hash": "3120d80e41da2c76" + }, + "entity": { + "Function": { + "name": "overriddentype_send", + "unaliased_name": "overriddentype_send", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::OverriddenType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "OverriddenType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "argument_sql": { + "Ok": { + "As": "OverriddenType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "OverriddenType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 41, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::panics", + "signature_hash": "d836e0f7657269d6" + }, + "entity": { + "Function": { + "name": "panics", + "unaliased_name": "panics", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::panics", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 85, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::parent", + "signature_hash": "68cc22b15f086418" + }, + "entity": { + "Function": { + "name": "parent", + "unaliased_name": "parent", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::parent", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 97, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::passes_null", + "signature_hash": "7d35669f6a19367c" + }, + "entity": { + "Function": { + "name": "passes_null", + "unaliased_name": "passes_null", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::passes_null", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::nullable::Nullable) -> pgrx::nullable::Nullable" + }, + "fn_args": [ + { + "pattern": "null", + "used_ty": { + "ty_source": "Nullable < i32 >", + "full_path": "pgrx::nullable::Nullable", + "module_path": "pgrx::nullable", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Nullable < i32 >", + "full_path": "pgrx::nullable::Nullable", + "module_path": "pgrx::nullable", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 95, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::nullable::Nullable", + "signature_hash": "1baa913da5560b3c" + }, + "entity": { + "BuiltinType": "pgrx::nullable::Nullable" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc", + "signature_hash": "d90611e8b97d95dc" + }, + "entity": { + "Function": { + "name": "pgbox_alloc", + "unaliased_name": "pgbox_alloc", + "module_path": "pgrx_tests::tests::pgbox_tests::tests", + "full_path": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgbox_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc0", + "signature_hash": "334708beab4c1a01" + }, + "entity": { + "Function": { + "name": "pgbox_alloc0", + "unaliased_name": "pgbox_alloc0", + "module_path": "pgrx_tests::tests::pgbox_tests::tests", + "full_path": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc0", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pgbox_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "signature_hash": "34c7412c5b8112b1" + }, + "entity": { + "Function": { + "name": "pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "unaliased_name": "pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::varlena::PgVarlena, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> i32" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < PgrxModuleQualificationTest >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 142, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "signature_hash": "89c6120222b4d8e2" + }, + "entity": { + "Function": { + "name": "pgrx_module_qualification_test_pgrx_mqt_name_state", + "unaliased_name": "pgrx_module_qualification_test_pgrx_mqt_name_state", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::varlena::PgVarlena, core::option::Option, *mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData) -> pgrx::datum::varlena::PgVarlena" + }, + "fn_args": [ + { + "pattern": "this", + "used_ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < PgrxModuleQualificationTest >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "value", + "used_ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + }, + { + "pattern": "fcinfo", + "used_ty": { + "ty_source": ":: pgrx :: pg_sys :: FunctionCallInfo", + "full_path": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "module_path": "*mut pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "argument_sql": { + "Ok": "Skip" + }, + "return_sql": { + "Ok": { + "One": "Skip" + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < PgrxModuleQualificationTest >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 142, + "extern_attrs": [ + "ParallelSafe", + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "signature_hash": "eb79d5db4ee508b2" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_cmp", + "unaliased_name": "pgrxmodulequalificationtest_cmp", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> i32" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "signature_hash": "9a08d57d23150281" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_eq", + "unaliased_name": "pgrxmodulequalificationtest_eq", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 46, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": "=", + "commutator": "=", + "negator": "<>", + "restrict": "eqsel", + "join": "eqjoinsel", + "hashes": true, + "merges": true + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "signature_hash": "84a59ce81ee9821d" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_ge", + "unaliased_name": "pgrxmodulequalificationtest_ge", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": ">=", + "commutator": "<=", + "negator": "<", + "restrict": "scalargesel", + "join": "scalargejoinsel", + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "signature_hash": "e1217327b7b185c8" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_gt", + "unaliased_name": "pgrxmodulequalificationtest_gt", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": ">", + "commutator": "<", + "negator": "<=", + "restrict": "scalargtsel", + "join": "scalargtjoinsel", + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "signature_hash": "18049263a223e912" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_hash", + "unaliased_name": "pgrxmodulequalificationtest_hash", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> i32" + }, + "fn_args": [ + { + "pattern": "value", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 47, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "signature_hash": "80be0804e8e63903" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_in", + "unaliased_name": "pgrxmodulequalificationtest_in", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < PgrxModuleQualificationTest >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 44, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "signature_hash": "fdf58183eace154b" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_le", + "unaliased_name": "pgrxmodulequalificationtest_le", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": "<=", + "commutator": ">=", + "negator": ">", + "restrict": "scalarlesel", + "join": "scalarlejoinsel", + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "signature_hash": "690ad97a3b26a10" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_lt", + "unaliased_name": "pgrxmodulequalificationtest_lt", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": "<", + "commutator": ">", + "negator": ">=", + "restrict": "scalarltsel", + "join": "scalarltjoinsel", + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "signature_hash": "6cbf9eedb28248e1" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_ne", + "unaliased_name": "pgrxmodulequalificationtest_ne", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest, pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> bool" + }, + "fn_args": [ + { + "pattern": "left", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "right", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 46, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": { + "opname": "<>", + "commutator": "<>", + "negator": "=", + "restrict": "neqsel", + "join": "neqjoinsel", + "hashes": false, + "merges": false + }, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "signature_hash": "71c2db641c28ef8c" + }, + "entity": { + "Function": { + "name": "pgrxmodulequalificationtest_out", + "unaliased_name": "pgrxmodulequalificationtest_out", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "PgrxModuleQualificationTest", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 44, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "signature_hash": "db1ab27ae5e1c7f5" + }, + "entity": { + "Function": { + "name": "proximitypart_in", + "unaliased_name": "proximitypart_in", + "module_path": "pgrx_tests::tests::derive_pgtype_lifetimes", + "full_path": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ProximityPart" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ProximityPart" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < ProximityPart < '_ > >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ProximityPart" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ProximityPart" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/derive_pgtype_lifetimes.rs", + "line": 19, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "signature_hash": "6ab728a60dd2fc4a" + }, + "entity": { + "Function": { + "name": "proximitypart_out", + "unaliased_name": "proximitypart_out", + "module_path": "pgrx_tests::tests::derive_pgtype_lifetimes", + "full_path": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "argument_sql": { + "Ok": { + "As": "ProximityPart" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ProximityPart" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "ProximityPart < '_ >", + "full_path": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "module_path": "pgrx_tests::tests::derive_pgtype_lifetimes", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "argument_sql": { + "Ok": { + "As": "ProximityPart" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ProximityPart" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/derive_pgtype_lifetimes.rs", + "line": 19, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "signature_hash": "6a118a4aeb1d8591" + }, + "entity": { + "Function": { + "name": "randomdata_in", + "unaliased_name": "randomdata_in", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < RandomData >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 6, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "signature_hash": "2dfcd64f9f7917d2" + }, + "entity": { + "Function": { + "name": "randomdata_out", + "unaliased_name": "randomdata_out", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::roundtrip_tests::RandomData) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "RandomData", + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 6, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "signature_hash": "f0145ca1d1cb098b" + }, + "entity": { + "Function": { + "name": "randomdata_recv", + "unaliased_name": "randomdata_recv", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::roundtrip_tests::RandomData" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "RandomData", + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 6, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "signature_hash": "63dc60159735e197" + }, + "entity": { + "Function": { + "name": "randomdata_send", + "unaliased_name": "randomdata_send", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::roundtrip_tests::RandomData) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "RandomData", + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 6, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "signature_hash": "b9b972c37b256b6" + }, + "entity": { + "Function": { + "name": "range_date_rt_bounds", + "unaliased_name": "range_date_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 99, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_date_rt_values", + "signature_hash": "556d1198b10b423b" + }, + "entity": { + "Function": { + "name": "range_date_rt_values", + "unaliased_name": "range_date_rt_values", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_date_rt_values", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Date >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "daterange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "daterange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 94, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "signature_hash": "3bb554ec8640b5ce" + }, + "entity": { + "Function": { + "name": "range_i32_rt_bounds", + "unaliased_name": "range_i32_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 69, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "signature_hash": "f577dfce024d3d" + }, + "entity": { + "Function": { + "name": "range_i32_rt_values", + "unaliased_name": "range_i32_rt_values", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i32 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int4range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int4range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 64, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "signature_hash": "8dacff3f0b52e784" + }, + "entity": { + "Function": { + "name": "range_i64_rt_bounds", + "unaliased_name": "range_i64_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 79, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "signature_hash": "60bcaed5c1580fe4" + }, + "entity": { + "Function": { + "name": "range_i64_rt_values", + "unaliased_name": "range_i64_rt_values", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < i64 >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "int8range" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "int8range" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 74, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "signature_hash": "558c9ef5ba4319c0" + }, + "entity": { + "Function": { + "name": "range_num_rt_bounds", + "unaliased_name": "range_num_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 89, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_num_rt_values", + "signature_hash": "29cc149747021b01" + }, + "entity": { + "Function": { + "name": "range_num_rt_values", + "unaliased_name": "range_num_rt_values", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_num_rt_values", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < AnyNumeric >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "numrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "numrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 84, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "signature_hash": "fe2ff99291c27355" + }, + "entity": { + "Function": { + "name": "range_ts_rt_bounds", + "unaliased_name": "range_ts_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 109, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "signature_hash": "938555d4320fdada" + }, + "entity": { + "Function": { + "name": "range_ts_rt_values", + "unaliased_name": "range_ts_rt_values", + "module_path": "pgrx_tests::tests::range_tests", + "full_path": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::range::Range) -> pgrx::datum::range::Range" + }, + "fn_args": [ + { + "pattern": "range", + "used_ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Range < Timestamp >", + "full_path": "pgrx::datum::range::Range", + "module_path": "pgrx::datum::range::Range", + "argument_sql": { + "Ok": { + "As": "tsrange" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "tsrange" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 104, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::name_tests::func_to_rename", + "signature_hash": "820422555eb52581" + }, + "entity": { + "Function": { + "name": "renamed_func", + "unaliased_name": "func_to_rename", + "module_path": "pgrx_tests::tests::name_tests", + "full_path": "pgrx_tests::tests::name_tests::func_to_rename", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/name_tests.rs", + "line": 12, + "extern_attrs": [ + { + "Name": "renamed_func" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::name_tests::tests::renamed_func", + "signature_hash": "bdf24e493967a7f7" + }, + "entity": { + "Function": { + "name": "renamed_func", + "unaliased_name": "renamed_func", + "module_path": "pgrx_tests::tests::name_tests::tests", + "full_path": "pgrx_tests::tests::name_tests::tests::renamed_func", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/name_tests.rs", + "line": 23, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::result_table_1", + "signature_hash": "e156b91c39ce03a2" + }, + "entity": { + "Function": { + "name": "result_table_1", + "unaliased_name": "result_table_1", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::result_table_1", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::option::Option)>, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::option::Option)>, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 83, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "Option < i32 >", + "signature_hash": "948f875b60a2e6b8" + }, + "entity": { + "BuiltinType": "Option < i32 >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::result_table_2", + "signature_hash": "7ab09393cad88489" + }, + "entity": { + "Function": { + "name": "result_table_2", + "unaliased_name": "result_table_2", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::result_table_2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::option::Option)>, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::option::Option)>, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 91, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::result_table_3", + "signature_hash": "a76bf4fda722c943" + }, + "entity": { + "Function": { + "name": "result_table_3", + "unaliased_name": "result_table_3", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::result_table_3", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::option::Option)>, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::option::Option)>, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 99, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::result_table_4_err", + "signature_hash": "7a6e9f5f917a6582" + }, + "entity": { + "Function": { + "name": "result_table_4_err", + "unaliased_name": "result_table_4_err", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::result_table_4_err", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::option::Option)>, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::option::Option)>, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 107, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::result_table_5_none", + "signature_hash": "621463d4e425f5ea" + }, + "entity": { + "Function": { + "name": "result_table_5_none", + "unaliased_name": "result_table_5_none", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::result_table_5_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::option::Option)>, alloc::boxed::Box>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::option::Option)>, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 115, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::result_tests_a_func", + "signature_hash": "c9d688814852069" + }, + "entity": { + "Function": { + "name": "result_tests_a_func", + "unaliased_name": "result_tests_a_func", + "module_path": "pgrx_tests::tests::result_tests", + "full_path": "pgrx_tests::tests::result_tests::result_tests_a_func", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < ResultTestsA, spi :: Error >", + "full_path": "core::result::Result", + "module_path": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 25, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::resulttestsa_in", + "signature_hash": "55a66f71230cd726" + }, + "entity": { + "Function": { + "name": "resulttestsa_in", + "unaliased_name": "resulttestsa_in", + "module_path": "pgrx_tests::tests::result_tests", + "full_path": "pgrx_tests::tests::result_tests::resulttestsa_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < ResultTestsA >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 21, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::resulttestsa_out", + "signature_hash": "a0e10289383fbb0b" + }, + "entity": { + "Function": { + "name": "resulttestsa_out", + "unaliased_name": "resulttestsa_out", + "module_path": "pgrx_tests::tests::result_tests", + "full_path": "pgrx_tests::tests::result_tests::resulttestsa_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::result_tests::ResultTestsA) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "ResultTestsA", + "full_path": "pgrx_tests::tests::result_tests::ResultTestsA", + "module_path": "pgrx_tests::tests::result_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 21, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "signature_hash": "dc994d74f9cad2d4" + }, + "entity": { + "Function": { + "name": "resulttestsa_recv", + "unaliased_name": "resulttestsa_recv", + "module_path": "pgrx_tests::tests::result_tests", + "full_path": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::result_tests::ResultTestsA" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "ResultTestsA", + "full_path": "pgrx_tests::tests::result_tests::ResultTestsA", + "module_path": "pgrx_tests::tests::result_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 21, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::resulttestsa_send", + "signature_hash": "a7339153a423be3e" + }, + "entity": { + "Function": { + "name": "resulttestsa_send", + "unaliased_name": "resulttestsa_send", + "module_path": "pgrx_tests::tests::result_tests", + "full_path": "pgrx_tests::tests::result_tests::resulttestsa_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::result_tests::ResultTestsA) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "ResultTestsA", + "full_path": "pgrx_tests::tests::result_tests::ResultTestsA", + "module_path": "pgrx_tests::tests::result_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::result_tests::ResultTestsA", + "argument_sql": { + "Ok": { + "As": "ResultTestsA" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "ResultTestsA" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 21, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::return_3pm_mountain_time", + "signature_hash": "ed14ba1aefad753b" + }, + "entity": { + "Function": { + "name": "return_3pm_mountain_time", + "unaliased_name": "return_3pm_mountain_time", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::return_3pm_mountain_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 61, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "signature_hash": "61f674f567359e37" + }, + "entity": { + "Function": { + "name": "return_a_f64_numeric", + "unaliased_name": "return_a_f64_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::datum::numeric::AnyNumeric" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 26, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "signature_hash": "cc8a9cb993f3e22c" + }, + "entity": { + "Function": { + "name": "return_a_u64_numeric", + "unaliased_name": "return_a_u64_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::datum::numeric::AnyNumeric" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 31, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "signature_hash": "190cbf7d3bf3ae14" + }, + "entity": { + "Function": { + "name": "return_an_i32_numeric", + "unaliased_name": "return_an_i32_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::datum::numeric::AnyNumeric" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "signature_hash": "3b4a7e014cee1832" + }, + "entity": { + "Function": { + "name": "return_bytes", + "unaliased_name": "return_bytes", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "metadata": { + "arguments": [], + "retval": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> &[u8]" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ [u8]", + "full_path": "&[u8]", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "&[u8]", + "signature_hash": "9b07359ce5d3f16" + }, + "entity": { + "BuiltinType": "&[u8]" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "signature_hash": "860be37b4632f161" + }, + "entity": { + "Function": { + "name": "return_bytes_slice", + "unaliased_name": "return_bytes_slice", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "metadata": { + "arguments": [ + { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&[u8]) -> &[u8]" + }, + "fn_args": [ + { + "pattern": "bytes", + "used_ty": { + "ty_source": "& [u8]", + "full_path": "&[u8]", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& [u8]", + "full_path": "&[u8]", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 29, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "signature_hash": "6a9168685d2fcbdf" + }, + "entity": { + "Function": { + "name": "return_empty_iterator", + "unaliased_name": "return_empty_iterator", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, &str)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32, &str)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"idx\"" + }, + { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"some_value\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 37, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::return_empty_result_setof_iterator", + "signature_hash": "928c05ad58c1587b" + }, + "entity": { + "Function": { + "name": "return_empty_result_setof_iterator", + "unaliased_name": "return_empty_result_setof_iterator", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::return_empty_result_setof_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, alloc::boxed::Box>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 53, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::return_empty_setof_iterator", + "signature_hash": "5a4b7e08ae8e772d" + }, + "entity": { + "Function": { + "name": "return_empty_setof_iterator", + "unaliased_name": "return_empty_setof_iterator", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::return_empty_setof_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::SetOfIterator", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::SetOfIterator" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 48, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_error_report", + "signature_hash": "a60d0d90c00e6413" + }, + "entity": { + "Function": { + "name": "return_error_report", + "unaliased_name": "return_error_report", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_error_report", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), ErrorReport >", + "full_path": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "module_path": "core::result::Result<(), pgrx_pg_sys::submodules::panic", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 69, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "signature_hash": "35922d29f567743" + }, + "entity": { + "BuiltinType": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "signature_hash": "b3873caf7da1bad7" + }, + "entity": { + "Function": { + "name": "return_eyre_result", + "unaliased_name": "return_eyre_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "eyre :: Result < i32 >", + "full_path": "core::result::Result", + "module_path": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 59, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result", + "signature_hash": "5a3bbfa81163f87c" + }, + "entity": { + "BuiltinType": "core::result::Result" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "signature_hash": "927f6c9cd36bde0a" + }, + "entity": { + "Function": { + "name": "return_eyre_result_error", + "unaliased_name": "return_eyre_result_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "eyre :: Result < i32 >", + "full_path": "core::result::Result", + "module_path": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 64, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "signature_hash": "ef42c69312267916" + }, + "entity": { + "Function": { + "name": "return_none_optional_result", + "unaliased_name": "return_none_optional_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::convert::Infallible>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::convert::Infallible>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < i32 > , Infallible >", + "full_path": "core::result::Result, core::convert::Infallible>", + "module_path": "core::result::Result, core::convert", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, core::convert::Infallible>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 49, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, core::convert::Infallible>", + "signature_hash": "f5629dac133b7ee1" + }, + "entity": { + "BuiltinType": "core::result::Result, core::convert::Infallible>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_result", + "signature_hash": "9d644097bb83c498" + }, + "entity": { + "Function": { + "name": "return_result", + "unaliased_name": "return_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < i32, Infallible >", + "full_path": "core::result::Result", + "module_path": "core::result::Result", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 39, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result", + "signature_hash": "61042b3de2a56b88" + }, + "entity": { + "BuiltinType": "core::result::Result" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "signature_hash": "f11911a08ac6cb05" + }, + "entity": { + "Function": { + "name": "return_result_set_of", + "unaliased_name": "return_result_set_of", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 90, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "signature_hash": "536bf3308bcfa6fe" + }, + "entity": { + "Function": { + "name": "return_result_set_of_error", + "unaliased_name": "return_result_set_of_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 95, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "signature_hash": "24b6c02d2957b129" + }, + "entity": { + "Function": { + "name": "return_result_table_iterator", + "unaliased_name": "return_result_table_iterator", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "signature_hash": "c0971f96710f2792" + }, + "entity": { + "Function": { + "name": "return_result_table_iterator_error", + "unaliased_name": "return_result_table_iterator_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 84, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::return_setof_iterator", + "signature_hash": "30029aae4d287356" + }, + "entity": { + "Function": { + "name": "return_setof_iterator", + "unaliased_name": "return_setof_iterator", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::return_setof_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::SetOfIterator", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::SetOfIterator" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 43, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_some_error", + "signature_hash": "e2799d54d7481980" + }, + "entity": { + "Function": { + "name": "return_some_error", + "unaliased_name": "return_some_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_some_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < i32, Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result>", + "module_path": "core::result::Result>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 54, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result>", + "signature_hash": "f71536d4d27c0ddd" + }, + "entity": { + "BuiltinType": "core::result::Result>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "signature_hash": "e479184c2477cba1" + }, + "entity": { + "Function": { + "name": "return_some_optional_result", + "unaliased_name": "return_some_optional_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, core::convert::Infallible>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, core::convert::Infallible>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < i32 > , Infallible >", + "full_path": "core::result::Result, core::convert::Infallible>", + "module_path": "core::result::Result, core::convert", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, core::convert::Infallible>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 44, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::return_table_iterator", + "signature_hash": "6bca1490ca1834ea" + }, + "entity": { + "Function": { + "name": "return_table_iterator", + "unaliased_name": "return_table_iterator", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::return_table_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, &str)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32, &str)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"idx\"" + }, + { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"some_value\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 29, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single", + "signature_hash": "83297ead69766db6" + }, + "entity": { + "Function": { + "name": "return_table_single", + "unaliased_name": "return_table_single", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple,)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple,)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"dog\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 504, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single_bare", + "signature_hash": "52eb6c1e4b098c94" + }, + "entity": { + "Function": { + "name": "return_table_single_bare", + "unaliased_name": "return_table_single_bare", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single_bare", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple,)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple,)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"dog\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 515, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "signature_hash": "adb98e34c9f90cba" + }, + "entity": { + "Function": { + "name": "return_table_two", + "unaliased_name": "return_table_two", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple, pgrx::heap_tuple::PgHeapTuple)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + }, + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(pgrx::heap_tuple::PgHeapTuple, pgrx::heap_tuple::PgHeapTuple)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 526, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "signature_hash": "5e294080b31d1659" + }, + "entity": { + "Function": { + "name": "return_table_two_optional", + "unaliased_name": "return_table_two_optional", + "module_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests", + "full_path": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(core::option::Option>, core::option::Option>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "Composite": { + "array_brackets": false + } + }, + { + "Composite": { + "array_brackets": false + } + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(core::option::Option>, core::option::Option>)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"dog\"" + }, + { + "ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"cat\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 547, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::return_text_array", + "signature_hash": "e4710db1b1164778" + }, + "entity": { + "Function": { + "name": "return_text_array", + "unaliased_name": "return_text_array", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::return_text_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "alloc::vec::Vec<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> alloc::vec::Vec<&str>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < & '_ str >", + "full_path": "alloc::vec::Vec<&str>", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 82, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec<&str>", + "signature_hash": "a82638c037b2258c" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec<&str>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::return_uuid", + "signature_hash": "e9013289defba7fc" + }, + "entity": { + "Function": { + "name": "return_uuid", + "unaliased_name": "return_uuid", + "module_path": "pgrx_tests::tests::uuid_tests", + "full_path": "pgrx_tests::tests::uuid_tests::return_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::datum::uuid::Uuid" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "signature_hash": "83b71590d4fea492" + }, + "entity": { + "Function": { + "name": "return_vec_bytes", + "unaliased_name": "return_vec_bytes", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "metadata": { + "arguments": [], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> alloc::vec::Vec" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 40, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "signature_hash": "7df2b11320de878b" + }, + "entity": { + "Function": { + "name": "return_vec_subvec", + "unaliased_name": "return_vec_subvec", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(alloc::vec::Vec) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "bytes", + "used_ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 51, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::return_zero_length_vec", + "signature_hash": "f32f86ad3de332ae" + }, + "entity": { + "Function": { + "name": "return_zero_length_vec", + "unaliased_name": "return_zero_length_vec", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::return_zero_length_vec", + "metadata": { + "arguments": [], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> alloc::vec::Vec" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < i32 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 87, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "signature_hash": "3ee1f5cb5c7bfc5c" + }, + "entity": { + "Function": { + "name": "returns_iterator_with_lifetime", + "unaliased_name": "returns_iterator_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::iter::SetOfIterator<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str) -> pgrx::iter::SetOfIterator<&str>" + }, + "fn_args": [ + { + "pattern": "value", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 48, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::returns_lifetime", + "signature_hash": "69d9dc7cfe0e267b" + }, + "entity": { + "Function": { + "name": "returns_lifetime", + "unaliased_name": "returns_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::returns_lifetime", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < CustomType < '_ > >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 26, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "signature_hash": "f6f904a293ab0a8d" + }, + "entity": { + "Function": { + "name": "returns_named_tuple_with_rust_reserved_keyword", + "unaliased_name": "returns_named_tuple_with_rust_reserved_keyword", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(alloc::string::String, i32)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "TEXT" + }, + { + "As": "INT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(alloc::string::String, i32)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"type\"" + }, + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"i\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 66, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "String", + "signature_hash": "ca570e9cfb352cd6" + }, + "entity": { + "BuiltinType": "String" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::returns_none", + "signature_hash": "e66e83d6d7011581" + }, + "entity": { + "Function": { + "name": "returns_none", + "unaliased_name": "returns_none", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::returns_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 80, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::returns_null", + "signature_hash": "c34c19dbe6e5481b" + }, + "entity": { + "Function": { + "name": "returns_null", + "unaliased_name": "returns_null", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::returns_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> pgrx::nullable::Nullable" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Nullable < i32 >", + "full_path": "pgrx::nullable::Nullable", + "module_path": "pgrx::nullable", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::nullable::Nullable", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 90, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::returns_option_ref_with_lifetime", + "signature_hash": "d280644ab28e219a" + }, + "entity": { + "Function": { + "name": "returns_option_ref_with_lifetime", + "unaliased_name": "returns_option_ref_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::returns_option_ref_with_lifetime", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option<&str>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < & '_ str >", + "full_path": "core::option::Option<&str>", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 36, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::returns_ref_with_lifetime", + "signature_hash": "15017eaf27aabfda" + }, + "entity": { + "Function": { + "name": "returns_ref_with_lifetime", + "unaliased_name": "returns_ref_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::returns_ref_with_lifetime", + "metadata": { + "arguments": [], + "retval": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> &str" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 31, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::returns_some", + "signature_hash": "6fe088f45df58c8f" + }, + "entity": { + "Function": { + "name": "returns_some", + "unaliased_name": "returns_some", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::returns_some", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::option::Option" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 75, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "signature_hash": "9a66295751842fbd" + }, + "entity": { + "Function": { + "name": "returns_tuple", + "unaliased_name": "returns_tuple", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, alloc::string::String)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(i32, alloc::string::String)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"id\"" + }, + { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"title\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 105, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "signature_hash": "49bc9644b099071b" + }, + "entity": { + "Function": { + "name": "returns_tuple_with_attributes", + "unaliased_name": "returns_tuple_with_attributes", + "module_path": "pgrx_tests::tests::pg_extern_tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx::iter::TableIterator<(alloc::string::String, alloc::string::String)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "TEXT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx::iter::TableIterator<(alloc::string::String, alloc::string::String)>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"arg\"" + }, + { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"arg2\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 24, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "signature_hash": "6164db26dc7d7cd1" + }, + "entity": { + "Function": { + "name": "returns_tuple_with_lifetime", + "unaliased_name": "returns_tuple_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::iter::TableIterator<(&str, core::option::Option<&str>)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "TEXT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str) -> pgrx::iter::TableIterator<(&str, core::option::Option<&str>)>" + }, + "fn_args": [ + { + "pattern": "value", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"a\"" + }, + { + "ty": { + "ty_source": "Option < & '_ str >", + "full_path": "core::option::Option<&str>", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"b\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 41, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "Option < & '_ str >", + "signature_hash": "862a0409ef2cd394" + }, + "entity": { + "BuiltinType": "Option < & '_ str >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::returns_void", + "signature_hash": "a3d440bcf4685966" + }, + "entity": { + "Function": { + "name": "returns_void", + "unaliased_name": "returns_void", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::returns_void", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 100, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "signature_hash": "a4b71e090a3cb752" + }, + "entity": { + "Function": { + "name": "rt_anynumeric", + "unaliased_name": "rt_anynumeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::numeric::AnyNumeric) -> pgrx::datum::numeric::AnyNumeric" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "AnyNumeric", + "full_path": "pgrx::datum::numeric::AnyNumeric", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::AnyNumeric", + "argument_sql": { + "Ok": { + "As": "NUMERIC" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 147, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "signature_hash": "e2b3b882a645c377" + }, + "entity": { + "Function": { + "name": "rt_array_anynumeric", + "unaliased_name": "rt_array_anynumeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "NUMERIC[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "NUMERIC[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < AnyNumeric > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "NUMERIC[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < AnyNumeric > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "NUMERIC[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 349, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "f33b6d64dac92356" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "signature_hash": "1d354eecbdef5e40" + }, + "entity": { + "Function": { + "name": "rt_array_bool", + "unaliased_name": "rt_array_bool", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < bool > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < bool > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bool[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 324, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "57832a24da047e16" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "signature_hash": "2a0ab5ff9bc8e456" + }, + "entity": { + "Function": { + "name": "rt_array_box", + "unaliased_name": "rt_array_box", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "box[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "box[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < pg_sys :: BOX > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "box[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < pg_sys :: BOX > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "box[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 290, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "a537a2aab8be69b4" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "signature_hash": "b638c25f71c2ff79" + }, + "entity": { + "Function": { + "name": "rt_array_char", + "unaliased_name": "rt_array_char", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "varchar[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "varchar[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < char > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "varchar[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < char > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "varchar[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 227, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "c083e5ae471e0917" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "signature_hash": "f9a1abdba447f7d0" + }, + "entity": { + "Function": { + "name": "rt_array_complex", + "unaliased_name": "rt_array_complex", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "Complex[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "Complex[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>>) -> alloc::vec::Vec>>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < PgBox < Complex > > >", + "full_path": "alloc::vec::Vec>>", + "module_path": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "Complex[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < PgBox < Complex > > >", + "full_path": "alloc::vec::Vec>>", + "module_path": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "Complex[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 469, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>>", + "signature_hash": "34c85a95fc0751ea" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "signature_hash": "f7113bae104ed9fb" + }, + "entity": { + "Function": { + "name": "rt_array_date", + "unaliased_name": "rt_array_date", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "date[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "date[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Date > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "date[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Date > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "date[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 362, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "2a2fdc7f82d280e7" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "signature_hash": "b6ce6c6975a53c81" + }, + "entity": { + "Function": { + "name": "rt_array_f32", + "unaliased_name": "rt_array_f32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < f32 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < f32 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "real[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 330, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "cfac1019233ccb46" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "signature_hash": "cf26dea55a357b00" + }, + "entity": { + "Function": { + "name": "rt_array_f64", + "unaliased_name": "rt_array_f64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "double precision[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "double precision[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < f64 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "double precision[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < f64 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "double precision[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 284, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "c0f24990850f1122" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "signature_hash": "2549b5fd1dacacab" + }, + "entity": { + "Function": { + "name": "rt_array_i16", + "unaliased_name": "rt_array_i16", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "smallint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "smallint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < i16 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "smallint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < i16 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "smallint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 278, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "737510ce22e27a86" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "signature_hash": "d0d341f43dbf0661" + }, + "entity": { + "Function": { + "name": "rt_array_i32", + "unaliased_name": "rt_array_i32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < i32 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < i32 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 318, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "5a95cb03d7404f4e" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "signature_hash": "9c4f2030de0a049b" + }, + "entity": { + "Function": { + "name": "rt_array_i64", + "unaliased_name": "rt_array_i64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < i64 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < i64 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 312, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "8a970e4597029a14" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "signature_hash": "fe7fd8cd8e0e61a9" + }, + "entity": { + "Function": { + "name": "rt_array_i8", + "unaliased_name": "rt_array_i8", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "\"char\"[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "\"char\"[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < i8 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "\"char\"[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < i8 > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "\"char\"[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 233, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "d32fbcd64f249c8c" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "signature_hash": "f4e5c9eccdcba3d1" + }, + "entity": { + "Function": { + "name": "rt_array_interval", + "unaliased_name": "rt_array_interval", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "interval[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "interval[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Interval > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "interval[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Interval > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "interval[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 427, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "fe59d671afc98714" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "signature_hash": "de01f334d604f3d1" + }, + "entity": { + "Function": { + "name": "rt_array_numeric", + "unaliased_name": "rt_array_numeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>>) -> alloc::vec::Vec>>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Numeric < 100, 0 > > >", + "full_path": "alloc::vec::Vec>>", + "module_path": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Numeric < 100, 0 > > >", + "full_path": "alloc::vec::Vec>>", + "module_path": "alloc::vec::Vec>>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 336, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>>", + "signature_hash": "b2adcc035f3e2dfb" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "signature_hash": "c82307b29b04165f" + }, + "entity": { + "Function": { + "name": "rt_array_oid", + "unaliased_name": "rt_array_oid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "oid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "oid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < pg_sys :: Oid > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "oid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < pg_sys :: Oid > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "oid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 265, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "671d1a9fcc9b86c1" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "signature_hash": "64a79343639d9ce8" + }, + "entity": { + "Function": { + "name": "rt_array_point", + "unaliased_name": "rt_array_point", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "point[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "point[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < pg_sys :: Point > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "point[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < pg_sys :: Point > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "point[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 239, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "3297dc399d3bb5e6" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "signature_hash": "4be496596a33cdea" + }, + "entity": { + "Function": { + "name": "rt_array_random_data", + "unaliased_name": "rt_array_random_data", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "RandomData[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "RandomData[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < RandomData > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "RandomData[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < RandomData > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "RandomData[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 455, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "signature_hash": "277f6b41a5a25cf6" + }, + "entity": { + "Function": { + "name": "rt_array_string", + "unaliased_name": "rt_array_string", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < String > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < String > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "TEXT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 252, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "15b03530f61af632" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "signature_hash": "5bb515195d8a5656" + }, + "entity": { + "Function": { + "name": "rt_array_time", + "unaliased_name": "rt_array_time", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Time > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Time > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 401, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "67ac5f1c28accb93" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "signature_hash": "ac8e1a41c07bfc50" + }, + "entity": { + "Function": { + "name": "rt_array_timetz", + "unaliased_name": "rt_array_timetz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < TimeWithTimeZone > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < TimeWithTimeZone > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "time with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 414, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "b8ac1f5b013b83f8" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "signature_hash": "16cf12065cac5552" + }, + "entity": { + "Function": { + "name": "rt_array_ts", + "unaliased_name": "rt_array_ts", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Timestamp > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Timestamp > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 375, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "4ad908f887ebb17f" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "signature_hash": "5be5256c05ec2dac" + }, + "entity": { + "Function": { + "name": "rt_array_tstz", + "unaliased_name": "rt_array_tstz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < TimestampWithTimeZone > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < TimestampWithTimeZone > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 388, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "28c2e970b97ff566" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "signature_hash": "69052bd038cb7e1a" + }, + "entity": { + "Function": { + "name": "rt_array_uuid", + "unaliased_name": "rt_array_uuid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "metadata": { + "arguments": [ + { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "uuid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid[]" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "uuid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid[]" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(alloc::vec::Vec>) -> alloc::vec::Vec>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Vec < Option < Uuid > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "uuid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < Option < Uuid > >", + "full_path": "alloc::vec::Vec>", + "module_path": "alloc::vec::Vec>", + "argument_sql": { + "Ok": { + "As": "uuid[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid[]" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 441, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "alloc::vec::Vec>", + "signature_hash": "8ba071acefc32fb8" + }, + "entity": { + "BuiltinType": "alloc::vec::Vec>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "signature_hash": "f31fe6b0a006938d" + }, + "entity": { + "Function": { + "name": "rt_bool", + "unaliased_name": "rt_bool", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "metadata": { + "arguments": [ + { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(bool) -> bool" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 144, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "signature_hash": "d8126b923f39ff98" + }, + "entity": { + "Function": { + "name": "rt_box", + "unaliased_name": "rt_box", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::include::pg18::BOX", + "argument_sql": { + "Ok": { + "As": "box" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::include::pg18::BOX", + "argument_sql": { + "Ok": { + "As": "box" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::include::pg18::BOX) -> pgrx_pg_sys::include::pg18::BOX" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "pg_sys :: BOX", + "full_path": "pgrx_pg_sys::include::pg18::BOX", + "module_path": "pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::include::pg18::BOX", + "argument_sql": { + "Ok": { + "As": "box" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: BOX", + "full_path": "pgrx_pg_sys::include::pg18::BOX", + "module_path": "pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::include::pg18::BOX", + "argument_sql": { + "Ok": { + "As": "box" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "box" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 132, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx_pg_sys::include::pg18::BOX", + "signature_hash": "f1e807c7658beae0" + }, + "entity": { + "BuiltinType": "pgrx_pg_sys::include::pg18::BOX" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "signature_hash": "e9e4e0967f0356d9" + }, + "entity": { + "Function": { + "name": "rt_bytea", + "unaliased_name": "rt_bytea", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "metadata": { + "arguments": [ + { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&[u8]) -> &[u8]" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ [u8]", + "full_path": "&[u8]", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ [u8]", + "full_path": "&[u8]", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&[u8]", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 116, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "signature_hash": "ceae7ed5540dc2a7" + }, + "entity": { + "Function": { + "name": "rt_char_0", + "unaliased_name": "rt_char_0", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> char" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 117, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "char", + "signature_hash": "d3dd8d57d06c0de9" + }, + "entity": { + "BuiltinType": "char" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "signature_hash": "375bc0e0c6559b68" + }, + "entity": { + "Function": { + "name": "rt_char_1", + "unaliased_name": "rt_char_1", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> char" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 118, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "signature_hash": "575a9a5b757f69a2" + }, + "entity": { + "Function": { + "name": "rt_char_2", + "unaliased_name": "rt_char_2", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> char" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 119, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "signature_hash": "c616495d4f5f453d" + }, + "entity": { + "Function": { + "name": "rt_char_3", + "unaliased_name": "rt_char_3", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> char" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 120, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "signature_hash": "4f2b79b9134d838e" + }, + "entity": { + "Function": { + "name": "rt_char_4", + "unaliased_name": "rt_char_4", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 121, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "signature_hash": "a9c75ed11a8cb59e" + }, + "entity": { + "Function": { + "name": "rt_char_5", + "unaliased_name": "rt_char_5", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 122, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "signature_hash": "c30bd169def151db" + }, + "entity": { + "Function": { + "name": "rt_char_6", + "unaliased_name": "rt_char_6", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 123, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "signature_hash": "ea54efae2dd3c020" + }, + "entity": { + "Function": { + "name": "rt_char_7", + "unaliased_name": "rt_char_7", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 124, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "signature_hash": "2f4b4d6a6c3fd028" + }, + "entity": { + "Function": { + "name": "rt_complex", + "unaliased_name": "rt_complex", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::pgbox::PgBox) -> pgrx::pgbox::PgBox" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "PgBox < Complex >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "PgBox < Complex >", + "full_path": "pgrx::pgbox::PgBox", + "module_path": "pgrx::pgbox::PgBox", + "argument_sql": { + "Ok": { + "As": "Complex" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Complex" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 180, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "signature_hash": "f0976acb70b35444" + }, + "entity": { + "Function": { + "name": "rt_cstr", + "unaliased_name": "rt_cstr", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "metadata": { + "arguments": [ + { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&core::ffi::c_str::CStr) -> &core::ffi::c_str::CStr" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ CStr", + "full_path": "&core::ffi::c_str::CStr", + "module_path": "&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&core::ffi::c_str::CStr", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 153, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "signature_hash": "252337de3abdd541" + }, + "entity": { + "Function": { + "name": "rt_date", + "unaliased_name": "rt_date", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::date::Date) -> pgrx::datum::date::Date" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Date", + "full_path": "pgrx::datum::date::Date", + "module_path": "pgrx::datum::date", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::date::Date", + "argument_sql": { + "Ok": { + "As": "date" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "date" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 155, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "signature_hash": "e67da6b423447750" + }, + "entity": { + "Function": { + "name": "rt_f32", + "unaliased_name": "rt_f32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "metadata": { + "arguments": [ + { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(f32) -> f32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "f32", + "full_path": "f32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f32", + "full_path": "f32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 145, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "signature_hash": "2a9c9466969a3f57" + }, + "entity": { + "Function": { + "name": "rt_f64", + "unaliased_name": "rt_f64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "metadata": { + "arguments": [ + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(f64) -> f64" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 131, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "signature_hash": "a0e6192fe671e86e" + }, + "entity": { + "Function": { + "name": "rt_i16", + "unaliased_name": "rt_i16", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "metadata": { + "arguments": [ + { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i16) -> i16" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i16", + "full_path": "i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i16", + "full_path": "i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 130, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "signature_hash": "f1026e44ab6083ec" + }, + "entity": { + "Function": { + "name": "rt_i32", + "unaliased_name": "rt_i32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 142, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "signature_hash": "ff3f4d0e8513f017" + }, + "entity": { + "Function": { + "name": "rt_i64", + "unaliased_name": "rt_i64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "metadata": { + "arguments": [ + { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i64) -> i64" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 141, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "signature_hash": "6a5e31de775b294d" + }, + "entity": { + "Function": { + "name": "rt_i8", + "unaliased_name": "rt_i8", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "metadata": { + "arguments": [ + { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i8) -> i8" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i8", + "full_path": "i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i8", + "full_path": "i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 125, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "signature_hash": "caf75dbd4014c32f" + }, + "entity": { + "Function": { + "name": "rt_interval", + "unaliased_name": "rt_interval", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::interval::Interval) -> pgrx::datum::interval::Interval" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Interval", + "full_path": "pgrx::datum::interval::Interval", + "module_path": "pgrx::datum::interval", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::interval::Interval", + "argument_sql": { + "Ok": { + "As": "interval" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "interval" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 170, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "signature_hash": "e3bb707f198f07d1" + }, + "entity": { + "Function": { + "name": "rt_numeric", + "unaliased_name": "rt_numeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::numeric::Numeric<100, 0>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::numeric::Numeric<100, 0>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::numeric::Numeric<100, 0>) -> pgrx::datum::numeric::Numeric<100, 0>" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Numeric < 100, 0 >", + "full_path": "pgrx::datum::numeric::Numeric<100, 0>", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::Numeric<100, 0>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Numeric < 100, 0 >", + "full_path": "pgrx::datum::numeric::Numeric<100, 0>", + "module_path": "pgrx::datum::numeric", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::numeric::Numeric<100, 0>", + "argument_sql": { + "Ok": { + "As": "NUMERIC(100)" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "NUMERIC(100)" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 146, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::numeric::Numeric<100, 0>", + "signature_hash": "74f600c89fcef946" + }, + "entity": { + "BuiltinType": "pgrx::datum::numeric::Numeric<100, 0>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "signature_hash": "1aee94f80f7fc09c" + }, + "entity": { + "Function": { + "name": "rt_oid", + "unaliased_name": "rt_oid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::submodules::oids::Oid) -> pgrx_pg_sys::submodules::oids::Oid" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Oid", + "full_path": "pgrx_pg_sys::submodules::oids::Oid", + "module_path": "pgrx_pg_sys::submodules::oids", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::oids::Oid", + "argument_sql": { + "Ok": { + "As": "oid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "oid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 128, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "signature_hash": "1588e3bb966c611a" + }, + "entity": { + "Function": { + "name": "rt_point", + "unaliased_name": "rt_point", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::include::pg18::Point) -> pgrx_pg_sys::include::pg18::Point" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "pg_sys :: Point", + "full_path": "pgrx_pg_sys::include::pg18::Point", + "module_path": "pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: Point", + "full_path": "pgrx_pg_sys::include::pg18::Point", + "module_path": "pgrx_pg_sys::include::pg18", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::include::pg18::Point", + "argument_sql": { + "Ok": { + "As": "point" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "point" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 126, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "signature_hash": "4a03a2338b07f96e" + }, + "entity": { + "Function": { + "name": "rt_random_data", + "unaliased_name": "rt_random_data", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::roundtrip_tests::RandomData) -> pgrx_tests::tests::roundtrip_tests::RandomData" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "RandomData", + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "RandomData", + "full_path": "pgrx_tests::tests::roundtrip_tests::RandomData", + "module_path": "pgrx_tests::tests::roundtrip_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::roundtrip_tests::RandomData", + "argument_sql": { + "Ok": { + "As": "RandomData" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "RandomData" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 179, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "signature_hash": "4c75952773777d75" + }, + "entity": { + "Function": { + "name": "rt_refstr", + "unaliased_name": "rt_refstr", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str) -> &str" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 143, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "signature_hash": "53a8434d2d07759e" + }, + "entity": { + "Function": { + "name": "rt_string", + "unaliased_name": "rt_string", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "metadata": { + "arguments": [ + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(alloc::string::String) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 127, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "signature_hash": "4308bc50a22f5143" + }, + "entity": { + "Function": { + "name": "rt_time", + "unaliased_name": "rt_time", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time::Time) -> pgrx::datum::time::Time" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Time", + "full_path": "pgrx::datum::time::Time", + "module_path": "pgrx::datum::time", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time::Time", + "argument_sql": { + "Ok": { + "As": "time" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 163, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "signature_hash": "276d81dde54a6a9f" + }, + "entity": { + "Function": { + "name": "rt_timetz", + "unaliased_name": "rt_timetz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_with_timezone::TimeWithTimeZone) -> pgrx::datum::time_with_timezone::TimeWithTimeZone" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "TimeWithTimeZone", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimeWithTimeZone", + "full_path": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "module_path": "pgrx::datum::time_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "argument_sql": { + "Ok": { + "As": "time with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "time with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 164, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "signature_hash": "e05004438b769ed3" + }, + "entity": { + "Function": { + "name": "rt_ts", + "unaliased_name": "rt_ts", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp::Timestamp) -> pgrx::datum::time_stamp::Timestamp" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Timestamp", + "full_path": "pgrx::datum::time_stamp::Timestamp", + "module_path": "pgrx::datum::time_stamp", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp::Timestamp", + "argument_sql": { + "Ok": { + "As": "timestamp" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 156, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "signature_hash": "1f80f2b0f75346f0" + }, + "entity": { + "Function": { + "name": "rt_tstz", + "unaliased_name": "rt_tstz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone) -> pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TimestampWithTimeZone", + "full_path": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "module_path": "pgrx::datum::time_stamp_with_timezone", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "argument_sql": { + "Ok": { + "As": "timestamp with time zone" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "timestamp with time zone" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 157, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "signature_hash": "c845b22205d883b2" + }, + "entity": { + "Function": { + "name": "rt_uuid", + "unaliased_name": "rt_uuid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::uuid::Uuid) -> pgrx::datum::uuid::Uuid" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Uuid", + "full_path": "pgrx::datum::uuid::Uuid", + "module_path": "pgrx::datum::uuid", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::uuid::Uuid", + "argument_sql": { + "Ok": { + "As": "uuid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "uuid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 172, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "signature_hash": "e8e41791bdf8acc1" + }, + "entity": { + "Function": { + "name": "rt_xid", + "unaliased_name": "rt_xid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "argument_sql": { + "Ok": { + "As": "xid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "xid" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "argument_sql": { + "Ok": { + "As": "xid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "xid" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_pg_sys::submodules::transaction_id::TransactionId) -> pgrx_pg_sys::submodules::transaction_id::TransactionId" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "pg_sys :: TransactionId", + "full_path": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "module_path": "pgrx_pg_sys::submodules::transaction_id", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "argument_sql": { + "Ok": { + "As": "xid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "xid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "pg_sys :: TransactionId", + "full_path": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "module_path": "pgrx_pg_sys::submodules::transaction_id", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "argument_sql": { + "Ok": { + "As": "xid" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "xid" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 129, + "extern_attrs": [ + { + "Requires": [ + { + "Name": "create_complex_type" + } + ] + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "signature_hash": "bb617798c1dc1d0e" + }, + "entity": { + "BuiltinType": "pgrx_pg_sys::submodules::transaction_id::TransactionId" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::same_name", + "signature_hash": "40f3dcfbda395377" + }, + "entity": { + "Function": { + "name": "same_name", + "unaliased_name": "same_name", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::same_name", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str) -> &str" + }, + "fn_args": [ + { + "pattern": "same_name", + "used_ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 110, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "signature_hash": "d1ec53dd2aabbbf5" + }, + "entity": { + "Function": { + "name": "scritch", + "unaliased_name": "scritch", + "module_path": "pgrx_tests::tests::heap_tuple::returning::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option>) -> core::option::Option>" + }, + "fn_args": [ + { + "pattern": "maybe_dog", + "used_ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 325, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "signature_hash": "d899c18a9cf8ab91" + }, + "entity": { + "Function": { + "name": "scritch_strict", + "unaliased_name": "scritch_strict", + "module_path": "pgrx_tests::tests::heap_tuple::returning::singleton", + "full_path": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::heap_tuple::PgHeapTuple) -> pgrx::heap_tuple::PgHeapTuple" + }, + "fn_args": [ + { + "pattern": "dog", + "used_ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "full_path": "pgrx::heap_tuple::PgHeapTuple", + "module_path": "pgrx::heap_tuple::PgHeapTuple", + "argument_sql": { + "Ok": { + "Composite": { + "array_brackets": false + } + } + }, + "return_sql": { + "Ok": { + "One": { + "Composite": { + "array_brackets": false + } + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 340, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "signature_hash": "27443572f02a976a" + }, + "entity": { + "Function": { + "name": "select_a_numeric", + "unaliased_name": "select_a_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 36, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "signature_hash": "850b20bc98b6347a" + }, + "entity": { + "Function": { + "name": "serde_serialize_array_i32", + "unaliased_name": "serde_serialize_array_i32", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 72, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "signature_hash": "89242d5482cbd7d8" + }, + "entity": { + "Function": { + "name": "serde_serialize_array_i32_deny_null", + "unaliased_name": "serde_serialize_array_i32_deny_null", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> pgrx::datum::json::Json" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 77, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "signature_hash": "e5ef04b473de71a4" + }, + "entity": { + "Function": { + "name": "spi_can_read_binary_coercible_types", + "unaliased_name": "spi_can_read_binary_coercible_types", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < Option < pgrx :: Inet > >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 509, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, pgrx::spi::SpiError>", + "signature_hash": "8d31483b6db08851" + }, + "entity": { + "BuiltinType": "core::result::Result, pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "signature_hash": "35cbdd7645d61554" + }, + "entity": { + "Function": { + "name": "spi_can_read_domain_types", + "unaliased_name": "spi_can_read_domain_types", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < Option < String > >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 496, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, pgrx::spi::SpiError>", + "signature_hash": "3a2381fa91da083d" + }, + "entity": { + "BuiltinType": "core::result::Result, pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "signature_hash": "2dea4853d90dc9a4" + }, + "entity": { + "Function": { + "name": "spi_can_read_domain_types_based_on_domain_types", + "unaliased_name": "spi_can_read_domain_types_based_on_domain_types", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < Option < String > >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 502, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "signature_hash": "225823a9f9315abf" + }, + "entity": { + "Function": { + "name": "spi_in_iterator", + "unaliased_name": "spi_in_iterator", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result)>, pgrx::spi::SpiError>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result)>, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"id\"" + }, + { + "ty": { + "ty_source": "Option < String >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "\"relname\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 280, + "extern_attrs": [ + { + "ShouldPanic": "column \"cause_an_error\" does not exist" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "Option < String >", + "signature_hash": "a60e75ce2446fefb" + }, + "entity": { + "BuiltinType": "Option < String >" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "signature_hash": "fc1ccf74da681888" + }, + "entity": { + "Function": { + "name": "spi_in_setof", + "unaliased_name": "spi_in_setof", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result>, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result>, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "Option < String >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 299, + "extern_attrs": [ + { + "ShouldPanic": "column \"cause_an_error\" does not exist" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "signature_hash": "38cc3d3404ce7056" + }, + "entity": { + "Function": { + "name": "split_set_with_borrow", + "unaliased_name": "split_set_with_borrow", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::iter::SetOfIterator<&str>", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "SetOf": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str, &str) -> pgrx::iter::SetOfIterator<&str>" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "pattern", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "SetOf": { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 70, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "signature_hash": "5e3741b428523b1a" + }, + "entity": { + "Function": { + "name": "split_table_with_borrow", + "unaliased_name": "split_table_with_borrow", + "module_path": "pgrx_tests::tests::srf_tests", + "full_path": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::iter::TableIterator<(i32, &str)>", + "argument_sql": { + "Err": "Table" + }, + "return_sql": { + "Ok": { + "Table": [ + { + "As": "INT" + }, + { + "As": "TEXT" + } + ] + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str, &str) -> pgrx::iter::TableIterator<(i32, &str)>" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "pattern", + "used_ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Iterated": { + "tys": [ + { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"i\"" + }, + { + "ty": { + "ty_source": "& '_ str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "\"s\"" + } + ] + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 75, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::sum_array_i32", + "signature_hash": "a4b8217e8305d388" + }, + "entity": { + "Function": { + "name": "sum_array", + "unaliased_name": "sum_array_i32", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::sum_array_i32", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i32" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i32 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "INT[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 17, + "extern_attrs": [ + { + "Name": "sum_array" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::sum_array_i64", + "signature_hash": "ac95e7db66d601b7" + }, + "entity": { + "Function": { + "name": "sum_array", + "unaliased_name": "sum_array_i64", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::sum_array_i64", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::array::Array) -> i64" + }, + "fn_args": [ + { + "pattern": "values", + "used_ty": { + "ty_source": "Array < i64 >", + "full_path": "pgrx::datum::array::Array", + "module_path": "pgrx::datum::array", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array", + "argument_sql": { + "Ok": { + "As": "bigint[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 34, + "extern_attrs": [ + { + "Name": "sum_array" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::Array", + "signature_hash": "e0ccbaa74471c976" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::Array" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::switch_to_should_switch_back_on_panic", + "signature_hash": "c0d2ea6d26a6f88b" + }, + "entity": { + "Function": { + "name": "switch_to_should_switch_back_on_panic", + "unaliased_name": "switch_to_should_switch_back_on_panic", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::switch_to_should_switch_back_on_panic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 106, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "signature_hash": "fa86e903086d2e2" + }, + "entity": { + "Function": { + "name": "take_and_return_inet", + "unaliased_name": "take_and_return_inet", + "module_path": "pgrx_tests::tests::inet_tests::tests", + "full_path": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::inet::Inet", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx::datum::inet::Inet", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::inet::Inet) -> pgrx::datum::inet::Inet" + }, + "fn_args": [ + { + "pattern": "inet", + "used_ty": { + "ty_source": "Inet", + "full_path": "pgrx::datum::inet::Inet", + "module_path": "pgrx::datum::inet", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::inet::Inet", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Inet", + "full_path": "pgrx::datum::inet::Inet", + "module_path": "pgrx::datum::inet", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::inet::Inet", + "argument_sql": { + "Ok": { + "As": "inet" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "inet" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/inet_tests.rs", + "line": 33, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::inet::Inet", + "signature_hash": "88b608c5032aa632" + }, + "entity": { + "BuiltinType": "pgrx::datum::inet::Inet" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "signature_hash": "7de5731687266a50" + }, + "entity": { + "Function": { + "name": "take_foo_enum", + "unaliased_name": "take_foo_enum", + "module_path": "pgrx_tests::tests::enum_type_tests", + "full_path": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::enum_type_tests::Foo", + "argument_sql": { + "Ok": { + "As": "Foo" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Foo" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_tests::tests::enum_type_tests::Foo", + "argument_sql": { + "Ok": { + "As": "Foo" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Foo" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::enum_type_tests::Foo) -> pgrx_tests::tests::enum_type_tests::Foo" + }, + "fn_args": [ + { + "pattern": "value", + "used_ty": { + "ty_source": "Foo", + "full_path": "pgrx_tests::tests::enum_type_tests::Foo", + "module_path": "pgrx_tests::tests::enum_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::enum_type_tests::Foo", + "argument_sql": { + "Ok": { + "As": "Foo" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Foo" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Foo", + "full_path": "pgrx_tests::tests::enum_type_tests::Foo", + "module_path": "pgrx_tests::tests::enum_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::enum_type_tests::Foo", + "argument_sql": { + "Ok": { + "As": "Foo" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "Foo" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/enum_type_tests.rs", + "line": 20, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "signature_hash": "4884e2f1d45f9e0d" + }, + "entity": { + "Function": { + "name": "takes_bool", + "unaliased_name": "takes_bool", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "metadata": { + "arguments": [ + { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(bool) -> bool" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 35, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_char", + "signature_hash": "afe840d8d0eafb10" + }, + "entity": { + "Function": { + "name": "takes_char", + "unaliased_name": "takes_char", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_char", + "metadata": { + "arguments": [ + { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(char) -> char" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "char", + "full_path": "char", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "char", + "argument_sql": { + "Ok": { + "As": "varchar" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "varchar" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 55, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "signature_hash": "41d534fef859d365" + }, + "entity": { + "Function": { + "name": "takes_f32", + "unaliased_name": "takes_f32", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "metadata": { + "arguments": [ + { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(f32) -> f32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "f32", + "full_path": "f32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f32", + "full_path": "f32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f32", + "argument_sql": { + "Ok": { + "As": "real" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "real" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 40, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "signature_hash": "31d426a2eaf3995d" + }, + "entity": { + "Function": { + "name": "takes_f64", + "unaliased_name": "takes_f64", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "metadata": { + "arguments": [ + { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(f64) -> f64" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 45, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "signature_hash": "fbe26ded1c5e777" + }, + "entity": { + "Function": { + "name": "takes_i16", + "unaliased_name": "takes_i16", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "metadata": { + "arguments": [ + { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i16) -> i16" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i16", + "full_path": "i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i16", + "full_path": "i16", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i16", + "argument_sql": { + "Ok": { + "As": "smallint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "smallint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 20, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "signature_hash": "38a9a8384ed50cac" + }, + "entity": { + "Function": { + "name": "takes_i32", + "unaliased_name": "takes_i32", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 25, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "signature_hash": "450ce1fe5cc15b05" + }, + "entity": { + "Function": { + "name": "takes_i64", + "unaliased_name": "takes_i64", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "metadata": { + "arguments": [ + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i32) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "signature_hash": "591268a2a6d5f56d" + }, + "entity": { + "Function": { + "name": "takes_i8", + "unaliased_name": "takes_i8", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "metadata": { + "arguments": [ + { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i8) -> i8" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "i8", + "full_path": "i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i8", + "full_path": "i8", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i8", + "argument_sql": { + "Ok": { + "As": "\"char\"" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "\"char\"" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 50, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_option", + "signature_hash": "f12b627f558bdb3f" + }, + "entity": { + "Function": { + "name": "takes_option", + "unaliased_name": "takes_option", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_option", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option) -> i32" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 60, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_str", + "signature_hash": "3b6c5af96cadccbe" + }, + "entity": { + "Function": { + "name": "takes_str", + "unaliased_name": "takes_str", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_str", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str) -> &str" + }, + "fn_args": [ + { + "pattern": "s", + "used_ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 65, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::takes_string", + "signature_hash": "89c1d6be28de3cb9" + }, + "entity": { + "Function": { + "name": "takes_string", + "unaliased_name": "takes_string", + "module_path": "pgrx_tests::tests::fcinfo_tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::takes_string", + "metadata": { + "arguments": [ + { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(alloc::string::String) -> alloc::string::String" + }, + "fn_args": [ + { + "pattern": "s", + "used_ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "String", + "full_path": "alloc::string::String", + "module_path": "alloc::string", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::string::String", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 70, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_infinity", + "signature_hash": "49877b529ee25d11" + }, + "entity": { + "Function": { + "name": "test_accept_date_infinity", + "unaliased_name": "test_accept_date_infinity", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_infinity", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 194, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_large_date", + "signature_hash": "ec009a1eb08bdf09" + }, + "entity": { + "Function": { + "name": "test_accept_date_large_date", + "unaliased_name": "test_accept_date_large_date", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_large_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 201, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_neg_infinity", + "signature_hash": "e79a124ee7c6095d" + }, + "entity": { + "Function": { + "name": "test_accept_date_neg_infinity", + "unaliased_name": "test_accept_date_neg_infinity", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_neg_infinity", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 187, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_now", + "signature_hash": "74b457b4e937278f" + }, + "entity": { + "Function": { + "name": "test_accept_date_now", + "unaliased_name": "test_accept_date_now", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_now", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 167, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_random", + "signature_hash": "49bb2f8873fabba6" + }, + "entity": { + "Function": { + "name": "test_accept_date_random", + "unaliased_name": "test_accept_date_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 208, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_large_date", + "signature_hash": "9294dfa38a04fa36" + }, + "entity": { + "Function": { + "name": "test_accept_date_round_trip_large_date", + "unaliased_name": "test_accept_date_round_trip_large_date", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_large_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 215, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_random", + "signature_hash": "6ce5cc665d9426f8" + }, + "entity": { + "Function": { + "name": "test_accept_date_round_trip_random", + "unaliased_name": "test_accept_date_round_trip_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 223, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_tomorrow", + "signature_hash": "5b05dbd927dc66ff" + }, + "entity": { + "Function": { + "name": "test_accept_date_tomorrow", + "unaliased_name": "test_accept_date_tomorrow", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_tomorrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 180, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_yesterday", + "signature_hash": "778359a623ab9932" + }, + "entity": { + "Function": { + "name": "test_accept_date_yesterday", + "unaliased_name": "test_accept_date_yesterday", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_yesterday", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 173, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_neg_random", + "signature_hash": "a6cdef7dab662d35" + }, + "entity": { + "Function": { + "name": "test_accept_interval_neg_random", + "unaliased_name": "test_accept_interval_neg_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_neg_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 441, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_random", + "signature_hash": "d6aacc837316496a" + }, + "entity": { + "Function": { + "name": "test_accept_interval_random", + "unaliased_name": "test_accept_interval_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 434, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_neg_random", + "signature_hash": "d24b523e25baadbc" + }, + "entity": { + "Function": { + "name": "test_accept_interval_round_trip_neg_random", + "unaliased_name": "test_accept_interval_round_trip_neg_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_neg_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 455, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_random", + "signature_hash": "5cae65187017f301" + }, + "entity": { + "Function": { + "name": "test_accept_interval_round_trip_random", + "unaliased_name": "test_accept_interval_round_trip_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 448, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_date", + "signature_hash": "e3edb974e09cac7f" + }, + "entity": { + "Function": { + "name": "test_accept_range_date", + "unaliased_name": "test_accept_range_date", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 152, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_date_array", + "signature_hash": "cc7418c653b50121" + }, + "entity": { + "Function": { + "name": "test_accept_range_date_array", + "unaliased_name": "test_accept_range_date_array", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_date_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 160, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_i32", + "signature_hash": "7faaafaa71d19919" + }, + "entity": { + "Function": { + "name": "test_accept_range_i32", + "unaliased_name": "test_accept_range_i32", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 122, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_i64", + "signature_hash": "21d92119e026f544" + }, + "entity": { + "Function": { + "name": "test_accept_range_i64", + "unaliased_name": "test_accept_range_i64", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_i64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 129, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_numeric", + "signature_hash": "5cc49cd0b519dd9f" + }, + "entity": { + "Function": { + "name": "test_accept_range_numeric", + "unaliased_name": "test_accept_range_numeric", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 136, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_ts", + "signature_hash": "2f44770144cc65cc" + }, + "entity": { + "Function": { + "name": "test_accept_range_ts", + "unaliased_name": "test_accept_range_ts", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_ts", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 168, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_accept_range_tstz", + "signature_hash": "270e0445b473bde5" + }, + "entity": { + "Function": { + "name": "test_accept_range_tstz", + "unaliased_name": "test_accept_range_tstz", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_accept_range_tstz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 176, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::rel_tests::tests::test_accept_relation", + "signature_hash": "32bcc66a0d11e9d3" + }, + "entity": { + "Function": { + "name": "test_accept_relation", + "unaliased_name": "test_accept_relation", + "module_path": "pgrx_tests::tests::rel_tests::tests", + "full_path": "pgrx_tests::tests::rel_tests::tests::test_accept_relation", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/rel_tests.rs", + "line": 24, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_now", + "signature_hash": "99323053b53f9d85" + }, + "entity": { + "Function": { + "name": "test_accept_time_now", + "unaliased_name": "test_accept_time_now", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_now", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 231, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_random", + "signature_hash": "46b3b6ea1dd7244b" + }, + "entity": { + "Function": { + "name": "test_accept_time_random", + "unaliased_name": "test_accept_time_random", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_random", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 269, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_tomorrow", + "signature_hash": "e7f097615e42c95c" + }, + "entity": { + "Function": { + "name": "test_accept_time_tomorrow", + "unaliased_name": "test_accept_time_tomorrow", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_tomorrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 261, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_yesterday", + "signature_hash": "e374f13a9e9162b8" + }, + "entity": { + "Function": { + "name": "test_accept_time_yesterday", + "unaliased_name": "test_accept_time_yesterday", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_yesterday", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 253, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp", + "signature_hash": "6b4d063c13303c23" + }, + "entity": { + "Function": { + "name": "test_accept_timestamp", + "unaliased_name": "test_accept_timestamp", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 277, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone", + "signature_hash": "e96617a2728f77d1" + }, + "entity": { + "Function": { + "name": "test_accept_timestamp_with_time_zone", + "unaliased_name": "test_accept_timestamp_with_time_zone", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 284, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_datetime_round_trip", + "signature_hash": "99e283fd7d467caa" + }, + "entity": { + "Function": { + "name": "test_accept_timestamp_with_time_zone_datetime_round_trip", + "unaliased_name": "test_accept_timestamp_with_time_zone_datetime_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_datetime_round_trip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 344, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_not_utc", + "signature_hash": "89a3fc5f79542b3" + }, + "entity": { + "Function": { + "name": "test_accept_timestamp_with_time_zone_not_utc", + "unaliased_name": "test_accept_timestamp_with_time_zone_not_utc", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_not_utc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 290, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_offset_round_trip", + "signature_hash": "bca4d550b618bbb6" + }, + "entity": { + "Function": { + "name": "test_accept_timestamp_with_time_zone_offset_round_trip", + "unaliased_name": "test_accept_timestamp_with_time_zone_offset_round_trip", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_offset_round_trip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 336, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::tests::test_accept_uuid", + "signature_hash": "266f7aafe2412362" + }, + "entity": { + "Function": { + "name": "test_accept_uuid", + "unaliased_name": "test_accept_uuid", + "module_path": "pgrx_tests::tests::uuid_tests::tests", + "full_path": "pgrx_tests::tests::uuid_tests::tests::test_accept_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 59, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "signature_hash": "bfa9b603f51a8f4b" + }, + "entity": { + "Function": { + "name": "test_add_date_time", + "unaliased_name": "test_add_date_time", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 568, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "signature_hash": "21df1e4d74ba19f" + }, + "entity": { + "Function": { + "name": "test_add_intervals", + "unaliased_name": "test_add_intervals", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 587, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "signature_hash": "b76aa5c2db50deaf" + }, + "entity": { + "Function": { + "name": "test_add_time_interval", + "unaliased_name": "test_add_time_interval", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 578, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_add_two_numbers", + "signature_hash": "5de3ca50fe6ff14e" + }, + "entity": { + "Function": { + "name": "test_add_two_numbers", + "unaliased_name": "test_add_two_numbers", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_add_two_numbers", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 194, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "signature_hash": "fdb53d13bb8f04a5" + }, + "entity": { + "Function": { + "name": "test_anyarray_arg", + "unaliased_name": "test_anyarray_arg", + "module_path": "pgrx_tests::tests::anyarray_tests::tests", + "full_path": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "std :: result :: Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyarray_tests.rs", + "line": 39, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "signature_hash": "91e213e099dc93f9" + }, + "entity": { + "Function": { + "name": "test_anyarray_iter_arg", + "unaliased_name": "test_anyarray_iter_arg", + "module_path": "pgrx_tests::tests::anyarray_tests::tests", + "full_path": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "std :: result :: Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyarray_tests.rs", + "line": 47, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_anyele_type", + "signature_hash": "f0bf25ae4f87e467" + }, + "entity": { + "Function": { + "name": "test_anyele_type", + "unaliased_name": "test_anyele_type", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_anyele_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 165, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "signature_hash": "984c7a5d0265525e" + }, + "entity": { + "Function": { + "name": "test_anyelement_arg", + "unaliased_name": "test_anyelement_arg", + "module_path": "pgrx_tests::tests::anyelement_tests::tests", + "full_path": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anyelement_tests.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "signature_hash": "c2ee0892604fcbd3" + }, + "entity": { + "Function": { + "name": "test_anynumeric_arg", + "unaliased_name": "test_anynumeric_arg", + "module_path": "pgrx_tests::tests::anynumeric_tests::tests", + "full_path": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/anynumeric_tests.rs", + "line": 16, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "signature_hash": "1186df5c46ceab1c" + }, + "entity": { + "Function": { + "name": "test_anynumeric_sum", + "unaliased_name": "test_anynumeric_sum", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 209, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_arr_data_ptr", + "signature_hash": "6f62deee2315466f" + }, + "entity": { + "Function": { + "name": "test_arr_data_ptr", + "unaliased_name": "test_arr_data_ptr", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_arr_data_ptr", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 313, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq", + "signature_hash": "b8bdeeb54af5b1b1" + }, + "entity": { + "Function": { + "name": "test_arr_sort_uniq", + "unaliased_name": "test_arr_sort_uniq", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 366, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "signature_hash": "26e79b643ab54d28" + }, + "entity": { + "Function": { + "name": "test_arr_sort_uniq_with_null", + "unaliased_name": "test_arr_sort_uniq_with_null", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 372, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_arr_to_vec", + "signature_hash": "7226c2d99e7aa6c7" + }, + "entity": { + "Function": { + "name": "test_arr_to_vec", + "unaliased_name": "test_arr_to_vec", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_arr_to_vec", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 356, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "signature_hash": "a73cf3c200841c26" + }, + "entity": { + "Function": { + "name": "test_array_deny_nulls", + "unaliased_name": "test_array_deny_nulls", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 244, + "extern_attrs": [ + { + "ShouldPanic": "array contains NULL" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::composite_type_tests::tests::test_array_of_composite_type", + "signature_hash": "37df9c3a5309e615" + }, + "entity": { + "Function": { + "name": "test_array_of_composite_type", + "unaliased_name": "test_array_of_composite_type", + "module_path": "pgrx_tests::tests::composite_type_tests::tests", + "full_path": "pgrx_tests::tests::composite_type_tests::tests::test_array_of_composite_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/composite_type_tests.rs", + "line": 34, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "signature_hash": "d68af72667c58f35" + }, + "entity": { + "Function": { + "name": "test_array_of_points", + "unaliased_name": "test_array_of_points", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 433, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_assign_hook", + "signature_hash": "62c67f9c820ba8e6" + }, + "entity": { + "Function": { + "name": "test_assign_hook", + "unaliased_name": "test_assign_hook", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_assign_hook", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 313, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests::test_background_worker_transaction_return", + "signature_hash": "ce7928074e0c85c8" + }, + "entity": { + "Function": { + "name": "test_background_worker_transaction_return", + "unaliased_name": "test_background_worker_transaction_return", + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "full_path": "pgrx_tests::tests::bgworker_tests::tests::test_background_worker_transaction_return", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 151, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_bad_conversions", + "signature_hash": "d7316d3ef5a1bd23" + }, + "entity": { + "Function": { + "name": "test_bad_conversions", + "unaliased_name": "test_bad_conversions", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_bad_conversions", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 144, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::shmem_tests::tests::test_behaves_normally_when_elog_while_holding_lock", + "signature_hash": "7a742dadd7b9adca" + }, + "entity": { + "Function": { + "name": "test_behaves_normally_when_elog_while_holding_lock", + "unaliased_name": "test_behaves_normally_when_elog_while_holding_lock", + "module_path": "pgrx_tests::tests::shmem_tests::tests", + "full_path": "pgrx_tests::tests::shmem_tests::tests::test_behaves_normally_when_elog_while_holding_lock", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/shmem_tests.rs", + "line": 39, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_bool_guc", + "signature_hash": "6d41f2bc9b49f11f" + }, + "entity": { + "Function": { + "name": "test_bool_guc", + "unaliased_name": "test_bool_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_bool_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "signature_hash": "e574a42e18a61164" + }, + "entity": { + "Function": { + "name": "test_box_into_datum", + "unaliased_name": "test_box_into_datum", + "module_path": "pgrx_tests::tests::geo_tests::tests", + "full_path": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/geo_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_null", + "signature_hash": "b69933dfb74cc01e" + }, + "entity": { + "Function": { + "name": "test_call_with_enum_null", + "unaliased_name": "test_call_with_enum_null", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 227, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_value", + "signature_hash": "e20bec7d97a55fc" + }, + "entity": { + "Function": { + "name": "test_call_with_enum_value", + "unaliased_name": "test_call_with_enum_value", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_value", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 219, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_null", + "signature_hash": "796f77ad0f5103a5" + }, + "entity": { + "Function": { + "name": "test_call_with_null", + "unaliased_name": "test_call_with_null", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 201, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_value", + "signature_hash": "4c5a4ba1bceaf51" + }, + "entity": { + "Function": { + "name": "test_call_with_value", + "unaliased_name": "test_call_with_value", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_value", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 193, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "signature_hash": "27ca68b137ba3125" + }, + "entity": { + "Function": { + "name": "test_cfg_exists", + "unaliased_name": "test_cfg_exists", + "module_path": "pgrx_tests::tests::cfg_tests::tests", + "full_path": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/cfg_tests.rs", + "line": 29, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_check_for_interrupts", + "signature_hash": "304045b8a5610261" + }, + "entity": { + "Function": { + "name": "test_check_for_interrupts", + "unaliased_name": "test_check_for_interrupts", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_check_for_interrupts", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 67, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_check_hook_fail", + "signature_hash": "f5175287cf1a61d5" + }, + "entity": { + "Function": { + "name": "test_check_hook_fail", + "unaliased_name": "test_check_hook_fail", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_check_hook_fail", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 282, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "signature_hash": "620ad9ddb0d86884" + }, + "entity": { + "Function": { + "name": "test_clone_bool", + "unaliased_name": "test_clone_bool", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 66, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "signature_hash": "dc9ca386ad9d52ec" + }, + "entity": { + "Function": { + "name": "test_clone_f64", + "unaliased_name": "test_clone_f64", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 70, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "signature_hash": "bcd2b95a4232b745" + }, + "entity": { + "Function": { + "name": "test_clone_i16", + "unaliased_name": "test_clone_i16", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 68, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "signature_hash": "f6879289adc80db7" + }, + "entity": { + "Function": { + "name": "test_clone_i32", + "unaliased_name": "test_clone_i32", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 69, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "signature_hash": "16b8c23c854daa3c" + }, + "entity": { + "Function": { + "name": "test_clone_i8", + "unaliased_name": "test_clone_i8", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 67, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "signature_hash": "5452a22263f5d9ca" + }, + "entity": { + "Function": { + "name": "test_clone_oid", + "unaliased_name": "test_clone_oid", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "signature_hash": "6c165a8a4571339b" + }, + "entity": { + "Function": { + "name": "test_clone_point", + "unaliased_name": "test_clone_point", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 71, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "signature_hash": "39c6f79d39cd4ba0" + }, + "entity": { + "Function": { + "name": "test_clone_str", + "unaliased_name": "test_clone_str", + "module_path": "pgrx_tests::tests::borrow_datum::tests", + "full_path": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/borrow_datum.rs", + "line": 77, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_columns", + "signature_hash": "5b0c931df082222f" + }, + "entity": { + "Function": { + "name": "test_columns", + "unaliased_name": "test_columns", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_columns", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 307, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_compatibility", + "signature_hash": "3b8ee4cafb9d0c33" + }, + "entity": { + "Function": { + "name": "test_compatibility", + "unaliased_name": "test_compatibility", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_compatibility", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 856, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "signature_hash": "8321bf4df2cce92" + }, + "entity": { + "Function": { + "name": "test_completely_unreasonable_but_still_valid_oid", + "unaliased_name": "test_completely_unreasonable_but_still_valid_oid", + "module_path": "pgrx_tests::tests::oid_tests::tests", + "full_path": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/oid_tests.rs", + "line": 31, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "signature_hash": "779a1ae57407a5e8" + }, + "entity": { + "Function": { + "name": "test_complex_from_text", + "unaliased_name": "test_complex_from_text", + "module_path": "pgrx_tests::tests::struct_type_tests::tests", + "full_path": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/struct_type_tests.rs", + "line": 43, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "signature_hash": "532738e9aece8407" + }, + "entity": { + "Function": { + "name": "test_complex_in", + "unaliased_name": "test_complex_in", + "module_path": "pgrx_tests::tests::struct_type_tests::tests", + "full_path": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/struct_type_tests.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::struct_type_tests::tests::test_complex_out", + "signature_hash": "f6ee2eea68feedbd" + }, + "entity": { + "Function": { + "name": "test_complex_out", + "unaliased_name": "test_complex_out", + "module_path": "pgrx_tests::tests::struct_type_tests::tests", + "full_path": "pgrx_tests::tests::struct_type_tests::tests::test_complex_out", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/struct_type_tests.rs", + "line": 36, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "signature_hash": "f162a3f37d352ecd" + }, + "entity": { + "Function": { + "name": "test_complex_storage_and_retrieval", + "unaliased_name": "test_complex_storage_and_retrieval", + "module_path": "pgrx_tests::tests::struct_type_tests::tests", + "full_path": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/struct_type_tests.rs", + "line": 58, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_composite_set", + "signature_hash": "b62b3595870119d6" + }, + "entity": { + "Function": { + "name": "test_composite_set", + "unaliased_name": "test_composite_set", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_composite_set", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 174, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_connect_return_anything", + "signature_hash": "e129135833264b26" + }, + "entity": { + "Function": { + "name": "test_connect_return_anything", + "unaliased_name": "test_connect_return_anything", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_connect_return_anything", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 328, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_convert_time_with_time_zone_now", + "signature_hash": "dc233e0c5f9b065" + }, + "entity": { + "Function": { + "name": "test_convert_time_with_time_zone_now", + "unaliased_name": "test_convert_time_with_time_zone_now", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_convert_time_with_time_zone_now", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 237, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::xid64_tests::tests::test_convert_xid_to_u64", + "signature_hash": "49ec7b35a0c64dab" + }, + "entity": { + "Function": { + "name": "test_convert_xid_to_u64", + "unaliased_name": "test_convert_xid_to_u64", + "module_path": "pgrx_tests::tests::xid64_tests::tests", + "full_path": "pgrx_tests::tests::xid64_tests::tests::test_convert_xid_to_u64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/xid64_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_operator_tests::tests::test_correct_schema", + "signature_hash": "f2fd7ef1bbacb7a7" + }, + "entity": { + "Function": { + "name": "test_correct_schema", + "unaliased_name": "test_correct_schema", + "module_path": "pgrx_tests::tests::pg_operator_tests::tests", + "full_path": "pgrx_tests::tests::pg_operator_tests::tests::test_correct_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_operator_tests.rs", + "line": 30, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_count_nulls", + "signature_hash": "e16857dc7d219010" + }, + "entity": { + "Function": { + "name": "test_count_nulls", + "unaliased_name": "test_count_nulls", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_count_nulls", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 232, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_count_true", + "signature_hash": "8207f494337c6fec" + }, + "entity": { + "Function": { + "name": "test_count_true", + "unaliased_name": "test_count_true", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_count_true", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 226, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "signature_hash": "d05558958a49f66a" + }, + "entity": { + "Function": { + "name": "test_create_dog", + "unaliased_name": "test_create_dog", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 716, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_create_or_replace", + "signature_hash": "9c3fc756e5ea2c30" + }, + "entity": { + "Function": { + "name": "test_create_or_replace", + "unaliased_name": "test_create_or_replace", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_create_or_replace", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 150, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "signature_hash": "20d25edcdf36ddae" + }, + "entity": { + "Function": { + "name": "test_cstring_array", + "unaliased_name": "test_cstring_array", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 378, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "signature_hash": "461b66b8d1be8c4e" + }, + "entity": { + "Function": { + "name": "test_cstring_roundtrip", + "unaliased_name": "test_cstring_roundtrip", + "module_path": "pgrx_tests::tests::from_into_datum_tests::tests", + "full_path": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/from_into_datum_tests.rs", + "line": 41, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop", + "signature_hash": "565f70a6c94e4986" + }, + "entity": { + "Function": { + "name": "test_current_owned_memory_context_drop", + "unaliased_name": "test_current_owned_memory_context_drop", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 121, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop_when_set_current_twice", + "signature_hash": "7345bbf94403d4c7" + }, + "entity": { + "Function": { + "name": "test_current_owned_memory_context_drop_when_set_current_twice", + "unaliased_name": "test_current_owned_memory_context_drop_when_set_current_twice", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop_when_set_current_twice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 134, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "signature_hash": "b114e7144b04c855" + }, + "entity": { + "Function": { + "name": "test_cursor", + "unaliased_name": "test_cursor", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 190, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "signature_hash": "5d4c27de95f787ff" + }, + "entity": { + "Function": { + "name": "test_cursor_by_name", + "unaliased_name": "test_cursor_by_name", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 264, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_failure", + "signature_hash": "ed59f2ec811e0e76" + }, + "entity": { + "Function": { + "name": "test_cursor_failure", + "unaliased_name": "test_cursor_failure", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_failure", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 295, + "extern_attrs": [ + { + "ShouldPanic": "syntax error at or near \"THIS\"" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_not_found", + "signature_hash": "871ed299de267921" + }, + "entity": { + "Function": { + "name": "test_cursor_not_found", + "unaliased_name": "test_cursor_not_found", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_not_found", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 302, + "extern_attrs": [ + { + "ShouldPanic": "cursor: CursorNotFound(\"NOT A CURSOR\")" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "signature_hash": "e8532a3c78e5994b" + }, + "entity": { + "Function": { + "name": "test_cursor_prepared_statement", + "unaliased_name": "test_cursor_prepared_statement", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 210, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "signature_hash": "b98ec4785e82c38c" + }, + "entity": { + "Function": { + "name": "test_cursor_prepared_statement_panics_less_args", + "unaliased_name": "test_cursor_prepared_statement_panics_less_args", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 231, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "signature_hash": "ccdb62d742de55b5" + }, + "entity": { + "Function": { + "name": "test_cursor_prepared_statement_panics_more_args", + "unaliased_name": "test_cursor_prepared_statement_panics_more_args", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 237, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "signature_hash": "582d9c4badd9b0c1" + }, + "entity": { + "Function": { + "name": "test_custom_ereport", + "unaliased_name": "test_custom_ereport", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), ErrorReport >", + "full_path": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "module_path": "core::result::Result<(), pgrx_pg_sys::submodules::panic", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 155, + "extern_attrs": [ + { + "ShouldPanic": "raised custom ereport" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_date_serialization", + "signature_hash": "151d3111975e9b59" + }, + "entity": { + "Function": { + "name": "test_date_serialization", + "unaliased_name": "test_date_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_date_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 150, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_debug1", + "signature_hash": "809f8849124b70f0" + }, + "entity": { + "Function": { + "name": "test_debug1", + "unaliased_name": "test_debug1", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_debug1", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 57, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_debug2", + "signature_hash": "3e66b4d30b072540" + }, + "entity": { + "Function": { + "name": "test_debug2", + "unaliased_name": "test_debug2", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_debug2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 52, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_debug3", + "signature_hash": "5ca74f19feda553b" + }, + "entity": { + "Function": { + "name": "test_debug3", + "unaliased_name": "test_debug3", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_debug3", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 47, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_debug4", + "signature_hash": "ad6ead4f7b2aaf00" + }, + "entity": { + "Function": { + "name": "test_debug4", + "unaliased_name": "test_debug4", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_debug4", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 42, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_debug5", + "signature_hash": "12853c03d0dd1b8b" + }, + "entity": { + "Function": { + "name": "test_debug5", + "unaliased_name": "test_debug5", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_debug5", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 37, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument", + "signature_hash": "cd2dc3aa28036382" + }, + "entity": { + "Function": { + "name": "test_default_argument", + "unaliased_name": "test_default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 44, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument_specified", + "signature_hash": "f0dccf62a26b37e4" + }, + "entity": { + "Function": { + "name": "test_default_argument_specified", + "unaliased_name": "test_default_argument_specified", + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument_specified", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 50, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::inet_tests::tests::test_deserialize_inet", + "signature_hash": "ee8b44bf5afdbcf1" + }, + "entity": { + "Function": { + "name": "test_deserialize_inet", + "unaliased_name": "test_deserialize_inet", + "module_path": "pgrx_tests::tests::inet_tests::tests", + "full_path": "pgrx_tests::tests::inet_tests::tests::test_deserialize_inet", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/inet_tests.rs", + "line": 19, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_deserialize_numeric", + "signature_hash": "f8202a5e302799e7" + }, + "entity": { + "Function": { + "name": "test_deserialize_numeric", + "unaliased_name": "test_deserialize_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_deserialize_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 65, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "signature_hash": "45128d6b214b368a" + }, + "entity": { + "Function": { + "name": "test_display_get_arr_nullbitmap", + "unaliased_name": "test_display_get_arr_nullbitmap", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 325, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::tests::test_display_uuid", + "signature_hash": "5576142bd56dd2be" + }, + "entity": { + "Function": { + "name": "test_display_uuid", + "unaliased_name": "test_display_uuid", + "module_path": "pgrx_tests::tests::uuid_tests::tests", + "full_path": "pgrx_tests::tests::uuid_tests::tests::test_display_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 40, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_drop", + "signature_hash": "943fcde7470e733c" + }, + "entity": { + "Function": { + "name": "test_drop", + "unaliased_name": "test_drop", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_drop", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 175, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_and_ignore_and_finally", + "signature_hash": "bc119540ffad0847" + }, + "entity": { + "Function": { + "name": "test_drop_with_panic_and_ignore_and_finally", + "unaliased_name": "test_drop_with_panic_and_ignore_and_finally", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_and_ignore_and_finally", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 282, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_ignore", + "signature_hash": "baf56bf43e62ef70" + }, + "entity": { + "Function": { + "name": "test_drop_with_panic_catch_and_ignore", + "unaliased_name": "test_drop_with_panic_catch_and_ignore", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_ignore", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 254, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_rethrow", + "signature_hash": "c318dfb1964322c7" + }, + "entity": { + "Function": { + "name": "test_drop_with_panic_catch_and_rethrow", + "unaliased_name": "test_drop_with_panic_catch_and_rethrow", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_rethrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 226, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_no_catch", + "signature_hash": "5197d475151f00d4" + }, + "entity": { + "Function": { + "name": "test_drop_with_panic_no_catch", + "unaliased_name": "test_drop_with_panic_no_catch", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_no_catch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 199, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_conversion", + "signature_hash": "88412b5380bec842" + }, + "entity": { + "Function": { + "name": "test_duration_to_interval_conversion", + "unaliased_name": "test_duration_to_interval_conversion", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_conversion", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 533, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_err", + "signature_hash": "ca5f29827185466c" + }, + "entity": { + "Function": { + "name": "test_duration_to_interval_err", + "unaliased_name": "test_duration_to_interval_err", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_err", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 470, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker", + "signature_hash": "e87817990101cefe" + }, + "entity": { + "Function": { + "name": "test_dynamic_bgworker", + "unaliased_name": "test_dynamic_bgworker", + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "full_path": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 95, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked", + "signature_hash": "d902c4b23a44a87e" + }, + "entity": { + "Function": { + "name": "test_dynamic_bgworker_untracked", + "unaliased_name": "test_dynamic_bgworker_untracked", + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "full_path": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 115, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked_termination_handle", + "signature_hash": "3eb74fa2956cd21b" + }, + "entity": { + "Function": { + "name": "test_dynamic_bgworker_untracked_termination_handle", + "unaliased_name": "test_dynamic_bgworker_untracked_termination_handle", + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "full_path": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked_termination_handle", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 133, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_worker_allocation_failure", + "signature_hash": "f7a130cffa9bd4b5" + }, + "entity": { + "Function": { + "name": "test_dynamic_worker_allocation_failure", + "unaliased_name": "test_dynamic_worker_allocation_failure", + "module_path": "pgrx_tests::tests::bgworker_tests::tests", + "full_path": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_worker_allocation_failure", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bgworker_tests.rs", + "line": 171, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_empty_anynumeric_range", + "signature_hash": "fc2efd5acdf7af18" + }, + "entity": { + "Function": { + "name": "test_empty_anynumeric_range", + "unaliased_name": "test_empty_anynumeric_range", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_empty_anynumeric_range", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 144, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "signature_hash": "e9e1791bb15f08f9" + }, + "entity": { + "Function": { + "name": "test_enum_array_roundtrip", + "unaliased_name": "test_enum_array_roundtrip", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 197, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_enum_guc", + "signature_hash": "f3b9876db2143eec" + }, + "entity": { + "Function": { + "name": "test_enum_guc", + "unaliased_name": "test_enum_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_enum_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 149, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_ereport", + "signature_hash": "87e363e8a1a165ed" + }, + "entity": { + "Function": { + "name": "test_ereport", + "unaliased_name": "test_ereport", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_ereport", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 72, + "extern_attrs": [ + { + "ShouldPanic": "ereport error" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_error", + "signature_hash": "30ba20651cb3003d" + }, + "entity": { + "Function": { + "name": "test_error", + "unaliased_name": "test_error", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 62, + "extern_attrs": [ + { + "ShouldPanic": "error message" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "signature_hash": "ce44d1334e297600" + }, + "entity": { + "Function": { + "name": "test_execute_prepared_statement_in_readonly", + "unaliased_name": "test_execute_prepared_statement_in_readonly", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 434, + "extern_attrs": [ + { + "ShouldPanic": "CREATE TABLE is not allowed in a non-volatile function" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "signature_hash": "fea6fc2b521a1f27" + }, + "entity": { + "Function": { + "name": "test_execute_prepared_statement_in_readwrite", + "unaliased_name": "test_execute_prepared_statement_in_readwrite", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 444, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "signature_hash": "acbe1db4a5b90345" + }, + "entity": { + "Function": { + "name": "test_f32_slice", + "unaliased_name": "test_f32_slice", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 393, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "signature_hash": "7c90127c57d69117" + }, + "entity": { + "Function": { + "name": "test_f64_slice", + "unaliased_name": "test_f64_slice", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 385, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool", + "signature_hash": "4d849e851378980f" + }, + "entity": { + "Function": { + "name": "test_false_bool", + "unaliased_name": "test_false_bool", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 51, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool_is_some_false", + "signature_hash": "5b3bbb5e7d50e647" + }, + "entity": { + "Function": { + "name": "test_false_bool_is_some_false", + "unaliased_name": "test_false_bool_is_some_false", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool_is_some_false", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 71, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_float_guc", + "signature_hash": "a294357d35834165" + }, + "entity": { + "Function": { + "name": "test_float_guc", + "unaliased_name": "test_float_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_float_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 82, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::enum_type_tests::tests::test_foo_enum", + "signature_hash": "da08412fdfb1eab4" + }, + "entity": { + "Function": { + "name": "test_foo_enum", + "unaliased_name": "test_foo_enum", + "module_path": "pgrx_tests::tests::enum_type_tests::tests", + "full_path": "pgrx_tests::tests::enum_type_tests::tests::test_foo_enum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/enum_type_tests.rs", + "line": 39, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::attributes_tests::tests::test_for_ignore_attribute", + "signature_hash": "605c5497c4c8a901" + }, + "entity": { + "Function": { + "name": "test_for_ignore_attribute", + "unaliased_name": "test_for_ignore_attribute", + "module_path": "pgrx_tests::tests::attributes_tests::tests", + "full_path": "pgrx_tests::tests::attributes_tests::tests::test_for_ignore_attribute", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/attributes_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::attributes_tests::tests::test_for_should_panic_attribute", + "signature_hash": "a1f22e08c7372906" + }, + "entity": { + "Function": { + "name": "test_for_should_panic_attribute", + "unaliased_name": "test_for_should_panic_attribute", + "module_path": "pgrx_tests::tests::attributes_tests::tests", + "full_path": "pgrx_tests::tests::attributes_tests::tests::test_for_should_panic_attribute", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/attributes_tests.rs", + "line": 24, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "signature_hash": "71d704c05ad9adad" + }, + "entity": { + "Function": { + "name": "test_from_str", + "unaliased_name": "test_from_str", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 423, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_func_with_collation", + "signature_hash": "930e412c85b3e721" + }, + "entity": { + "Function": { + "name": "test_func_with_collation", + "unaliased_name": "test_func_with_collation", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_func_with_collation", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 192, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::variadic_tests::tests::test_func_with_variadic_array_args", + "signature_hash": "54b16eb03da1551d" + }, + "entity": { + "Function": { + "name": "test_func_with_variadic_array_args", + "unaliased_name": "test_func_with_variadic_array_args", + "module_path": "pgrx_tests::tests::variadic_tests::tests", + "full_path": "pgrx_tests::tests::variadic_tests::tests::test_func_with_variadic_array_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/variadic_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_generate_series", + "signature_hash": "7b9bed834113b95d" + }, + "entity": { + "Function": { + "name": "test_generate_series", + "unaliased_name": "test_generate_series", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_generate_series", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 153, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_get_arr_data_ptr_nth_elem", + "signature_hash": "e66aa89f45156dfb" + }, + "entity": { + "Function": { + "name": "test_get_arr_data_ptr_nth_elem", + "unaliased_name": "test_get_arr_data_ptr_nth_elem", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_get_arr_data_ptr_nth_elem", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 319, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "signature_hash": "52d75141792e5bb2" + }, + "entity": { + "Function": { + "name": "test_get_arr_ndim", + "unaliased_name": "test_get_arr_ndim", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 342, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field", + "signature_hash": "87792fbeedc7457d" + }, + "entity": { + "Function": { + "name": "test_gets_name_field", + "unaliased_name": "test_gets_name_field", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 590, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_default", + "signature_hash": "18a969a7a4b4c74a" + }, + "entity": { + "Function": { + "name": "test_gets_name_field_default", + "unaliased_name": "test_gets_name_field_default", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 600, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_strict", + "signature_hash": "7194ba1612c5e00b" + }, + "entity": { + "Function": { + "name": "test_gets_name_field_strict", + "unaliased_name": "test_gets_name_field_strict", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_strict", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 610, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_variadic", + "signature_hash": "489e6a257c932cbb" + }, + "entity": { + "Function": { + "name": "test_gets_name_field_variadic", + "unaliased_name": "test_gets_name_field_variadic", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_variadic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 620, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_guc_check_hook", + "signature_hash": "fbaf61b04061ac04" + }, + "entity": { + "Function": { + "name": "test_guc_check_hook", + "unaliased_name": "test_guc_check_hook", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_guc_check_hook", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 236, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_guc_flags", + "signature_hash": "3f132d518b61f63d" + }, + "entity": { + "Function": { + "name": "test_guc_flags", + "unaliased_name": "test_guc_flags", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_guc_flags", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 183, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "signature_hash": "131d45cd7d64ffad" + }, + "entity": { + "Function": { + "name": "test_i16_slice", + "unaliased_name": "test_i16_slice", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 417, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "signature_hash": "e2a44eec22e74865" + }, + "entity": { + "Function": { + "name": "test_i32_slice", + "unaliased_name": "test_i32_slice", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 409, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "signature_hash": "6170d1bb4b4371fa" + }, + "entity": { + "Function": { + "name": "test_i64_slice", + "unaliased_name": "test_i64_slice", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 401, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_immutable", + "signature_hash": "1b4ee63775951bfa" + }, + "entity": { + "Function": { + "name": "test_immutable", + "unaliased_name": "test_immutable", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_immutable", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 77, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema", + "signature_hash": "9431b595e4b17f03" + }, + "entity": { + "Function": { + "name": "test_in_different_schema", + "unaliased_name": "test_in_different_schema", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 97, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema2", + "signature_hash": "9e0068d0e0be5cda" + }, + "entity": { + "Function": { + "name": "test_in_different_schema2", + "unaliased_name": "test_in_different_schema2", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::from_into_datum_tests::tests::test_incompatible_datum_returns_error", + "signature_hash": "abfdaa569f735304" + }, + "entity": { + "Function": { + "name": "test_incompatible_datum_returns_error", + "unaliased_name": "test_incompatible_datum_returns_error", + "module_path": "pgrx_tests::tests::from_into_datum_tests::tests", + "full_path": "pgrx_tests::tests::from_into_datum_tests::tests::test_incompatible_datum_returns_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/from_into_datum_tests.rs", + "line": 20, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_incompatible_return_type", + "signature_hash": "95b91a3d4e544d25" + }, + "entity": { + "Function": { + "name": "test_incompatible_return_type", + "unaliased_name": "test_incompatible_return_type", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_incompatible_return_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 97, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_info", + "signature_hash": "3a31cbcfcf8219ed" + }, + "entity": { + "Function": { + "name": "test_info", + "unaliased_name": "test_info", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_info", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 17, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "signature_hash": "d376f5b073d56a82" + }, + "entity": { + "Function": { + "name": "test_inserting_null", + "unaliased_name": "test_inserting_null", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 167, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_eq", + "signature_hash": "72ad7ca46780d061" + }, + "entity": { + "Function": { + "name": "test_int4eq_eq", + "unaliased_name": "test_int4eq_eq", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_eq", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 54, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_ne", + "signature_hash": "f13ccb02324ee4a5" + }, + "entity": { + "Function": { + "name": "test_int4eq_ne", + "unaliased_name": "test_int4eq_ne", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_ne", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 60, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_int_guc", + "signature_hash": "2332febc88284291" + }, + "entity": { + "Function": { + "name": "test_int_guc", + "unaliased_name": "test_int_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_int_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 41, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_mismatched_signs", + "signature_hash": "a9555a1b439c1c79" + }, + "entity": { + "Function": { + "name": "test_interval_from_mismatched_signs", + "unaliased_name": "test_interval_from_mismatched_signs", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_mismatched_signs", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 562, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_seconds", + "signature_hash": "4a138426f659add8" + }, + "entity": { + "Function": { + "name": "test_interval_from_seconds", + "unaliased_name": "test_interval_from_seconds", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_seconds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 553, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_interval_serialization", + "signature_hash": "4756d19e9318b11a" + }, + "entity": { + "Function": { + "name": "test_interval_serialization", + "unaliased_name": "test_interval_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_interval_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 462, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_interval_to_duration_conversion", + "signature_hash": "59777aebf1a37a5d" + }, + "entity": { + "Function": { + "name": "test_interval_to_duration_conversion", + "unaliased_name": "test_interval_to_duration_conversion", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_interval_to_duration_conversion", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 516, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "signature_hash": "d506434b5ecf2f12" + }, + "entity": { + "Function": { + "name": "test_is_timestamp_utc", + "unaliased_name": "test_is_timestamp_utc", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 320, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "signature_hash": "1e423f3ec4ad9606" + }, + "entity": { + "Function": { + "name": "test_is_timestamp_with_time_zone_utc", + "unaliased_name": "test_is_timestamp_with_time_zone_utc", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 309, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::tests::test_json", + "signature_hash": "3fd667f15166b913" + }, + "entity": { + "Function": { + "name": "test_json", + "unaliased_name": "test_json", + "module_path": "pgrx_tests::tests::json_tests::tests", + "full_path": "pgrx_tests::tests::json_tests::tests::test_json", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "signature_hash": "f08951a1427b11df" + }, + "entity": { + "Function": { + "name": "test_json_arg", + "unaliased_name": "test_json_arg", + "module_path": "pgrx_tests::tests::json_tests::tests", + "full_path": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "signature_hash": "869dba7f16150eda" + }, + "entity": { + "Function": { + "name": "test_json_enum_type", + "unaliased_name": "test_json_enum_type", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 255, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "signature_hash": "332dcc5c9f911058" + }, + "entity": { + "Function": { + "name": "test_jsonb", + "unaliased_name": "test_jsonb", + "module_path": "pgrx_tests::tests::json_tests::tests", + "full_path": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 55, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "signature_hash": "f8558f2711dae7d9" + }, + "entity": { + "Function": { + "name": "test_jsonb_arg", + "unaliased_name": "test_jsonb_arg", + "module_path": "pgrx_tests::tests::json_tests::tests", + "full_path": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/json_tests.rs", + "line": 91, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "signature_hash": "2a155901be5e00ff" + }, + "entity": { + "Function": { + "name": "test_jsontype", + "unaliased_name": "test_jsontype", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 244, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop", + "signature_hash": "a7440786473fd05a" + }, + "entity": { + "Function": { + "name": "test_leak_and_drop", + "unaliased_name": "test_leak_and_drop", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop_with_panic", + "signature_hash": "641dd7288d9885b7" + }, + "entity": { + "Function": { + "name": "test_leak_and_drop_with_panic", + "unaliased_name": "test_leak_and_drop_with_panic", + "module_path": "pgrx_tests::tests::memcxt_tests::tests", + "full_path": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop_with_panic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/memcxt_tests.rs", + "line": 53, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_limits", + "signature_hash": "12530e12d09e70" + }, + "entity": { + "Function": { + "name": "test_limits", + "unaliased_name": "test_limits", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_limits", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 77, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_drop", + "signature_hash": "f167e810888166fc" + }, + "entity": { + "Function": { + "name": "test_lock_is_released_on_drop", + "unaliased_name": "test_lock_is_released_on_drop", + "module_path": "pgrx_tests::tests::shmem_tests::tests", + "full_path": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_drop", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/shmem_tests.rs", + "line": 49, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_unwind", + "signature_hash": "1049274fe2f8c835" + }, + "entity": { + "Function": { + "name": "test_lock_is_released_on_unwind", + "unaliased_name": "test_lock_is_released_on_unwind", + "module_path": "pgrx_tests::tests::shmem_tests::tests", + "full_path": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_unwind", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/shmem_tests.rs", + "line": 57, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_log", + "signature_hash": "f2903ff9e317977b" + }, + "entity": { + "Function": { + "name": "test_log", + "unaliased_name": "test_log", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_log", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_mb_guc", + "signature_hash": "7ff0b48905a8a893" + }, + "entity": { + "Function": { + "name": "test_mb_guc", + "unaliased_name": "test_mb_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_mb_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 63, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_missing_field", + "signature_hash": "de7b06aacf42a85c" + }, + "entity": { + "Function": { + "name": "test_missing_field", + "unaliased_name": "test_missing_field", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_missing_field", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 782, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_missing_number", + "signature_hash": "6f0be69b42b07df8" + }, + "entity": { + "Function": { + "name": "test_missing_number", + "unaliased_name": "test_missing_number", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_missing_number", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 799, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_missing_type", + "signature_hash": "7187e6e8809e413c" + }, + "entity": { + "Function": { + "name": "test_missing_type", + "unaliased_name": "test_missing_type", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_missing_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 770, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "signature_hash": "24db798696d78cec" + }, + "entity": { + "Function": { + "name": "test_my_enum_type", + "unaliased_name": "test_my_enum_type", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 185, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_my_int4eq", + "signature_hash": "3070bb822f2b7681" + }, + "entity": { + "Function": { + "name": "test_my_int4eq", + "unaliased_name": "test_my_int4eq", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_my_int4eq", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 66, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "signature_hash": "e4ffaad5239b8164" + }, + "entity": { + "Function": { + "name": "test_mytype", + "unaliased_name": "test_mytype", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 175, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_name", + "signature_hash": "d6bb2061e920e02" + }, + "entity": { + "Function": { + "name": "test_name", + "unaliased_name": "test_name", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_name", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 177, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_nan_ordering", + "signature_hash": "fe864721e38676f4" + }, + "entity": { + "Function": { + "name": "test_nan_ordering", + "unaliased_name": "test_nan_ordering", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_nan_ordering", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 178, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests::test_negative_default_argument", + "signature_hash": "ba6f6abb5e96dc71" + }, + "entity": { + "Function": { + "name": "test_negative_default_argument", + "unaliased_name": "test_negative_default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::tests::test_negative_default_argument", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 38, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_negative_interval_to_duration_conversion", + "signature_hash": "228d300dec4d7bf8" + }, + "entity": { + "Function": { + "name": "test_negative_interval_to_duration_conversion", + "unaliased_name": "test_negative_interval_to_duration_conversion", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_negative_interval_to_duration_conversion", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 525, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_new_composite_type", + "signature_hash": "1f5f06d9e08b0cef" + }, + "entity": { + "Function": { + "name": "test_new_composite_type", + "unaliased_name": "test_new_composite_type", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_new_composite_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 755, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_notice", + "signature_hash": "2f2f8925ecadc7af" + }, + "entity": { + "Function": { + "name": "test_notice", + "unaliased_name": "test_notice", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_notice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 32, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_none", + "signature_hash": "85e772fba18aa97c" + }, + "entity": { + "Function": { + "name": "test_null_arg_none", + "unaliased_name": "test_null_arg_none", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 84, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_some", + "signature_hash": "71879555d55a850b" + }, + "entity": { + "Function": { + "name": "test_null_arg_some", + "unaliased_name": "test_null_arg_some", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_some", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 78, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_null_error_type", + "signature_hash": "cd1bffe934790cdc" + }, + "entity": { + "Function": { + "name": "test_null_error_type", + "unaliased_name": "test_null_error_type", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_null_error_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 348, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_null_strict_type", + "signature_hash": "9bdf9ba67b8b61ca" + }, + "entity": { + "Function": { + "name": "test_null_strict_type", + "unaliased_name": "test_null_strict_type", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_null_strict_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 343, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "signature_hash": "149303c4265d02fe" + }, + "entity": { + "Function": { + "name": "test_old_date", + "unaliased_name": "test_old_date", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 597, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_one_col_table", + "signature_hash": "2aa1162e705bae3f" + }, + "entity": { + "Function": { + "name": "test_one_col_table", + "unaliased_name": "test_one_col_table", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_one_col_table", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 340, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "signature_hash": "c65ae0dbeb4d7c87" + }, + "entity": { + "Function": { + "name": "test_open_multiple_tuptables", + "unaliased_name": "test_open_multiple_tuptables", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 343, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "signature_hash": "57426d090ef70233" + }, + "entity": { + "Function": { + "name": "test_open_multiple_tuptables_rev", + "unaliased_name": "test_open_multiple_tuptables_rev", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 358, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_option", + "signature_hash": "7209b2d868b757a0" + }, + "entity": { + "Function": { + "name": "test_option", + "unaliased_name": "test_option", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_option", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 412, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "signature_hash": "96857ee93f77e653" + }, + "entity": { + "Function": { + "name": "test_option_anynumeric_sum", + "unaliased_name": "test_option_anynumeric_sum", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 218, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument", + "signature_hash": "b8b0a294c9392de5" + }, + "entity": { + "Function": { + "name": "test_option_default_argument", + "unaliased_name": "test_option_default_argument", + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 56, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument_specified", + "signature_hash": "bc4cf35b13fe9ee5" + }, + "entity": { + "Function": { + "name": "test_option_default_argument_specified", + "unaliased_name": "test_option_default_argument_specified", + "module_path": "pgrx_tests::tests::default_arg_value_tests::tests", + "full_path": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument_specified", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/default_arg_value_tests.rs", + "line": 62, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_optional_array", + "signature_hash": "f83f95bda68c9ae4" + }, + "entity": { + "Function": { + "name": "test_optional_array", + "unaliased_name": "test_optional_array", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_optional_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 238, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_optional_array_with_default", + "signature_hash": "d31e1b8e64155208" + }, + "entity": { + "Function": { + "name": "test_optional_array_with_default", + "unaliased_name": "test_optional_array_with_default", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_optional_array_with_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 260, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_ordering", + "signature_hash": "642ee903fcad6abd" + }, + "entity": { + "Function": { + "name": "test_ordering", + "unaliased_name": "test_ordering", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_ordering", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 197, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_overridden_sql_with_fn_name", + "signature_hash": "c29585e2053cff35" + }, + "entity": { + "Function": { + "name": "test_overridden_sql_with_fn_name", + "unaliased_name": "test_overridden_sql_with_fn_name", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_overridden_sql_with_fn_name", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 118, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "signature_hash": "7288e1b3a4a795a6" + }, + "entity": { + "Function": { + "name": "test_owned_prepared_statement", + "unaliased_name": "test_owned_prepared_statement", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 399, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_panic", + "signature_hash": "4dff44db400007cb" + }, + "entity": { + "Function": { + "name": "test_panic", + "unaliased_name": "test_panic", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_panic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 77, + "extern_attrs": [ + { + "ShouldPanic": "panic message" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "signature_hash": "d4c69b5c753839b" + }, + "entity": { + "Function": { + "name": "test_panic_in_extern_c_fn", + "unaliased_name": "test_panic_in_extern_c_fn", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 64, + "extern_attrs": [ + { + "ShouldPanic": "panic in walker" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_panic_via_spi", + "signature_hash": "de41251c9c3ef20b" + }, + "entity": { + "Function": { + "name": "test_panic_via_spi", + "unaliased_name": "test_panic_via_spi", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_panic_via_spi", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 162, + "extern_attrs": [ + { + "ShouldPanic": "did a panic" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_panics", + "signature_hash": "8ebb7c39cd134974" + }, + "entity": { + "Function": { + "name": "test_panics", + "unaliased_name": "test_panics", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_panics", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 316, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::tests::test_parse_uuid_v4", + "signature_hash": "2da77a7c9202e665" + }, + "entity": { + "Function": { + "name": "test_parse_uuid_v4", + "unaliased_name": "test_parse_uuid_v4", + "module_path": "pgrx_tests::tests::uuid_tests::tests", + "full_path": "pgrx_tests::tests::uuid_tests::tests::test_parse_uuid_v4", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 75, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_assignment_type_cast", + "signature_hash": "8a9a62a5f4ed3061" + }, + "entity": { + "Function": { + "name": "test_pg_cast_assignment_type_cast", + "unaliased_name": "test_pg_cast_assignment_type_cast", + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "full_path": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_assignment_type_cast", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 71, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_explicit_type_cast", + "signature_hash": "ec6f9e5b562bcbd5" + }, + "entity": { + "Function": { + "name": "test_pg_cast_explicit_type_cast", + "unaliased_name": "test_pg_cast_explicit_type_cast", + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "full_path": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_explicit_type_cast", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 62, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_implicit_type_cast", + "signature_hash": "6454772e2bb0ba49" + }, + "entity": { + "Function": { + "name": "test_pg_cast_implicit_type_cast", + "unaliased_name": "test_pg_cast_implicit_type_cast", + "module_path": "pgrx_tests::tests::pg_cast_tests::tests", + "full_path": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_implicit_type_cast", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 82, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_no_error", + "signature_hash": "7e84d0452cfe0969" + }, + "entity": { + "Function": { + "name": "test_pg_try_catch_and_rethrow_no_error", + "unaliased_name": "test_pg_try_catch_and_rethrow_no_error", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_no_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 131, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_with_error", + "signature_hash": "b774937e713247fd" + }, + "entity": { + "Function": { + "name": "test_pg_try_catch_and_rethrow_with_error", + "unaliased_name": "test_pg_try_catch_and_rethrow_with_error", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_with_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 137, + "extern_attrs": [ + { + "ShouldPanic": "rethrow a panic" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error", + "signature_hash": "53b2234230ba212d" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_no_error", + "unaliased_name": "test_pg_try_execute_no_error", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 105, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error_no_catch", + "signature_hash": "9648658f3f02d274" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_no_error_no_catch", + "unaliased_name": "test_pg_try_execute_no_error_no_catch", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error_no_catch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 69, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash", + "signature_hash": "eaa287b630b561d6" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_with_crash", + "unaliased_name": "test_pg_try_execute_with_crash", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 85, + "extern_attrs": [ + { + "ShouldPanic": "panic in walker" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_ignore", + "signature_hash": "8eff8a57d3c93cd4" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_with_crash_ignore", + "unaliased_name": "test_pg_try_execute_with_crash_ignore", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_ignore", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 90, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_rethrow", + "signature_hash": "5461d85869aea6b1" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_with_crash_rethrow", + "unaliased_name": "test_pg_try_execute_with_crash_rethrow", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_rethrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 98, + "extern_attrs": [ + { + "ShouldPanic": "panic in walker" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error", + "signature_hash": "d7ccac9f5d40ee98" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_with_error", + "unaliased_name": "test_pg_try_execute_with_error", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 75, + "extern_attrs": [ + { + "ShouldPanic": "unwrapped a panic" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error_report", + "signature_hash": "11478174a0b5290f" + }, + "entity": { + "Function": { + "name": "test_pg_try_execute_with_error_report", + "unaliased_name": "test_pg_try_execute_with_error_report", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error_report", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 80, + "extern_attrs": [ + { + "ShouldPanic": "raised an error" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally", + "signature_hash": "31fa562c80718e4b" + }, + "entity": { + "Function": { + "name": "test_pg_try_finally", + "unaliased_name": "test_pg_try_finally", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 142, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch", + "signature_hash": "59dc51aae0dab8d" + }, + "entity": { + "Function": { + "name": "test_pg_try_finally_with_catch", + "unaliased_name": "test_pg_try_finally_with_catch", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 150, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch_rethrow", + "signature_hash": "957faf682a905667" + }, + "entity": { + "Function": { + "name": "test_pg_try_finally_with_catch_rethrow", + "unaliased_name": "test_pg_try_finally_with_catch_rethrow", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch_rethrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 161, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_ignore_panic", + "signature_hash": "cc35f2db7841bf35" + }, + "entity": { + "Function": { + "name": "test_pg_try_ignore_panic", + "unaliased_name": "test_pg_try_ignore_panic", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_ignore_panic", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 111, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_no_error_with_catch", + "signature_hash": "692b49fde799cda2" + }, + "entity": { + "Function": { + "name": "test_pg_try_no_error_with_catch", + "unaliased_name": "test_pg_try_no_error_with_catch", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_no_error_with_catch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 118, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_throw_different_error", + "signature_hash": "f7fbd1bdf1c7975b" + }, + "entity": { + "Function": { + "name": "test_pg_try_throw_different_error", + "unaliased_name": "test_pg_try_throw_different_error", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_throw_different_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 124, + "extern_attrs": [ + { + "ShouldPanic": "panic in catch" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "signature_hash": "24da7eddbfc3cfbf" + }, + "entity": { + "Function": { + "name": "test_point_into_datum", + "unaliased_name": "test_point_into_datum", + "module_path": "pgrx_tests::tests::geo_tests::tests", + "full_path": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/geo_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "signature_hash": "22a6a342d44c9a5d" + }, + "entity": { + "Function": { + "name": "test_prepared_statement", + "unaliased_name": "test_prepared_statement", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 374, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement_argument_mismatch", + "signature_hash": "5f8e7f791156cb00" + }, + "entity": { + "Function": { + "name": "test_prepared_statement_argument_mismatch", + "unaliased_name": "test_prepared_statement_argument_mismatch", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement_argument_mismatch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 385, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "signature_hash": "2c69d951c1ad7e72" + }, + "entity": { + "Function": { + "name": "test_proper_sql_errcode", + "unaliased_name": "test_proper_sql_errcode", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < i32 > , pgrx :: spi :: Error >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 139, + "extern_attrs": [ + { + "ShouldPanic": "got proper sql errorcode" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, pgrx::spi::SpiError>", + "signature_hash": "dfc5c43482dd5d63" + }, + "entity": { + "BuiltinType": "core::result::Result, pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "signature_hash": "73dc732eeb4c3b6c" + }, + "entity": { + "Function": { + "name": "test_proper_sql_errcode_from_error_report", + "unaliased_name": "test_proper_sql_errcode_from_error_report", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < i32 > , pgrx :: spi :: Error >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 148, + "extern_attrs": [ + { + "ShouldPanic": "got proper sql errorcode" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_quote_identifier", + "signature_hash": "5b86983d8c6584c7" + }, + "entity": { + "Function": { + "name": "test_quote_identifier", + "unaliased_name": "test_quote_identifier", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_quote_identifier", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 515, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_quote_literal", + "signature_hash": "b1372e5be2955235" + }, + "entity": { + "Function": { + "name": "test_quote_literal", + "unaliased_name": "test_quote_literal", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_quote_literal", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 538, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_quote_qualified_identifier", + "signature_hash": "10534a7db02db14f" + }, + "entity": { + "Function": { + "name": "test_quote_qualified_identifier", + "unaliased_name": "test_quote_qualified_identifier", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_quote_qualified_identifier", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 522, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds", + "signature_hash": "49329d30eb86977" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds", + "unaliased_name": "test_range_date_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 240, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_empty", + "signature_hash": "e187592756d22b24" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_empty", + "unaliased_name": "test_range_date_rt_bounds_empty", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_empty", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 272, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_full", + "signature_hash": "90affa1e4da9ef6e" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_full", + "unaliased_name": "test_range_date_rt_bounds_full", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_full", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 367, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_inf", + "signature_hash": "aa20976c93e3a9fe" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_inf", + "unaliased_name": "test_range_date_rt_bounds_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 304, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf", + "signature_hash": "14f51c1848a141a2" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_neg_inf", + "unaliased_name": "test_range_date_rt_bounds_neg_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 288, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_inf", + "signature_hash": "8ce157d55a007b4a" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_neg_inf_inf", + "unaliased_name": "test_range_date_rt_bounds_neg_inf_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 320, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_val", + "signature_hash": "b7b154ab2fcdf869" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_neg_inf_val", + "unaliased_name": "test_range_date_rt_bounds_neg_inf_val", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_val", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 336, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_val_inf", + "signature_hash": "5c55a4333c513b53" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_bounds_val_inf", + "unaliased_name": "test_range_date_rt_bounds_val_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_val_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 352, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values", + "signature_hash": "3a7b2a8bea5555ab" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values", + "unaliased_name": "test_range_date_rt_values", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 232, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_empty", + "signature_hash": "ad4954d8ce2be32" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_empty", + "unaliased_name": "test_range_date_rt_values_empty", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_empty", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 264, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_full", + "signature_hash": "7f095949e527c774" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_full", + "unaliased_name": "test_range_date_rt_values_full", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_full", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 360, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_inf", + "signature_hash": "1c3fc45ad4923819" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_inf", + "unaliased_name": "test_range_date_rt_values_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 296, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf", + "signature_hash": "62b1454005e2b3c1" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_neg_inf", + "unaliased_name": "test_range_date_rt_values_neg_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 280, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_inf", + "signature_hash": "448f7194df7b3107" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_neg_inf_inf", + "unaliased_name": "test_range_date_rt_values_neg_inf_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 312, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_val", + "signature_hash": "119c2b615ae0afe1" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_neg_inf_val", + "unaliased_name": "test_range_date_rt_values_neg_inf_val", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_val", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 328, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_val_inf", + "signature_hash": "b9f162128ef2cf61" + }, + "entity": { + "Function": { + "name": "test_range_date_rt_values_val_inf", + "unaliased_name": "test_range_date_rt_values_val_inf", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_val_inf", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 344, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_bounds", + "signature_hash": "923478823bdf4cdc" + }, + "entity": { + "Function": { + "name": "test_range_i32_rt_bounds", + "unaliased_name": "test_range_i32_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_bounds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 192, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_values", + "signature_hash": "6c7731e474b154b8" + }, + "entity": { + "Function": { + "name": "test_range_i32_rt_values", + "unaliased_name": "test_range_i32_rt_values", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_values", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 184, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_bounds", + "signature_hash": "9779d7cfebfb6932" + }, + "entity": { + "Function": { + "name": "test_range_i64_rt_bounds", + "unaliased_name": "test_range_i64_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_bounds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 208, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_values", + "signature_hash": "43602039f2258bbd" + }, + "entity": { + "Function": { + "name": "test_range_i64_rt_values", + "unaliased_name": "test_range_i64_rt_values", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_values", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 200, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_bounds", + "signature_hash": "4d86bdebb00d2fad" + }, + "entity": { + "Function": { + "name": "test_range_num_rt_bounds", + "unaliased_name": "test_range_num_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_bounds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 224, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_values", + "signature_hash": "402a7e8bb77186f3" + }, + "entity": { + "Function": { + "name": "test_range_num_rt_values", + "unaliased_name": "test_range_num_rt_values", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_values", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 216, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_bounds", + "signature_hash": "5d2d28546c25bc65" + }, + "entity": { + "Function": { + "name": "test_range_ts_rt_bounds", + "unaliased_name": "test_range_ts_rt_bounds", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_bounds", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 256, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_values", + "signature_hash": "7d7b6636a22f93a9" + }, + "entity": { + "Function": { + "name": "test_range_ts_rt_values", + "unaliased_name": "test_range_ts_rt_values", + "module_path": "pgrx_tests::tests::range_tests::tests", + "full_path": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_values", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/range_tests.rs", + "line": 248, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "signature_hash": "7afda92652f4b66e" + }, + "entity": { + "Function": { + "name": "test_readwrite_in_readonly", + "unaliased_name": "test_readwrite_in_readonly", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 417, + "extern_attrs": [ + { + "ShouldPanic": "CREATE TABLE is not allowed in a non-volatile function" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "signature_hash": "2e3b70dbef323e15" + }, + "entity": { + "Function": { + "name": "test_readwrite_in_select_readwrite", + "unaliased_name": "test_readwrite_in_select_readwrite", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 423, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "signature_hash": "efbe4064ce612467" + }, + "entity": { + "Function": { + "name": "test_reasonable_oid", + "unaliased_name": "test_reasonable_oid", + "module_path": "pgrx_tests::tests::oid_tests::tests", + "full_path": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/oid_tests.rs", + "line": 23, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_result_table_1", + "signature_hash": "446837e0deb488f4" + }, + "entity": { + "Function": { + "name": "test_result_table_1", + "unaliased_name": "test_result_table_1", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_result_table_1", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 311, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_result_table_2", + "signature_hash": "aac96adca663c983" + }, + "entity": { + "Function": { + "name": "test_result_table_2", + "unaliased_name": "test_result_table_2", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_result_table_2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 317, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_result_table_3", + "signature_hash": "713828e7b2641eff" + }, + "entity": { + "Function": { + "name": "test_result_table_3", + "unaliased_name": "test_result_table_3", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_result_table_3", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 323, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_result_table_4_err", + "signature_hash": "7a8dd540c8278f6f" + }, + "entity": { + "Function": { + "name": "test_result_table_4_err", + "unaliased_name": "test_result_table_4_err", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_result_table_4_err", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 329, + "extern_attrs": [ + { + "ShouldPanic": "oh no" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_result_table_5_none", + "signature_hash": "cf8e7db3bc0b23be" + }, + "entity": { + "Function": { + "name": "test_result_table_5_none", + "unaliased_name": "test_result_table_5_none", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_result_table_5_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 334, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "signature_hash": "e042342ce2142ba1" + }, + "entity": { + "Function": { + "name": "test_return_3pm_mountain_time", + "unaliased_name": "test_return_3pm_mountain_time", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 298, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_return_a_f64_numeric", + "signature_hash": "5848e6cf1da2eb3f" + }, + "entity": { + "Function": { + "name": "test_return_a_f64_numeric", + "unaliased_name": "test_return_a_f64_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_return_a_f64_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 50, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_return_a_u64_numeric", + "signature_hash": "518ffa250287aaf1" + }, + "entity": { + "Function": { + "name": "test_return_a_u64_numeric", + "unaliased_name": "test_return_a_u64_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_return_a_u64_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 57, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::numeric_tests::tests::test_return_an_i32_numeric", + "signature_hash": "f00520e201c8330e" + }, + "entity": { + "Function": { + "name": "test_return_an_i32_numeric", + "unaliased_name": "test_return_an_i32_numeric", + "module_path": "pgrx_tests::tests::numeric_tests::tests", + "full_path": "pgrx_tests::tests::numeric_tests::tests::test_return_an_i32_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/numeric_tests.rs", + "line": 44, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes", + "signature_hash": "9d2d44aa5b343a12" + }, + "entity": { + "Function": { + "name": "test_return_bytes", + "unaliased_name": "test_return_bytes", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 23, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes_slice", + "signature_hash": "2b45411d0b480ea0" + }, + "entity": { + "Function": { + "name": "test_return_bytes_slice", + "unaliased_name": "test_return_bytes_slice", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes_slice", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 34, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_return_empty_iterator", + "signature_hash": "4256da28dd8c4f68" + }, + "entity": { + "Function": { + "name": "test_return_empty_iterator", + "unaliased_name": "test_return_empty_iterator", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_return_empty_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 211, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_return_empty_setof_iterator", + "signature_hash": "6fd0d22d4e7b60ff" + }, + "entity": { + "Function": { + "name": "test_return_empty_setof_iterator", + "unaliased_name": "test_return_empty_setof_iterator", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_return_empty_setof_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 233, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result", + "signature_hash": "cc2d80e742cace12" + }, + "entity": { + "Function": { + "name": "test_return_eyre_result", + "unaliased_name": "test_return_eyre_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 129, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result_error", + "signature_hash": "1ef5fd6662a0f438" + }, + "entity": { + "Function": { + "name": "test_return_eyre_result_error", + "unaliased_name": "test_return_eyre_result_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 134, + "extern_attrs": [ + { + "ShouldPanic": "error!" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "signature_hash": "c0dbc4fdf3370df2" + }, + "entity": { + "Function": { + "name": "test_return_io_error", + "unaliased_name": "test_return_io_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), std::io::error::Error>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), std::io::error::Error>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), std :: io :: Error >", + "full_path": "core::result::Result<(), std::io::error::Error>", + "module_path": "core::result::Result<(), std::io::error", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), std::io::error::Error>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 100, + "extern_attrs": [ + { + "ShouldPanic": "I am a platform-independent and locale-agnostic string" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result<(), std::io::error::Error>", + "signature_hash": "458ef81c4bd102a3" + }, + "entity": { + "BuiltinType": "core::result::Result<(), std::io::error::Error>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_none_optional_result", + "signature_hash": "9bbb11e503b54598" + }, + "entity": { + "Function": { + "name": "test_return_none_optional_result", + "unaliased_name": "test_return_none_optional_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_none_optional_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 119, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_result", + "signature_hash": "d2ee0f1472ea1be" + }, + "entity": { + "Function": { + "name": "test_return_result", + "unaliased_name": "test_return_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 109, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "signature_hash": "7b2f30a76b352d16" + }, + "entity": { + "Function": { + "name": "test_return_result_set_of", + "unaliased_name": "test_return_result_set_of", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 174, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "signature_hash": "2a1fddc1725d2e2c" + }, + "entity": { + "Function": { + "name": "test_return_result_set_of_error", + "unaliased_name": "test_return_result_set_of_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 179, + "extern_attrs": [ + { + "ShouldPanic": "SpiTupleTable positioned before the start or after the end" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "signature_hash": "46b5a625c0013b8" + }, + "entity": { + "Function": { + "name": "test_return_result_table_iterator", + "unaliased_name": "test_return_result_table_iterator", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 164, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "signature_hash": "211758fd6a477961" + }, + "entity": { + "Function": { + "name": "test_return_result_table_iterator_error", + "unaliased_name": "test_return_result_table_iterator_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 169, + "extern_attrs": [ + { + "ShouldPanic": "SpiTupleTable positioned before the start or after the end" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_return_setof_iterator", + "signature_hash": "7250a6afdb6aeefb" + }, + "entity": { + "Function": { + "name": "test_return_setof_iterator", + "unaliased_name": "test_return_setof_iterator", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_return_setof_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 222, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_some_error", + "signature_hash": "72a723afac6a3993" + }, + "entity": { + "Function": { + "name": "test_return_some_error", + "unaliased_name": "test_return_some_error", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_some_error", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 124, + "extern_attrs": [ + { + "ShouldPanic": "error!" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::result_tests::tests::test_return_some_optional_result", + "signature_hash": "96b5a60468e67901" + }, + "entity": { + "Function": { + "name": "test_return_some_optional_result", + "unaliased_name": "test_return_some_optional_result", + "module_path": "pgrx_tests::tests::result_tests::tests", + "full_path": "pgrx_tests::tests::result_tests::tests::test_return_some_optional_result", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/result_tests.rs", + "line": 114, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_return_table_iterator", + "signature_hash": "49042d4f37dd6638" + }, + "entity": { + "Function": { + "name": "test_return_table_iterator", + "unaliased_name": "test_return_table_iterator", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_return_table_iterator", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 200, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_return_text_array", + "signature_hash": "769181c1288ca341" + }, + "entity": { + "Function": { + "name": "test_return_text_array", + "unaliased_name": "test_return_text_array", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_return_text_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 283, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::uuid_tests::tests::test_return_uuid", + "signature_hash": "1dffe9a5c19822cd" + }, + "entity": { + "Function": { + "name": "test_return_uuid", + "unaliased_name": "test_return_uuid", + "module_path": "pgrx_tests::tests::uuid_tests::tests", + "full_path": "pgrx_tests::tests::uuid_tests::tests::test_return_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/uuid_tests.rs", + "line": 67, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_bytes", + "signature_hash": "2ec91d6f8f9b7fea" + }, + "entity": { + "Function": { + "name": "test_return_vec_bytes", + "unaliased_name": "test_return_vec_bytes", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_bytes", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 45, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_subvec", + "signature_hash": "3e1431b67b524461" + }, + "entity": { + "Function": { + "name": "test_return_vec_subvec", + "unaliased_name": "test_return_vec_subvec", + "module_path": "pgrx_tests::tests::bytea_tests::tests", + "full_path": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_subvec", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/bytea_tests.rs", + "line": 56, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_return_zero_length_vec", + "signature_hash": "f806139e5066e5c5" + }, + "entity": { + "Function": { + "name": "test_return_zero_length_vec", + "unaliased_name": "test_return_zero_length_vec", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_return_zero_length_vec", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 289, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_none", + "signature_hash": "f448e05bc41a7de6" + }, + "entity": { + "Function": { + "name": "test_returns_none", + "unaliased_name": "test_returns_none", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_none", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 310, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_some", + "signature_hash": "c9221427dc1d9f44" + }, + "entity": { + "Function": { + "name": "test_returns_some", + "unaliased_name": "test_returns_some", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_some", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 304, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_tuple", + "signature_hash": "356dd3aa697070f1" + }, + "entity": { + "Function": { + "name": "test_returns_tuple", + "unaliased_name": "test_returns_tuple", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_tuple", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 330, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_void", + "signature_hash": "10a48aea80d6b85e" + }, + "entity": { + "Function": { + "name": "test_returns_void", + "unaliased_name": "test_returns_void", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_void", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 324, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "signature_hash": "9d747f9e654177a4" + }, + "entity": { + "Function": { + "name": "test_rt_anynumeric", + "unaliased_name": "test_rt_anynumeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 147, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "signature_hash": "af0e1b7e9a02573b" + }, + "entity": { + "Function": { + "name": "test_rt_array_anynumeric", + "unaliased_name": "test_rt_array_anynumeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 349, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "signature_hash": "32129e22c830734f" + }, + "entity": { + "Function": { + "name": "test_rt_array_bool", + "unaliased_name": "test_rt_array_bool", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 324, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "signature_hash": "c579eb4889e0262e" + }, + "entity": { + "Function": { + "name": "test_rt_array_box", + "unaliased_name": "test_rt_array_box", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 290, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "signature_hash": "26e73dea04cf26ef" + }, + "entity": { + "Function": { + "name": "test_rt_array_char", + "unaliased_name": "test_rt_array_char", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 227, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "signature_hash": "b6270fcd2f19505" + }, + "entity": { + "Function": { + "name": "test_rt_array_complex", + "unaliased_name": "test_rt_array_complex", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 469, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "signature_hash": "ae7d70106ff23623" + }, + "entity": { + "Function": { + "name": "test_rt_array_date", + "unaliased_name": "test_rt_array_date", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 362, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "signature_hash": "1a3783833bae3b29" + }, + "entity": { + "Function": { + "name": "test_rt_array_f32", + "unaliased_name": "test_rt_array_f32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 330, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "signature_hash": "e7e1104edbb75fef" + }, + "entity": { + "Function": { + "name": "test_rt_array_f64", + "unaliased_name": "test_rt_array_f64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 284, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "signature_hash": "f2e003ff1214dd5c" + }, + "entity": { + "Function": { + "name": "test_rt_array_i16", + "unaliased_name": "test_rt_array_i16", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 278, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "signature_hash": "5a91a033097310b2" + }, + "entity": { + "Function": { + "name": "test_rt_array_i32", + "unaliased_name": "test_rt_array_i32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 318, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "signature_hash": "df70236a84fb65d0" + }, + "entity": { + "Function": { + "name": "test_rt_array_i64", + "unaliased_name": "test_rt_array_i64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 312, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "signature_hash": "82bda2e0859f5f32" + }, + "entity": { + "Function": { + "name": "test_rt_array_i8", + "unaliased_name": "test_rt_array_i8", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 233, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "signature_hash": "94914253a2c1eff2" + }, + "entity": { + "Function": { + "name": "test_rt_array_interval", + "unaliased_name": "test_rt_array_interval", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 427, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "signature_hash": "d0cf26a503361c62" + }, + "entity": { + "Function": { + "name": "test_rt_array_numeric", + "unaliased_name": "test_rt_array_numeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 336, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "signature_hash": "744f9873450cf283" + }, + "entity": { + "Function": { + "name": "test_rt_array_oid", + "unaliased_name": "test_rt_array_oid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 265, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "signature_hash": "9d5a4285d6eb6fc0" + }, + "entity": { + "Function": { + "name": "test_rt_array_point", + "unaliased_name": "test_rt_array_point", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 239, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "signature_hash": "21ea029993c8b178" + }, + "entity": { + "Function": { + "name": "test_rt_array_random_data", + "unaliased_name": "test_rt_array_random_data", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 455, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "signature_hash": "316e515089e509f5" + }, + "entity": { + "Function": { + "name": "test_rt_array_string", + "unaliased_name": "test_rt_array_string", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 252, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "signature_hash": "5d9833b2db35b8b8" + }, + "entity": { + "Function": { + "name": "test_rt_array_time", + "unaliased_name": "test_rt_array_time", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 401, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "signature_hash": "5531f910134406ee" + }, + "entity": { + "Function": { + "name": "test_rt_array_timetz", + "unaliased_name": "test_rt_array_timetz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 414, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "signature_hash": "4fc4d669f12d06a3" + }, + "entity": { + "Function": { + "name": "test_rt_array_ts", + "unaliased_name": "test_rt_array_ts", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 375, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "signature_hash": "3ca5e0a118b9b8fb" + }, + "entity": { + "Function": { + "name": "test_rt_array_tstz", + "unaliased_name": "test_rt_array_tstz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 388, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "signature_hash": "6750dbc2d9d6445d" + }, + "entity": { + "Function": { + "name": "test_rt_array_uuid", + "unaliased_name": "test_rt_array_uuid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 441, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "signature_hash": "4fe2391e6a661037" + }, + "entity": { + "Function": { + "name": "test_rt_bool", + "unaliased_name": "test_rt_bool", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 144, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "signature_hash": "f8c554022bf55f4" + }, + "entity": { + "Function": { + "name": "test_rt_box", + "unaliased_name": "test_rt_box", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 132, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "signature_hash": "ed4feb74da7dd994" + }, + "entity": { + "Function": { + "name": "test_rt_bytea", + "unaliased_name": "test_rt_bytea", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 116, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "signature_hash": "fed0378104657fed" + }, + "entity": { + "Function": { + "name": "test_rt_char_0", + "unaliased_name": "test_rt_char_0", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 117, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "signature_hash": "6a0e9fd07a704c4c" + }, + "entity": { + "Function": { + "name": "test_rt_char_1", + "unaliased_name": "test_rt_char_1", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 118, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "signature_hash": "1b6e2d255cf1502f" + }, + "entity": { + "Function": { + "name": "test_rt_char_2", + "unaliased_name": "test_rt_char_2", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 119, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "signature_hash": "c0d75eb18b11353f" + }, + "entity": { + "Function": { + "name": "test_rt_char_3", + "unaliased_name": "test_rt_char_3", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 120, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "signature_hash": "d59c39a01407d7fb" + }, + "entity": { + "Function": { + "name": "test_rt_char_4", + "unaliased_name": "test_rt_char_4", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 121, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "signature_hash": "26b6862b92f0b560" + }, + "entity": { + "Function": { + "name": "test_rt_char_5", + "unaliased_name": "test_rt_char_5", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 122, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "signature_hash": "54285d6800a14043" + }, + "entity": { + "Function": { + "name": "test_rt_char_6", + "unaliased_name": "test_rt_char_6", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 123, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "signature_hash": "8f1d3ebe90513d90" + }, + "entity": { + "Function": { + "name": "test_rt_char_7", + "unaliased_name": "test_rt_char_7", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 124, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "signature_hash": "63d5c2dfd24bc0da" + }, + "entity": { + "Function": { + "name": "test_rt_complex", + "unaliased_name": "test_rt_complex", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 180, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "signature_hash": "e1c16369a3102be3" + }, + "entity": { + "Function": { + "name": "test_rt_cstr", + "unaliased_name": "test_rt_cstr", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 153, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "signature_hash": "1e285c00c903e113" + }, + "entity": { + "Function": { + "name": "test_rt_date", + "unaliased_name": "test_rt_date", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 155, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "signature_hash": "a8693a886a55bdca" + }, + "entity": { + "Function": { + "name": "test_rt_f32", + "unaliased_name": "test_rt_f32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 145, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "signature_hash": "c38b0200d5bdd348" + }, + "entity": { + "Function": { + "name": "test_rt_f64", + "unaliased_name": "test_rt_f64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 131, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "signature_hash": "27ce179170408f15" + }, + "entity": { + "Function": { + "name": "test_rt_i16", + "unaliased_name": "test_rt_i16", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 130, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "signature_hash": "9bbcbb16830b1db9" + }, + "entity": { + "Function": { + "name": "test_rt_i32", + "unaliased_name": "test_rt_i32", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 142, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "signature_hash": "9d430f957838e8bb" + }, + "entity": { + "Function": { + "name": "test_rt_i64", + "unaliased_name": "test_rt_i64", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 141, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "signature_hash": "6cf71c52c87b2265" + }, + "entity": { + "Function": { + "name": "test_rt_i8", + "unaliased_name": "test_rt_i8", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 125, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "signature_hash": "a7742f275f738bc2" + }, + "entity": { + "Function": { + "name": "test_rt_interval", + "unaliased_name": "test_rt_interval", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 170, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "signature_hash": "cbf0bb0b0f8ed57b" + }, + "entity": { + "Function": { + "name": "test_rt_numeric", + "unaliased_name": "test_rt_numeric", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 146, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "signature_hash": "776a4ddf2ca82a1e" + }, + "entity": { + "Function": { + "name": "test_rt_oid", + "unaliased_name": "test_rt_oid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 128, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "signature_hash": "5ff4a8458395bc47" + }, + "entity": { + "Function": { + "name": "test_rt_point", + "unaliased_name": "test_rt_point", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 126, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "signature_hash": "ee844cd22145b97f" + }, + "entity": { + "Function": { + "name": "test_rt_random_data", + "unaliased_name": "test_rt_random_data", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 179, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "signature_hash": "6e2b2ebb39104544" + }, + "entity": { + "Function": { + "name": "test_rt_refstr", + "unaliased_name": "test_rt_refstr", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 143, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "signature_hash": "2d64f9bfd7733ed7" + }, + "entity": { + "Function": { + "name": "test_rt_string", + "unaliased_name": "test_rt_string", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 127, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "signature_hash": "62d848b3234ae072" + }, + "entity": { + "Function": { + "name": "test_rt_time", + "unaliased_name": "test_rt_time", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 163, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "signature_hash": "4b76a3b268db4f2c" + }, + "entity": { + "Function": { + "name": "test_rt_timetz", + "unaliased_name": "test_rt_timetz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 164, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "signature_hash": "459370cb47097925" + }, + "entity": { + "Function": { + "name": "test_rt_ts", + "unaliased_name": "test_rt_ts", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 156, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "signature_hash": "3ea6ff22dd690f87" + }, + "entity": { + "Function": { + "name": "test_rt_tstz", + "unaliased_name": "test_rt_tstz", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 157, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "signature_hash": "48f95febf32fcac8" + }, + "entity": { + "Function": { + "name": "test_rt_uuid", + "unaliased_name": "test_rt_uuid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 172, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "signature_hash": "e674c65c1eb2121a" + }, + "entity": { + "Function": { + "name": "test_rt_xid", + "unaliased_name": "test_rt_xid", + "module_path": "pgrx_tests::tests::roundtrip_tests::tests", + "full_path": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/roundtrip_tests.rs", + "line": 129, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_same_name", + "signature_hash": "7afe4f181a7d59ef" + }, + "entity": { + "Function": { + "name": "test_same_name", + "unaliased_name": "test_same_name", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_same_name", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 338, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "signature_hash": "fdd907fee5a75ad7" + }, + "entity": { + "Function": { + "name": "test_scritch", + "unaliased_name": "test_scritch", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 729, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "signature_hash": "e3e725f457d28e35" + }, + "entity": { + "Function": { + "name": "test_scritch_strict", + "unaliased_name": "test_scritch_strict", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 742, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_security_definer", + "signature_hash": "1ee45fc00b92cbb" + }, + "entity": { + "Function": { + "name": "test_security_definer", + "unaliased_name": "test_security_definer", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_security_definer", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 99, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::tests::test_security_invoker", + "signature_hash": "ec3f56314d94058" + }, + "entity": { + "Function": { + "name": "test_security_invoker", + "unaliased_name": "test_security_invoker", + "module_path": "pgrx_tests::tests::pg_extern_tests::tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::tests::test_security_invoker", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 88, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "signature_hash": "77e316d6cd38e69e" + }, + "entity": { + "Function": { + "name": "test_serde_serialize_array_i32", + "unaliased_name": "test_serde_serialize_array_i32", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 266, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "signature_hash": "ffa9e5e0b837668f" + }, + "entity": { + "Function": { + "name": "test_serde_serialize_array_i32_deny_null", + "unaliased_name": "test_serde_serialize_array_i32_deny_null", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < Json > , pgrx :: spi :: Error >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 276, + "extern_attrs": [ + { + "ShouldPanic": "array contains NULL" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, pgrx::spi::SpiError>", + "signature_hash": "971c16df1bd5b85d" + }, + "entity": { + "BuiltinType": "core::result::Result, pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::inet_tests::tests::test_serialize_inet", + "signature_hash": "1277211b3fc8023c" + }, + "entity": { + "Function": { + "name": "test_serialize_inet", + "unaliased_name": "test_serialize_inet", + "module_path": "pgrx_tests::tests::inet_tests::tests", + "full_path": "pgrx_tests::tests::inet_tests::tests::test_serialize_inet", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/inet_tests.rs", + "line": 26, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "signature_hash": "4195bffa5b9aedd" + }, + "entity": { + "Function": { + "name": "test_serialized_enum_type", + "unaliased_name": "test_serialized_enum_type", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 233, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "signature_hash": "cf6129c416e0ae39" + }, + "entity": { + "Function": { + "name": "test_serializedtype", + "unaliased_name": "test_serializedtype", + "module_path": "pgrx_tests::tests::postgres_type_tests::tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 207, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_show_hook", + "signature_hash": "fe6b8afe4429f3a1" + }, + "entity": { + "Function": { + "name": "test_show_hook", + "unaliased_name": "test_show_hook", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_show_hook", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 349, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "signature_hash": "ab671d500772e3e" + }, + "entity": { + "Function": { + "name": "test_slice_to_array", + "unaliased_name": "test_slice_to_array", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 295, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "signature_hash": "1c4594f5c1ab8ca1" + }, + "entity": { + "Function": { + "name": "test_slice_with_null", + "unaliased_name": "test_slice_with_null", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 425, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "signature_hash": "c54908884089de90" + }, + "entity": { + "Function": { + "name": "test_spi_can_nest", + "unaliased_name": "test_spi_can_nest", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "signature_hash": "ac301522571af256" + }, + "entity": { + "Function": { + "name": "test_spi_explain", + "unaliased_name": "test_spi_explain", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 139, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "signature_hash": "4253861c612d31b" + }, + "entity": { + "Function": { + "name": "test_spi_explain_with_args", + "unaliased_name": "test_spi_explain_with_args", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 146, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "signature_hash": "24ac2f1e0721fe3c" + }, + "entity": { + "Function": { + "name": "test_spi_failure", + "unaliased_name": "test_spi_failure", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 22, + "extern_attrs": [ + { + "ShouldPanic": "syntax error at or near \"THIS\"" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "signature_hash": "97cd728971c465fb" + }, + "entity": { + "Function": { + "name": "test_spi_get_one", + "unaliased_name": "test_spi_get_one", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 63, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "signature_hash": "dfa785d4196b15f" + }, + "entity": { + "Function": { + "name": "test_spi_get_three", + "unaliased_name": "test_spi_get_three", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 84, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "signature_hash": "5a2048dbf57b723e" + }, + "entity": { + "Function": { + "name": "test_spi_get_three_failure", + "unaliased_name": "test_spi_get_three_failure", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 107, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "signature_hash": "d5f7b6c97289bfc1" + }, + "entity": { + "Function": { + "name": "test_spi_get_two", + "unaliased_name": "test_spi_get_two", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 72, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "signature_hash": "c93b4f6613952cc5" + }, + "entity": { + "Function": { + "name": "test_spi_get_two_with_failure", + "unaliased_name": "test_spi_get_two_with_failure", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 99, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "signature_hash": "d13e5c5f7f9854b0" + }, + "entity": { + "Function": { + "name": "test_spi_non_mut", + "unaliased_name": "test_spi_non_mut", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 334, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "signature_hash": "5219c2ed1b53c8a6" + }, + "entity": { + "Function": { + "name": "test_spi_returns_primitive", + "unaliased_name": "test_spi_returns_primitive", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 34, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "signature_hash": "8cf425dee247090f" + }, + "entity": { + "Function": { + "name": "test_spi_returns_str", + "unaliased_name": "test_spi_returns_str", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 43, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "signature_hash": "c3eeae225fa19839" + }, + "entity": { + "Function": { + "name": "test_spi_returns_string", + "unaliased_name": "test_spi_returns_string", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 53, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_run", + "signature_hash": "61bfe491eb0e1c9f" + }, + "entity": { + "Function": { + "name": "test_spi_run", + "unaliased_name": "test_spi_run", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_run", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 126, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_run_with_args", + "signature_hash": "1c0cce948528226d" + }, + "entity": { + "Function": { + "name": "test_spi_run_with_args", + "unaliased_name": "test_spi_run_with_args", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_run_with_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 131, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "signature_hash": "4bda5390c7c677d" + }, + "entity": { + "Function": { + "name": "test_spi_select_sees_run", + "unaliased_name": "test_spi_select_sees_run", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 467, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "signature_hash": "b317c0f9d359f318" + }, + "entity": { + "Function": { + "name": "test_spi_select_sees_update", + "unaliased_name": "test_spi_select_sees_update", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 454, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "signature_hash": "fa016b26c57a0a48" + }, + "entity": { + "Function": { + "name": "test_spi_select_sees_update_in_other_session", + "unaliased_name": "test_spi_select_sees_update_in_other_session", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "spi :: Result < () >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 480, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::spi_tests::tests::test_spi_select_zero_rows", + "signature_hash": "45563dc3a3eca50b" + }, + "entity": { + "Function": { + "name": "test_spi_select_zero_rows", + "unaliased_name": "test_spi_select_zero_rows", + "module_path": "pgrx_tests::tests::spi_tests::tests", + "full_path": "pgrx_tests::tests::spi_tests::tests::test_spi_select_zero_rows", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/spi_tests.rs", + "line": 121, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_sql_int4eq", + "signature_hash": "1cc410326743dfeb" + }, + "entity": { + "Function": { + "name": "test_sql_int4eq", + "unaliased_name": "test_sql_int4eq", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_sql_int4eq", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 72, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_srf_setof_datum_detoasting_with_borrow", + "signature_hash": "fa60f98723cc1519" + }, + "entity": { + "Function": { + "name": "test_srf_setof_datum_detoasting_with_borrow", + "unaliased_name": "test_srf_setof_datum_detoasting_with_borrow", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_srf_setof_datum_detoasting_with_borrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 244, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::srf_tests::tests::test_srf_table_datum_detoasting_with_borrow", + "signature_hash": "349848f0fd640c6b" + }, + "entity": { + "Function": { + "name": "test_srf_table_datum_detoasting_with_borrow", + "unaliased_name": "test_srf_table_datum_detoasting_with_borrow", + "module_path": "pgrx_tests::tests::srf_tests::tests", + "full_path": "pgrx_tests::tests::srf_tests::tests::test_srf_table_datum_detoasting_with_borrow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/srf_tests.rs", + "line": 262, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_strict", + "signature_hash": "15268cf233d72efc" + }, + "entity": { + "Function": { + "name": "test_strict", + "unaliased_name": "test_strict", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_strict", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 90, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_string_guc", + "signature_hash": "cc8cfa198505af88" + }, + "entity": { + "Function": { + "name": "test_string_guc", + "unaliased_name": "test_string_guc", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_string_guc", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 107, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::guc_tests::tests::test_string_guc_null_default", + "signature_hash": "9fc330f1031d735a" + }, + "entity": { + "Function": { + "name": "test_string_guc_null_default", + "unaliased_name": "test_string_guc_null_default", + "module_path": "pgrx_tests::tests::guc_tests::tests", + "full_path": "pgrx_tests::tests::guc_tests::tests::test_string_guc_null_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/guc_tests.rs", + "line": 129, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32", + "signature_hash": "e1906093820243c6" + }, + "entity": { + "Function": { + "name": "test_sum_array_i32", + "unaliased_name": "test_sum_array_i32", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 207, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "signature_hash": "108d5a15f1e7c88c" + }, + "entity": { + "Function": { + "name": "test_sum_array_i32_overflow", + "unaliased_name": "test_sum_array_i32_overflow", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result, pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < Option < i64 > , pgrx :: spi :: Error >", + "full_path": "core::result::Result, pgrx::spi::SpiError>", + "module_path": "core::result::Result, pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::result::Result, pgrx::spi::SpiError>", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 219, + "extern_attrs": [ + { + "ShouldPanic": "attempt to add with overflow" + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result, pgrx::spi::SpiError>", + "signature_hash": "683fa6e5dd0e252e" + }, + "entity": { + "BuiltinType": "core::result::Result, pgrx::spi::SpiError>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_sum_array_i64", + "signature_hash": "a74c55feaace5130" + }, + "entity": { + "Function": { + "name": "test_sum_array_i64", + "unaliased_name": "test_sum_array_i64", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_sum_array_i64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 213, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "signature_hash": "2d9c0f1671f4a44d" + }, + "entity": { + "Function": { + "name": "test_support_fn", + "unaliased_name": "test_support_fn", + "module_path": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "full_path": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx::datum::internal::Internal" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 18, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::inet_tests::tests::test_take_and_return_inet", + "signature_hash": "cd42f58817f34914" + }, + "entity": { + "Function": { + "name": "test_take_and_return_inet", + "unaliased_name": "test_take_and_return_inet", + "module_path": "pgrx_tests::tests::inet_tests::tests", + "full_path": "pgrx_tests::tests::inet_tests::tests::test_take_and_return_inet", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/inet_tests.rs", + "line": 38, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_bool", + "signature_hash": "88ce6882225aa1a" + }, + "entity": { + "Function": { + "name": "test_takes_bool", + "unaliased_name": "test_takes_bool", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 226, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_char", + "signature_hash": "79de3b19ad7c7ce" + }, + "entity": { + "Function": { + "name": "test_takes_char", + "unaliased_name": "test_takes_char", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_char", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 261, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f32", + "signature_hash": "5b733a69e86abc6c" + }, + "entity": { + "Function": { + "name": "test_takes_f32", + "unaliased_name": "test_takes_f32", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 237, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f64", + "signature_hash": "d48a99b6fd553b17" + }, + "entity": { + "Function": { + "name": "test_takes_f64", + "unaliased_name": "test_takes_f64", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 246, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i16", + "signature_hash": "c5109952f3fd8680" + }, + "entity": { + "Function": { + "name": "test_takes_i16", + "unaliased_name": "test_takes_i16", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i16", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 199, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i32", + "signature_hash": "de419ac63bfb2ca4" + }, + "entity": { + "Function": { + "name": "test_takes_i32", + "unaliased_name": "test_takes_i32", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 208, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i64", + "signature_hash": "5a91ecfa108904ae" + }, + "entity": { + "Function": { + "name": "test_takes_i64", + "unaliased_name": "test_takes_i64", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i64", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 217, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i8", + "signature_hash": "3f330c3d4eb2adfe" + }, + "entity": { + "Function": { + "name": "test_takes_i8", + "unaliased_name": "test_takes_i8", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i8", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 255, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_non_null_arg", + "signature_hash": "5d7274ebd2c62beb" + }, + "entity": { + "Function": { + "name": "test_takes_option_with_non_null_arg", + "unaliased_name": "test_takes_option_with_non_null_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_non_null_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 273, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_null_arg", + "signature_hash": "309faaafe82bd76b" + }, + "entity": { + "Function": { + "name": "test_takes_option_with_null_arg", + "unaliased_name": "test_takes_option_with_null_arg", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_null_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 267, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_str", + "signature_hash": "2595b8d9f743472c" + }, + "entity": { + "Function": { + "name": "test_takes_str", + "unaliased_name": "test_takes_str", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_str", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 284, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_string", + "signature_hash": "e74b63d6b16b9ab3" + }, + "entity": { + "Function": { + "name": "test_takes_string", + "unaliased_name": "test_takes_string", + "module_path": "pgrx_tests::tests::fcinfo_tests::tests", + "full_path": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_string", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "unsafe fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fcinfo_tests.rs", + "line": 293, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "signature_hash": "5bce5e88cc3dd8d" + }, + "entity": { + "Function": { + "name": "test_text_array_as_vec_string", + "unaliased_name": "test_text_array_as_vec_string", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 462, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "signature_hash": "f0d8d7f6426b9a1" + }, + "entity": { + "Function": { + "name": "test_text_array_iter", + "unaliased_name": "test_text_array_iter", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 474, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "signature_hash": "b985b4c2a64e2a71" + }, + "entity": { + "Function": { + "name": "test_text_array_via_getter", + "unaliased_name": "test_text_array_via_getter", + "module_path": "pgrx_tests::tests::array_tests::tests", + "full_path": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), alloc::boxed::Box>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result<(), alloc::boxed::Box>", + "module_path": "core::result::Result<(), alloc::boxed::Box>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 493, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_time_serialization", + "signature_hash": "b6e7ed5b9fe4dcf9" + }, + "entity": { + "Function": { + "name": "test_time_serialization", + "unaliased_name": "test_time_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_time_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 158, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_time_with_timezone_serialization", + "signature_hash": "2b2743ebab2738d6" + }, + "entity": { + "Function": { + "name": "test_time_with_timezone_serialization", + "unaliased_name": "test_time_with_timezone_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_time_with_timezone_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 123, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "signature_hash": "3422772c975041e4" + }, + "entity": { + "Function": { + "name": "test_timestamp_infinity", + "unaliased_name": "test_timestamp_infinity", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 400, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_serialization", + "signature_hash": "d525203804df0958" + }, + "entity": { + "Function": { + "name": "test_timestamp_serialization", + "unaliased_name": "test_timestamp_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 365, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "signature_hash": "80752ffa8631f09e" + }, + "entity": { + "Function": { + "name": "test_timestamp_with_timezone_infinity", + "unaliased_name": "test_timestamp_with_timezone_infinity", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), pgrx :: spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 376, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_serialization", + "signature_hash": "bc4705746362ef11" + }, + "entity": { + "Function": { + "name": "test_timestamp_with_timezone_serialization", + "unaliased_name": "test_timestamp_with_timezone_serialization", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_serialization", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 352, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timestamptz", + "signature_hash": "3c80215887905e1" + }, + "entity": { + "Function": { + "name": "test_timestamptz", + "unaliased_name": "test_timestamptz", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timestamptz", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 328, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timetz_from_time_and_zone", + "signature_hash": "35e7ebf83791cdfb" + }, + "entity": { + "Function": { + "name": "test_timetz_from_time_and_zone", + "unaliased_name": "test_timetz_from_time_and_zone", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timetz_from_time_and_zone", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 136, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_cest", + "signature_hash": "3627bff2df500be3" + }, + "entity": { + "Function": { + "name": "test_timezone_offset_cest", + "unaliased_name": "test_timezone_offset_cest", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_cest", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 496, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_unknown", + "signature_hash": "c00584ca5f370a26" + }, + "entity": { + "Function": { + "name": "test_timezone_offset_unknown", + "unaliased_name": "test_timezone_offset_unknown", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_unknown", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 508, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_us_eastern", + "signature_hash": "b5f9d5b74c291317" + }, + "entity": { + "Function": { + "name": "test_timezone_offset_us_eastern", + "unaliased_name": "test_timezone_offset_us_eastern", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_us_eastern", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 501, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_to_julian_days", + "signature_hash": "406ea1893e65d793" + }, + "entity": { + "Function": { + "name": "test_to_julian_days", + "unaliased_name": "test_to_julian_days", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_to_julian_days", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 116, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_to_pg_epoch_days", + "signature_hash": "a02d64c6e41b5446" + }, + "entity": { + "Function": { + "name": "test_to_pg_epoch_days", + "unaliased_name": "test_to_pg_epoch_days", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_to_pg_epoch_days", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::tests::test_to_posix_time", + "signature_hash": "34a171eb8c790f87" + }, + "entity": { + "Function": { + "name": "test_to_posix_time", + "unaliased_name": "test_to_posix_time", + "module_path": "pgrx_tests::tests::datetime_tests::tests", + "full_path": "pgrx_tests::tests::datetime_tests::tests::test_to_posix_time", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 109, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_too_many_args", + "signature_hash": "1a96373c88f60715" + }, + "entity": { + "Function": { + "name": "test_too_many_args", + "unaliased_name": "test_too_many_args", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_too_many_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 106, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "signature_hash": "23e98041bb00a7d6" + }, + "entity": { + "Function": { + "name": "test_tuple_desc_clone", + "unaliased_name": "test_tuple_desc_clone", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "metadata": { + "arguments": [], + "retval": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn() -> core::result::Result<(), pgrx::spi::SpiError>" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Result < (), spi :: Error >", + "full_path": "core::result::Result<(), pgrx::spi::SpiError>", + "module_path": "core::result::Result<(), pgrx::spi", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "core::result::Result<(), pgrx::spi::SpiError>", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 874, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_two_tuple_bool", + "signature_hash": "c93e083e65dfcbe1" + }, + "entity": { + "Function": { + "name": "test_two_tuple_bool", + "unaliased_name": "test_two_tuple_bool", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_two_tuple_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 21, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::tests::test_type_in_different_schema", + "signature_hash": "ffddb18fa4b708e7" + }, + "entity": { + "Function": { + "name": "test_type_in_different_schema", + "unaliased_name": "test_type_in_different_schema", + "module_path": "pgrx_tests::tests::schema_tests::tests", + "full_path": "pgrx_tests::tests::schema_tests::tests::test_type_in_different_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 107, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn", + "signature_hash": "8f081e5a42138dba" + }, + "entity": { + "Function": { + "name": "test_using_support_fn", + "unaliased_name": "test_using_support_fn", + "module_path": "pgrx_tests::tests::pg_extern_tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 50, + "extern_attrs": [ + { + "Support": { + "FullPath": "local_support_fn" + } + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn_in_other_module", + "signature_hash": "4f4fd2388940b484" + }, + "entity": { + "Function": { + "name": "test_using_support_fn_in_other_module", + "unaliased_name": "test_using_support_fn_in_other_module", + "module_path": "pgrx_tests::tests::pg_extern_tests", + "full_path": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn_in_other_module", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_extern_tests.rs", + "line": 38, + "extern_attrs": [ + { + "Support": { + "FullPath": "support_fn_schema::test_support_fn" + } + } + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_bool", + "signature_hash": "8ecb1b76947081a0" + }, + "entity": { + "Function": { + "name": "test_vec_bool", + "unaliased_name": "test_vec_bool", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_bool", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 28, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_ints", + "signature_hash": "eca9f80201172570" + }, + "entity": { + "Function": { + "name": "test_vec_ints", + "unaliased_name": "test_vec_ints", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_ints", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 35, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::log_tests::tests::test_warn", + "signature_hash": "1d1f1c3f326f3581" + }, + "entity": { + "Function": { + "name": "test_warn", + "unaliased_name": "test_warn", + "module_path": "pgrx_tests::tests::log_tests::tests", + "full_path": "pgrx_tests::tests::log_tests::tests::test_warn", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/log_tests.rs", + "line": 27, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_try_tests::tests::test_we_dont_blow_out_errdata_stack_size", + "signature_hash": "c85e4c1151fd1e54" + }, + "entity": { + "Function": { + "name": "test_we_dont_blow_out_errdata_stack_size", + "unaliased_name": "test_we_dont_blow_out_errdata_stack_size", + "module_path": "pgrx_tests::tests::pg_try_tests::tests", + "full_path": "pgrx_tests::tests::pg_try_tests::tests::test_we_dont_blow_out_errdata_stack_size", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/pg_try_tests.rs", + "line": 58, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args", + "signature_hash": "5c964e084ffba33e" + }, + "entity": { + "Function": { + "name": "test_with_arg_and_two_defaults_no_args", + "unaliased_name": "test_with_arg_and_two_defaults_no_args", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 149, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_1_arg", + "signature_hash": "9ad2e9f99f6bdcb8" + }, + "entity": { + "Function": { + "name": "test_with_arg_and_two_defaults_no_args_1_arg", + "unaliased_name": "test_with_arg_and_two_defaults_no_args_1_arg", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_1_arg", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 155, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_2_args", + "signature_hash": "58d20a7b0689670d" + }, + "entity": { + "Function": { + "name": "test_with_arg_and_two_defaults_no_args_2_args", + "unaliased_name": "test_with_arg_and_two_defaults_no_args_2_args", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_2_args", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 161, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_default", + "signature_hash": "8c7436b6fe7bf57b" + }, + "entity": { + "Function": { + "name": "test_with_default", + "unaliased_name": "test_with_default", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 131, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_functional_default", + "signature_hash": "6e567abb29a39158" + }, + "entity": { + "Function": { + "name": "test_with_functional_default", + "unaliased_name": "test_with_functional_default", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_functional_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 177, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_null_default", + "signature_hash": "9e9cb3feb7e56491" + }, + "entity": { + "Function": { + "name": "test_with_null_default", + "unaliased_name": "test_with_null_default", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_null_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 168, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_ambiguous", + "signature_hash": "a37a62c79c3916d" + }, + "entity": { + "Function": { + "name": "test_with_only_default_ambiguous", + "unaliased_name": "test_with_only_default_ambiguous", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_ambiguous", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 113, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int4", + "signature_hash": "ae0de20967dce145" + }, + "entity": { + "Function": { + "name": "test_with_only_default_int4", + "unaliased_name": "test_with_only_default_int4", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int4", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 119, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int8", + "signature_hash": "eb92efa5bc0223e" + }, + "entity": { + "Function": { + "name": "test_with_only_default_int8", + "unaliased_name": "test_with_only_default_int8", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int8", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 125, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_two_defaults", + "signature_hash": "c2d269ce37978186" + }, + "entity": { + "Function": { + "name": "test_with_two_defaults", + "unaliased_name": "test_with_two_defaults", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_two_defaults", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 137, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::test_with_unspecified_default", + "signature_hash": "3ce68a1b3d548477" + }, + "entity": { + "Function": { + "name": "test_with_unspecified_default", + "unaliased_name": "test_with_unspecified_default", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::test_with_unspecified_default", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 186, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::heap_tuple::tests::test_wrong_type_assumed", + "signature_hash": "21655b13dd3cc5bf" + }, + "entity": { + "Function": { + "name": "test_wrong_type_assumed", + "unaliased_name": "test_wrong_type_assumed", + "module_path": "pgrx_tests::tests::heap_tuple::tests", + "full_path": "pgrx_tests::tests::heap_tuple::tests::test_wrong_type_assumed", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/heap_tuple.rs", + "line": 816, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::xact_callback_tests::tests::test_xact_callback", + "signature_hash": "672a844afa464b0f" + }, + "entity": { + "Function": { + "name": "test_xact_callback", + "unaliased_name": "test_xact_callback", + "module_path": "pgrx_tests::tests::xact_callback_tests::tests", + "full_path": "pgrx_tests::tests::xact_callback_tests::tests::test_xact_callback", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/xact_callback_tests.rs", + "line": 22, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32", + "signature_hash": "4575df9c812e31a7" + }, + "entity": { + "Function": { + "name": "test_zero_i32", + "unaliased_name": "test_zero_i32", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 42, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32_is_some_zero", + "signature_hash": "942599fdb9dac0c6" + }, + "entity": { + "Function": { + "name": "test_zero_i32_is_some_zero", + "unaliased_name": "test_zero_i32_is_some_zero", + "module_path": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "full_path": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32_is_some_zero", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/zero_datum_edge_cases.rs", + "line": 60, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "signature_hash": "ed3fbf020f04e8c2" + }, + "entity": { + "Function": { + "name": "testcasttype_in", + "unaliased_name": "testcasttype_in", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < TestCastType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 32, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "signature_hash": "ea4f8baf1b4e7776" + }, + "entity": { + "Function": { + "name": "testcasttype_out", + "unaliased_name": "testcasttype_out", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 32, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "signature_hash": "b0c2ecad322d423d" + }, + "entity": { + "Function": { + "name": "testcasttype_recv", + "unaliased_name": "testcasttype_recv", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 32, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "signature_hash": "863704ee041cd059" + }, + "entity": { + "Function": { + "name": "testcasttype_send", + "unaliased_name": "testcasttype_send", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 32, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "signature_hash": "718c9898703d7867" + }, + "entity": { + "Function": { + "name": "testcasttype_to_bool", + "unaliased_name": "testcasttype_to_bool", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType) -> bool" + }, + "fn_args": [ + { + "pattern": "_i", + "used_ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 36, + "extern_attrs": [ + "Immutable" + ], + "search_path": null, + "operator": null, + "cast": "Implicit", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "signature_hash": "e465fe9c8df5bf72" + }, + "entity": { + "Function": { + "name": "testcasttype_to_testcasttype", + "unaliased_name": "testcasttype_to_testcasttype", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + }, + { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType, i32, bool) -> pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType" + }, + "fn_args": [ + { + "pattern": "i", + "used_ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "_typmod", + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + } + }, + { + "pattern": "_is_explicit", + "used_ty": { + "ty_source": "bool", + "full_path": "bool", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "bool", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TestCastType", + "full_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "module_path": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "argument_sql": { + "Ok": { + "As": "TestCastType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestCastType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/pg_cast_tests.rs", + "line": 45, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": "Default", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "signature_hash": "43bbfe9b2dd0a8f4" + }, + "entity": { + "Function": { + "name": "testtype_in", + "unaliased_name": "testtype_in", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & '_ :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < TestType >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 27, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "signature_hash": "d3076026d4c924ec" + }, + "entity": { + "Function": { + "name": "testtype_out", + "unaliased_name": "testtype_out", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::TestType) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "TestType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 27, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "signature_hash": "c8601349139d3b28" + }, + "entity": { + "Function": { + "name": "testtype_recv", + "unaliased_name": "testtype_recv", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::schema_tests::test_schema::TestType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "TestType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 27, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "signature_hash": "53dd2d406d67a711" + }, + "entity": { + "Function": { + "name": "testtype_send", + "unaliased_name": "testtype_send", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::schema_tests::test_schema::TestType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "TestType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 27, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::time_literal_spi_roundtrip", + "signature_hash": "b7422df5bb749000" + }, + "entity": { + "Function": { + "name": "time_literal_spi_roundtrip", + "unaliased_name": "time_literal_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::time_literal_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::time_spi_roundtrip", + "signature_hash": "cbd5c58dccef260d" + }, + "entity": { + "Function": { + "name": "time_spi_roundtrip", + "unaliased_name": "time_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::time_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::timestamp_literal_spi_roundtrip", + "signature_hash": "7133656aae37ec31" + }, + "entity": { + "Function": { + "name": "timestamp_literal_spi_roundtrip", + "unaliased_name": "timestamp_literal_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::timestamp_literal_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::timestamp_spi_roundtrip", + "signature_hash": "8e92a6e75b55e8e9" + }, + "entity": { + "Function": { + "name": "timestamp_spi_roundtrip", + "unaliased_name": "timestamp_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::timestamp_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "signature_hash": "6aebb64f22c571da" + }, + "entity": { + "Function": { + "name": "timestamptz_to_i64", + "unaliased_name": "timestamptz_to_i64", + "module_path": "pgrx_tests::tests::datetime_tests", + "full_path": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "metadata": { + "arguments": [ + { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(i64) -> i64" + }, + "fn_args": [ + { + "pattern": "tstz", + "used_ty": { + "ty_source": "pg_sys :: TimestampTz", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "i64", + "full_path": "i64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i64", + "argument_sql": { + "Ok": { + "As": "bigint" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bigint" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/datetime_tests.rs", + "line": 66, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": "\nCREATE FUNCTION \"timestamptz_to_i64\"(\n\t\"tstz\" timestamptz\n) RETURNS bigint\nSTRICT\nLANGUAGE c /* Rust */\nAS 'MODULE_PATHNAME', 'timestamptz_to_i64_wrapper';\n\n" + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::timetz_literal_spi_roundtrip", + "signature_hash": "c20cab0c48364ae3" + }, + "entity": { + "Function": { + "name": "timetz_literal_spi_roundtrip", + "unaliased_name": "timetz_literal_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::timetz_literal_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::proptests::tests::timetz_spi_roundtrip", + "signature_hash": "ad9ec42e29943156" + }, + "entity": { + "Function": { + "name": "timetz_spi_roundtrip", + "unaliased_name": "timetz_spi_roundtrip", + "module_path": "pgrx_tests::tests::proptests::tests", + "full_path": "pgrx_tests::tests::proptests::tests::timetz_spi_roundtrip", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/proptests.rs", + "line": 102, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::schema_tests::type_in_diff_schema", + "signature_hash": "5241c3295d3c0e7e" + }, + "entity": { + "Function": { + "name": "type_in_diff_schema", + "unaliased_name": "type_in_diff_schema", + "module_path": "pgrx_tests::tests::schema_tests", + "full_path": "pgrx_tests::tests::schema_tests::type_in_diff_schema", + "metadata": { + "arguments": [], + "retval": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn() -> pgrx_tests::tests::schema_tests::test_schema::TestType" + }, + "fn_args": [], + "fn_return": { + "Type": { + "ty": { + "ty_source": "test_schema :: TestType", + "full_path": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "module_path": "pgrx_tests::tests::schema_tests::test_schema", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "argument_sql": { + "Ok": { + "As": "TestType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TestType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/schema_tests.rs", + "line": 84, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::type_ref_with_lifetime", + "signature_hash": "ec3f253fefd2fe63" + }, + "entity": { + "Function": { + "name": "type_ref_with_lifetime", + "unaliased_name": "type_ref_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::type_ref_with_lifetime", + "metadata": { + "arguments": [ + { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(&str)" + }, + "fn_args": [ + { + "pattern": "_value", + "used_ty": { + "ty_source": "& str", + "full_path": "&str", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "&str", + "argument_sql": { + "Ok": { + "As": "TEXT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "TEXT" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 23, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::lifetime_tests::type_with_lifetime", + "signature_hash": "36b4729ef14ae01" + }, + "entity": { + "Function": { + "name": "type_with_lifetime", + "unaliased_name": "type_with_lifetime", + "module_path": "pgrx_tests::tests::lifetime_tests", + "full_path": "pgrx_tests::tests::lifetime_tests::type_with_lifetime", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(core::option::Option)" + }, + "fn_args": [ + { + "pattern": "_value", + "used_ty": { + "ty_source": "Option < CustomType < '_ > >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "CustomType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "CustomType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/lifetime_tests.rs", + "line": 20, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::fn_call_tests::tests::unknown_function", + "signature_hash": "573c17f67ea36b58" + }, + "entity": { + "Function": { + "name": "unknown_function", + "unaliased_name": "unknown_function", + "module_path": "pgrx_tests::tests::fn_call_tests::tests", + "full_path": "pgrx_tests::tests::fn_call_tests::tests::unknown_function", + "metadata": { + "arguments": [], + "retval": { + "type_name": "()", + "argument_sql": { + "Err": { + "NotValidAsArgument": "()" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VOID" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn()" + }, + "fn_args": [], + "fn_return": "None", + "schema": null, + "file": "pgrx-tests/src/tests/fn_call_tests.rs", + "line": 200, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::array_tests::validate_cstring_array", + "signature_hash": "19738da5712f8917" + }, + "entity": { + "Function": { + "name": "validate_cstring_array", + "unaliased_name": "validate_cstring_array", + "module_path": "pgrx_tests::tests::array_tests", + "full_path": "pgrx_tests::tests::array_tests::validate_cstring_array", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring[]" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "core::result::Result>", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(pgrx::datum::array::Array<&core::ffi::c_str::CStr>) -> core::result::Result>" + }, + "fn_args": [ + { + "pattern": "a", + "used_ty": { + "ty_source": "Array < '_, & '_ core :: ffi :: CStr >", + "full_path": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>", + "module_path": "pgrx::datum::array::Array<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring[]" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring[]" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "std :: result :: Result < bool, Box < dyn std :: error :: Error > >", + "full_path": "core::result::Result>", + "module_path": "core::result::Result>", + "argument_sql": { + "Ok": { + "As": "bool" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bool" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/array_tests.rs", + "line": 165, + "extern_attrs": [], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>", + "signature_hash": "39954a4fbd2d9c88" + }, + "entity": { + "BuiltinType": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>" + } + }, + { + "id": { + "entity_type": "BuiltinType", + "rust_identifier": "core::result::Result>", + "signature_hash": "c984bea7e375a338" + }, + "entity": { + "BuiltinType": "core::result::Result>" + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "signature_hash": "680b8bf7a71716f4" + }, + "entity": { + "Function": { + "name": "varlenaenumtype_in", + "unaliased_name": "varlenaenumtype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option>" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < :: pgrx :: datum :: PgVarlena < VarlenaEnumType > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 42, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "signature_hash": "7d855b2aa189b93f" + }, + "entity": { + "Function": { + "name": "varlenaenumtype_out", + "unaliased_name": "varlenaenumtype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::varlena::PgVarlena) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < VarlenaEnumType >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 42, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "signature_hash": "e4e2b55f32efb84e" + }, + "entity": { + "Function": { + "name": "varlenaenumtype_recv", + "unaliased_name": "varlenaenumtype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::VarlenaEnumType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "VarlenaEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 42, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "signature_hash": "7d57445893e95081" + }, + "entity": { + "Function": { + "name": "varlenaenumtype_send", + "unaliased_name": "varlenaenumtype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::VarlenaEnumType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "VarlenaEnumType", + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "argument_sql": { + "Ok": { + "As": "VarlenaEnumType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaEnumType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 42, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "signature_hash": "40014d9e6c324cb8" + }, + "entity": { + "Function": { + "name": "varlenatype_in", + "unaliased_name": "varlenatype_in", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "metadata": { + "arguments": [ + { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": true + }, + "path": "fn(core::option::Option<&core::ffi::c_str::CStr>) -> core::option::Option>" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "Option < & :: core :: ffi :: CStr >", + "full_path": "core::option::Option<&core::ffi::c_str::CStr>", + "module_path": "core::option::Option<&core::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option<&core::ffi::c_str::CStr>", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Option < :: pgrx :: datum :: PgVarlena < VarlenaType > >", + "full_path": "core::option::Option>", + "module_path": "core::option::Option>", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": true + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 16, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "signature_hash": "811e555a398dcb55" + }, + "entity": { + "Function": { + "name": "varlenatype_out", + "unaliased_name": "varlenatype_out", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::varlena::PgVarlena) -> alloc::ffi::c_str::CString" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < VarlenaType >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": ":: pgrx :: ffi :: CString", + "full_path": "alloc::ffi::c_str::CString", + "module_path": "alloc::ffi::c_str", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::ffi::c_str::CString", + "argument_sql": { + "Ok": { + "As": "cstring" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "cstring" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 16, + "extern_attrs": [ + "Immutable", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "signature_hash": "19c861e003a2f003" + }, + "entity": { + "Function": { + "name": "varlenatype_recv", + "unaliased_name": "varlenatype_recv", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "metadata": { + "arguments": [ + { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + ], + "retval": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx::datum::internal::Internal) -> pgrx_tests::tests::postgres_type_tests::VarlenaType" + }, + "fn_args": [ + { + "pattern": "internal", + "used_ty": { + "ty_source": ":: pgrx :: datum :: Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "VarlenaType", + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 16, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Function", + "rust_identifier": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "signature_hash": "f121f1300d39f2d0" + }, + "entity": { + "Function": { + "name": "varlenatype_send", + "unaliased_name": "varlenatype_send", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "full_path": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "metadata": { + "arguments": [ + { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + } + ], + "retval": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + }, + "path": "fn(pgrx_tests::tests::postgres_type_tests::VarlenaType) -> alloc::vec::Vec" + }, + "fn_args": [ + { + "pattern": "input", + "used_ty": { + "ty_source": "VarlenaType", + "full_path": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "module_path": "pgrx_tests::tests::postgres_type_tests", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "argument_sql": { + "Ok": { + "As": "VarlenaType" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "VarlenaType" + } + } + }, + "variadic": false, + "optional": false + } + } + } + ], + "fn_return": { + "Type": { + "ty": { + "ty_source": "Vec < u8 >", + "full_path": "alloc::vec::Vec", + "module_path": "alloc::vec", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "alloc::vec::Vec", + "argument_sql": { + "Ok": { + "As": "bytea" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "bytea" + } + } + }, + "variadic": false, + "optional": false + } + } + } + }, + "schema": null, + "file": "pgrx-tests/src/tests/postgres_type_tests.rs", + "line": 16, + "extern_attrs": [ + "Immutable", + "Strict", + "ParallelSafe" + ], + "search_path": null, + "operator": null, + "cast": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Ord", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "signature_hash": "a0eb2b614046db18" + }, + "entity": { + "Ord": { + "name": "PgrxModuleQualificationTest", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 45, + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Hash", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "signature_hash": "42aa15aa90dab545" + }, + "entity": { + "Hash": { + "name": "PgrxModuleQualificationTest", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 47, + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "signature_hash": "43e9fcdd516f0878" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 179, + "name": "demo_sum_state", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": null + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "Option < demo_schema :: DemoState >", + "full_path": "core::option::Option", + "module_path": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "DemoState" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "DemoState" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "state" + }, + "sfunc": "demo_custom_state_demo_custom_state_state", + "finalfunc": "demo_custom_state_demo_custom_state_finalize", + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoOps", + "signature_hash": "561d97780a2e5a9b" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 30, + "name": "demo_sum", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": null + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "demo_ops_demo_sum_name_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": "demo_ops_demo_sum_name_combine", + "serialfunc": null, + "deserialfunc": null, + "initcond": "0", + "msfunc": "demo_ops_demo_sum_name_moving_state", + "minvfunc": "demo_ops_demo_sum_name_moving_state_inverse", + "mstype": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": "0", + "sortop": null, + "hypothetical": false, + "parallel": "Unsafe", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoOps", + "signature_hash": "28d0bb050fe6f562" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::DemoOps", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 76, + "name": "demo_sub", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": null + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "demo_ops_demo_sub_name_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": "demo_ops_demo_sub_name_combine", + "serialfunc": null, + "deserialfunc": null, + "initcond": "0", + "msfunc": "demo_ops_demo_sub_name_moving_state", + "minvfunc": "demo_ops_demo_sub_name_moving_state_inverse", + "mstype": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": "0", + "sortop": null, + "hypothetical": false, + "parallel": "Unsafe", + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "signature_hash": "bce18072d255c9b" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 126, + "name": "DemoPercentileDisc", + "ordered_set": true, + "args": [ + { + "used_ty": { + "ty_source": "i32", + "full_path": "i32", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "i32", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "input" + } + ], + "direct_args": [ + { + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "percentile" + } + ], + "stype": { + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "state" + }, + "sfunc": "demo_percentile_disc_demo_percentile_disc_state", + "finalfunc": "demo_percentile_disc_demo_percentile_disc_finalize", + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "signature_hash": "ba316dc7d600c614" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 248, + "name": "FirstAnyArray", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "pgrx :: AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "value" + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "pgrx :: AnyArray", + "full_path": "pgrx::datum::anyarray::AnyArray", + "module_path": "pgrx::datum::anyarray", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyarray::AnyArray", + "argument_sql": { + "Ok": { + "As": "anyarray" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyarray" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "first_any_array_first_any_array_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "signature_hash": "56f2b80673ac5045" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 266, + "name": "FirstAnyElement", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "pgrx :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "value" + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "pgrx :: AnyElement", + "full_path": "pgrx::datum::anyelement::AnyElement", + "module_path": "pgrx::datum::anyelement", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::anyelement::AnyElement", + "argument_sql": { + "Ok": { + "As": "anyelement" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "anyelement" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "first_any_element_first_any_element_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::FirstJson", + "signature_hash": "ac8f429c89d0f997" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::FirstJson", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 212, + "name": "FirstJson", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "value" + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "pgrx :: Json", + "full_path": "pgrx::datum::json::Json", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::Json", + "argument_sql": { + "Ok": { + "As": "json" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "json" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "first_json_first_json_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "signature_hash": "1dabb0cd9ac536f9" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "module_path": "pgrx_tests::tests::aggregate_tests", + "file": "pgrx-tests/src/tests/aggregate_tests.rs", + "line": 230, + "name": "FirstJsonB", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "pgrx :: JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "value" + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": "pgrx :: JsonB", + "full_path": "pgrx::datum::json::JsonB", + "module_path": "pgrx::datum::json", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::json::JsonB", + "argument_sql": { + "Ok": { + "As": "jsonb" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "jsonb" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "first_json_b_first_json_b_state", + "finalfunc": null, + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::issue1134::Foo", + "signature_hash": "fb3469812b78d60d" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::issue1134::Foo", + "module_path": "pgrx_tests::tests::issue1134", + "file": "pgrx-tests/src/tests/issue1134.rs", + "line": 16, + "name": "Foo", + "ordered_set": true, + "args": [ + { + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": null + } + ], + "direct_args": [ + { + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "a" + }, + { + "used_ty": { + "ty_source": "f64", + "full_path": "f64", + "module_path": "", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "f64", + "argument_sql": { + "Ok": { + "As": "double precision" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "double precision" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "b" + } + ], + "stype": { + "used_ty": { + "ty_source": "Internal", + "full_path": "pgrx::datum::internal::Internal", + "module_path": "pgrx::datum::internal", + "composite_type": null, + "variadic": false, + "default": null, + "optional": false, + "metadata": { + "type_name": "pgrx::datum::internal::Internal", + "argument_sql": { + "Ok": { + "As": "internal" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "internal" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "state" + }, + "sfunc": "foo_foo_state", + "finalfunc": "foo_foo_finalize", + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": null, + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Aggregate", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "signature_hash": "b66d92b6f60c22bf" + }, + "entity": { + "Aggregate": { + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 142, + "name": "PgrxModuleQualificationTestAgg", + "ordered_set": false, + "args": [ + { + "used_ty": { + "ty_source": "Option < i32 >", + "full_path": "core::option::Option", + "module_path": "core::option", + "composite_type": null, + "variadic": false, + "default": null, + "optional": true, + "metadata": { + "type_name": "core::option::Option", + "argument_sql": { + "Ok": { + "As": "INT" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "INT" + } + } + }, + "variadic": false, + "optional": true + } + }, + "name": "value" + } + ], + "direct_args": null, + "stype": { + "used_ty": { + "ty_source": ":: pgrx :: datum :: PgVarlena < PgrxModuleQualificationTest >", + "full_path": "pgrx::datum::varlena::PgVarlena", + "module_path": "pgrx::datum::varlena::PgVarlena", + "argument_sql": { + "Ok": { + "As": "PgrxModuleQualificationTest" + } + }, + "return_sql": { + "Ok": { + "One": { + "As": "PgrxModuleQualificationTest" + } + } + }, + "variadic": false, + "optional": false + } + }, + "name": "state" + }, + "sfunc": "pgrx_module_qualification_test_pgrx_mqt_name_state", + "finalfunc": "pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "finalfunc_modify": null, + "combinefunc": null, + "serialfunc": null, + "deserialfunc": null, + "initcond": "{\"v\": 0}", + "msfunc": null, + "minvfunc": null, + "mstype": null, + "mfinalfunc": null, + "mfinalfunc_modify": null, + "minitcond": null, + "sortop": null, + "hypothetical": false, + "parallel": null, + "to_sql_config": { + "enabled": true, + "content": null + } + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::add_field_boopers", + "signature_hash": "c9ffaa3f0b0534cf" + }, + "entity": { + "Trigger": { + "function_name": "add_field_boopers", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 144, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::add_field_boopers" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::dont_delete_trigger", + "signature_hash": "7584daf5d436dec0" + }, + "entity": { + "Trigger": { + "function_name": "dont_delete_trigger", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 613, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::dont_delete_trigger" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::field_species_fox_to_bear", + "signature_hash": "91ed7327fc50a66" + }, + "entity": { + "Trigger": { + "function_name": "field_species_fox_to_bear", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 98, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::field_species_fox_to_bear" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_trigger", + "signature_hash": "14c19b971e6d0ddf" + }, + "entity": { + "Trigger": { + "function_name": "foo_trigger", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/pgrx_module_qualification.rs", + "line": 127, + "module_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests", + "full_path": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_trigger" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::has_sql_option_set", + "signature_hash": "e72f52e2e6fa57eb" + }, + "entity": { + "Trigger": { + "function_name": "has_sql_option_set", + "to_sql_config": { + "enabled": true, + "content": "\n CREATE FUNCTION tests.\"has_sql_option_set_and_respects_it\"()\n RETURNS TRIGGER\n LANGUAGE c\n AS 'MODULE_PATHNAME', 'has_sql_option_set_wrapper';\n \n" + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 492, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::has_sql_option_set" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata", + "signature_hash": "ab6fc2b24b9b6783" + }, + "entity": { + "Trigger": { + "function_name": "inserts_trigger_metadata", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 248, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata_safe", + "signature_hash": "502aeb11e667a70c" + }, + "entity": { + "Trigger": { + "function_name": "inserts_trigger_metadata_safe", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 378, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata_safe" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::intercept_bears", + "signature_hash": "344cc932b8e3b517" + }, + "entity": { + "Trigger": { + "function_name": "intercept_bears", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 190, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::intercept_bears" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::noop_postgres", + "signature_hash": "24dc4e11a438e058" + }, + "entity": { + "Trigger": { + "function_name": "noop_postgres", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 537, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::noop_postgres" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::noop_rust", + "signature_hash": "a705f67e5a942321" + }, + "entity": { + "Trigger": { + "function_name": "noop_rust", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 575, + "module_path": "pgrx_tests::tests::trigger_tests::tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::noop_rust" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_argument", + "signature_hash": "2cca329194676036" + }, + "entity": { + "Trigger": { + "function_name": "signature_aliased_argument", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 61, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_argument" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_both", + "signature_hash": "337f51889a2c5b22" + }, + "entity": { + "Trigger": { + "function_name": "signature_aliased_both", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 76, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_both" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_return", + "signature_hash": "3eee6f68641fb987" + }, + "entity": { + "Trigger": { + "function_name": "signature_aliased_return", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 71, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_return" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_postgres", + "signature_hash": "6bd4edfaa54d74dd" + }, + "entity": { + "Trigger": { + "function_name": "signature_alloc_by_postgres", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 44, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_postgres" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_rust", + "signature_hash": "9ef0a154e12ef0c2" + }, + "entity": { + "Trigger": { + "function_name": "signature_alloc_by_rust", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 51, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_rust" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_explicit_lifetimes", + "signature_hash": "6912cec81ee6bb21" + }, + "entity": { + "Trigger": { + "function_name": "signature_explicit_lifetimes", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 37, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_explicit_lifetimes" + } + } + }, + { + "id": { + "entity_type": "Trigger", + "rust_identifier": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_standard", + "signature_hash": "e931f46e778f016" + }, + "entity": { + "Trigger": { + "function_name": "signature_standard", + "to_sql_config": { + "enabled": true, + "content": null + }, + "file": "pgrx-tests/src/tests/trigger_tests.rs", + "line": 30, + "module_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "full_path": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_standard" + } + } + } + ], + "dependency_edges": [ + { + "from": "root", + "to": "create_composites", + "requires": "By" + }, + { + "from": "root", + "to": "issue1293", + "requires": "By" + }, + { + "from": "create_composites", + "to": "issue1293", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_module_qualification_test", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_module_qualification_test", + "requires": "By" + }, + { + "from": "root", + "to": "test_funcs", + "requires": "By" + }, + { + "from": "create_composites", + "to": "test_funcs", + "requires": "By" + }, + { + "from": "root", + "to": "create_complex_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "create_complex_type", + "requires": "By" + }, + { + "from": "root", + "to": "create_complex_shell_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "create_complex_shell_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyarray_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyelement_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anynumeric_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::attributes_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::cfg_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::composite_type_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::enum_type_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::from_into_datum_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::geo_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::inet_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::internal_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::list_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::name_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::oid_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_guard_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_operator_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgbox_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::rel_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::shmem_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::struct_type_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::variadic_tests::test", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::variadic_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::xact_callback_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::xid64_tests::tests", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::enum_type_tests::Foo", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::enum_type_tests::Foo", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::CustomType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::CustomType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::JsonType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::JsonType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::NullError", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::NullError", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::RandomData", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::RandomData", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::ResultTestsA", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::ResultTestsA", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_date_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_date_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::accept_range_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::accept_range_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::rel_tests::accept_relation", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::rel_tests::accept_relation", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::accept_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::accept_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_custom_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_custom_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_percentile_disc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_percentile_disc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sub", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sub", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::arr_into_vec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::arr_into_vec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_func_is_immutable", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_func_is_immutable", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_is_implicit", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_is_implicit", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_add_field", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_add_field", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_field_update", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_field_update", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_has_sql_option_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_has_sql_option_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_postgres", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_postgres", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_rust", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_rust", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::before_update_skip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::before_update_skip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::blank_function", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::blank_function", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::complex::complex_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::complex::complex_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::complex::complex_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::complex::complex_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::count_nulls", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::count_nulls", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::count_true", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::count_true", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::crash", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::crash", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::composite_type_tests::create_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::composite_type_tests::create_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::custom_handwritten_to_sql_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::custom_handwritten_to_sql_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_extern", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_extern", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::customtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::customtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::customtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::customtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::date_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::date_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::date_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::date_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demoops_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demoops_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demoops_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demoops_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demoops_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demoops_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::display_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::display_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::do_panic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::do_panic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::elided_extern_is_elided", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::elided_extern_is_elided", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::elided_type_is_elided", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::elided_type_is_elided", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::err", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::err", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::example_composite_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::example_composite_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_guard_tests::extern_func", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_guard_tests::extern_func", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::fdw_handler_return", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::fdw_handler_return", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::fn_raises_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::fn_raises_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_composite", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_composite", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_default_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_default_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_option_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_option_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_return_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_return_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_elided_from_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_elided_from_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_generated_with_custom_sql", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_generated_with_custom_sql", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_in_diff_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_in_diff_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::func_in_diff_schema2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::func_in_diff_schema2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::cfg_tests::func_test_cfg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::cfg_tests::func_test_cfg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::generate_lots_of_dogs", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::generate_lots_of_dogs", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::get_arr_ndim", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::get_arr_ndim", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::get_arr_nelems", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::get_arr_nelems", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_with", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_with", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::internal_tests::tests::internal_insert", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::internal_tests::tests::internal_insert", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::invalid_identifier", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::invalid_identifier", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_definer", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_definer", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_immutable", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_immutable", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_invoker", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_invoker", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::iterate_array_with_deny_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::iterate_array_with_deny_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::json_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::json_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::jsonb_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::jsonb_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::list_tests::tests::list_length_10", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::list_tests::tests::list_length_10", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::list_tests::tests::list_length_1000", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::list_tests::tests::list_length_1000", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::list_tests::tests::list_length_drained", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::list_tests::tests::list_length_drained", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::nop_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::nop_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::nop_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::nop_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::nop_timestamp", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::nop_timestamp", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::nop_timetz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::nop_timetz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::null_string_is_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::null_string_is_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::one_col", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::one_col", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::one_col_option", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::one_col_option", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::one_col_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::one_col_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::one_col_result_option", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::one_col_result_option", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::optional_array_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::optional_array_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::optional_array_with_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::optional_array_with_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::panics", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::panics", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::parent", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::parent", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::passes_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::passes_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc0", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc0", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_date_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_date_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_num_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_num_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::name_tests::func_to_rename", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::name_tests::func_to_rename", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::name_tests::tests::renamed_func", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::name_tests::tests::renamed_func", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::result_table_1", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::result_table_1", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::result_table_2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::result_table_2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::result_table_3", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::result_table_3", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::result_table_4_err", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::result_table_4_err", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::result_table_5_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::result_table_5_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::result_tests_a_func", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::result_tests_a_func", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::resulttestsa_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::resulttestsa_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::resulttestsa_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::resulttestsa_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::resulttestsa_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::resulttestsa_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::return_3pm_mountain_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::return_3pm_mountain_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::return_empty_result_setof_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::return_empty_result_setof_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::return_empty_setof_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::return_empty_setof_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_error_report", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_error_report", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::return_setof_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::return_setof_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_some_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_some_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::return_table_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::return_table_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single_bare", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single_bare", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::return_text_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::return_text_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::return_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::return_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::return_zero_length_vec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::return_zero_length_vec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::returns_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::returns_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::returns_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::returns_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::returns_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::returns_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::returns_option_ref_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::returns_option_ref_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::returns_ref_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::returns_ref_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::returns_some", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::returns_some", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::returns_void", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::returns_void", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::same_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::same_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::sum_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::sum_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::sum_array_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::sum_array_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::switch_to_should_switch_back_on_panic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::switch_to_should_switch_back_on_panic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_char", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_char", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_option", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_option", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::takes_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::takes_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_infinity", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_infinity", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_large_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_large_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_neg_infinity", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_neg_infinity", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_now", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_now", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_large_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_large_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_tomorrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_tomorrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_yesterday", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_yesterday", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_neg_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_neg_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_neg_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_neg_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::rel_tests::tests::test_accept_relation", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::rel_tests::tests::test_accept_relation", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_now", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_now", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_random", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_random", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_tomorrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_tomorrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_yesterday", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_yesterday", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_not_utc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_not_utc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_offset_round_trip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_offset_round_trip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::tests::test_accept_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::tests::test_accept_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_add_two_numbers", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_add_two_numbers", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_anyele_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_anyele_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_data_ptr", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_data_ptr", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_to_vec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_to_vec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::composite_type_tests::tests::test_array_of_composite_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::composite_type_tests::tests::test_array_of_composite_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_assign_hook", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_assign_hook", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_background_worker_transaction_return", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_background_worker_transaction_return", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_bad_conversions", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_bad_conversions", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::shmem_tests::tests::test_behaves_normally_when_elog_while_holding_lock", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::shmem_tests::tests::test_behaves_normally_when_elog_while_holding_lock", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_bool_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_bool_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_value", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_value", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_value", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_value", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_check_for_interrupts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_check_for_interrupts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_check_hook_fail", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_check_hook_fail", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_columns", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_columns", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_compatibility", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_compatibility", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_composite_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_composite_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_connect_return_anything", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_connect_return_anything", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_convert_time_with_time_zone_now", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_convert_time_with_time_zone_now", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::xid64_tests::tests::test_convert_xid_to_u64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::xid64_tests::tests::test_convert_xid_to_u64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_operator_tests::tests::test_correct_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_operator_tests::tests::test_correct_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_count_nulls", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_count_nulls", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_count_true", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_count_true", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_create_or_replace", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_create_or_replace", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop_when_set_current_twice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop_when_set_current_twice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_failure", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_failure", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_not_found", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_not_found", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_date_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_date_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_debug1", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_debug1", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_debug2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_debug2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_debug3", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_debug3", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_debug4", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_debug4", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_debug5", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_debug5", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument_specified", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument_specified", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::inet_tests::tests::test_deserialize_inet", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::inet_tests::tests::test_deserialize_inet", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_deserialize_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_deserialize_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::tests::test_display_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::tests::test_display_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_and_ignore_and_finally", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_and_ignore_and_finally", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_ignore", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_ignore", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_rethrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_rethrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_no_catch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_no_catch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_conversion", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_conversion", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_err", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_err", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked_termination_handle", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked_termination_handle", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_worker_allocation_failure", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_worker_allocation_failure", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_empty_anynumeric_range", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_empty_anynumeric_range", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_enum_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_enum_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_ereport", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_ereport", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool_is_some_false", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool_is_some_false", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_float_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_float_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::enum_type_tests::tests::test_foo_enum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::enum_type_tests::tests::test_foo_enum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_ignore_attribute", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_ignore_attribute", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_should_panic_attribute", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_should_panic_attribute", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_func_with_collation", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_func_with_collation", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::variadic_tests::tests::test_func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::variadic_tests::tests::test_func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_generate_series", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_generate_series", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_data_ptr_nth_elem", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_data_ptr_nth_elem", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_strict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_strict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_variadic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_variadic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_check_hook", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_check_hook", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_flags", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_flags", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_immutable", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_immutable", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_incompatible_datum_returns_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_incompatible_datum_returns_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_incompatible_return_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_incompatible_return_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_info", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_info", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_eq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_eq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_ne", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_ne", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_int_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_int_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_mismatched_signs", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_mismatched_signs", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_seconds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_seconds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::tests::test_json", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::tests::test_json", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop_with_panic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop_with_panic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_limits", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_limits", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_drop", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_drop", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_unwind", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_unwind", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_log", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_log", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_mb_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_mb_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_field", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_field", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_number", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_number", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_my_int4eq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_my_int4eq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_nan_ordering", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_nan_ordering", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_negative_default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_negative_default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_negative_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_negative_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_new_composite_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_new_composite_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_notice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_notice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_some", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_some", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_error_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_error_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_strict_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_strict_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_one_col_table", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_one_col_table", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_option", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_option", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument_specified", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument_specified", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array_with_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array_with_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_ordering", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_ordering", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_panic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_panic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_panic_via_spi", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_panic_via_spi", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_panics", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_panics", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::tests::test_parse_uuid_v4", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::tests::test_parse_uuid_v4", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_assignment_type_cast", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_assignment_type_cast", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_explicit_type_cast", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_explicit_type_cast", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_implicit_type_cast", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_implicit_type_cast", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_no_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_no_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_with_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_with_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error_no_catch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error_no_catch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_ignore", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_ignore", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_rethrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_rethrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error_report", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error_report", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch_rethrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch_rethrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_ignore_panic", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_ignore_panic", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_no_error_with_catch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_no_error_with_catch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_throw_different_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_throw_different_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement_argument_mismatch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement_argument_mismatch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_identifier", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_identifier", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_literal", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_literal", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_qualified_identifier", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_qualified_identifier", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_empty", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_empty", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_full", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_full", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_val", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_val", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_val_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_val_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_empty", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_empty", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_full", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_full", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_val", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_val", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_val_inf", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_val_inf", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_bounds", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_bounds", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_values", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_values", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_1", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_1", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_3", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_3", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_4_err", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_4_err", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_5_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_5_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_f64_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_f64_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_u64_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_u64_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_an_i32_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_an_i32_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes_slice", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes_slice", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_setof_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_setof_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_none_optional_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_none_optional_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_setof_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_setof_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_error", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_error", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_optional_result", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_optional_result", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_table_iterator", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_table_iterator", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_return_text_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_return_text_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::tests::test_return_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::uuid_tests::tests::test_return_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_bytes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_bytes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_subvec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_subvec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_return_zero_length_vec", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_return_zero_length_vec", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_none", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_none", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_some", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_some", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_tuple", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_tuple", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_void", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_void", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_same_name", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_same_name", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_definer", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_definer", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_invoker", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_invoker", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::inet_tests::tests::test_serialize_inet", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::inet_tests::tests::test_serialize_inet", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_show_hook", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_show_hook", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run_with_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run_with_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_zero_rows", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_zero_rows", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_sql_int4eq", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_sql_int4eq", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_setof_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_setof_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_table_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_table_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_strict", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_strict", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc_null_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc_null_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::inet_tests::tests::test_take_and_return_inet", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::inet_tests::tests::test_take_and_return_inet", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_char", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_char", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i16", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i16", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_non_null_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_non_null_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_null_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_null_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_str", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_str", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_with_timezone_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_with_timezone_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_serialization", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_serialization", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamptz", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamptz", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timetz_from_time_and_zone", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timetz_from_time_and_zone", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_cest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_cest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_unknown", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_unknown", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_us_eastern", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_us_eastern", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_julian_days", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_julian_days", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_pg_epoch_days", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_pg_epoch_days", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_posix_time", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_posix_time", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_too_many_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_too_many_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_two_tuple_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_two_tuple_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests::test_type_in_different_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::tests::test_type_in_different_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn_in_other_module", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn_in_other_module", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_ints", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_ints", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests::test_warn", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::log_tests::tests::test_warn", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_we_dont_blow_out_errdata_stack_size", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_we_dont_blow_out_errdata_stack_size", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_1_arg", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_1_arg", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_2_args", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_2_args", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_functional_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_functional_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_null_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_null_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_ambiguous", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_ambiguous", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int4", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int4", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int8", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int8", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_two_defaults", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_two_defaults", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_unspecified_default", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_unspecified_default", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests::test_wrong_type_assumed", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::heap_tuple::tests::test_wrong_type_assumed", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::xact_callback_tests::tests::test_xact_callback", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::xact_callback_tests::tests::test_xact_callback", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32_is_some_zero", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32_is_some_zero", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::time_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::time_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::time_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::time_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::timestamp_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::timestamp_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::timestamp_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::timestamp_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::timetz_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::timetz_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests::timetz_spi_roundtrip", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::proptests::tests::timetz_spi_roundtrip", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::type_in_diff_schema", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::schema_tests::type_in_diff_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::type_ref_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::type_ref_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::lifetime_tests::type_with_lifetime", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::lifetime_tests::type_with_lifetime", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests::unknown_function", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::fn_call_tests::tests::unknown_function", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::validate_cstring_array", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::array_tests::validate_cstring_array", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::FirstJson", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::FirstJson", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::add_field_boopers", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::add_field_boopers", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete_trigger", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete_trigger", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::field_species_fox_to_bear", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::field_species_fox_to_bear", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_trigger", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_trigger", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::has_sql_option_set", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::has_sql_option_set", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata_safe", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata_safe", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::intercept_bears", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::intercept_bears", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_postgres", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_postgres", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_rust", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_rust", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_argument", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_argument", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_both", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_both", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_return", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_return", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_postgres", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_postgres", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_rust", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_rust", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_explicit_lifetimes", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_explicit_lifetimes", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_standard", + "requires": "By" + }, + { + "from": "create_composites", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_standard", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fn_call_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::rel_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::fcinfo_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::roundtrip_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::enum_type_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::name_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::xact_callback_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::default_arg_value_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::spi_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::struct_type_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::geo_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::proptests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::uuid_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::composite_type_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::srf_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::schema_tests::test_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anynumeric_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::guc_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::from_into_datum_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::internal_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::shmem_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::memcxt_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bgworker_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyarray_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::log_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::heap_tuple::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::result_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::array_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::inet_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::datetime_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::bytea_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::variadic_tests::test", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_try_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::json_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::anyelement_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pgbox_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::borrow_datum::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::attributes_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::aggregate_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::postgres_type_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::oid_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::range_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::xid64_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::numeric_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_operator_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::list_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::cfg_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::pg_guard_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::trigger_tests::tests", + "requires": "By" + }, + { + "from": "root", + "to": "pgrx_tests::tests::variadic_tests::tests", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "test_funcs", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "test_funcs", + "requires": "By" + }, + { + "from": "create_complex_shell_type", + "to": "create_complex_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::complex::complex_in", + "to": "create_complex_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::complex::complex_out", + "to": "create_complex_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::anyarray_tests::tests", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_iter_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_oid", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_iter_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_limits", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_convert_time_with_time_zone_now", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_box", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "to": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::array_tests::ArrayTestEnum", + "to": "pgrx_tests::tests::array_tests::enum_array_roundtrip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::cfg_tests::tests", + "to": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::cfg_tests::tests::test_cfg_exists", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "requires": "ByArg" + }, + { + "from": "& '_ str", + "to": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "requires": "ByReturn" + }, + { + "from": "Option < & '_ str >", + "to": "pgrx_tests::tests::lifetime_tests::returns_tuple_with_lifetime", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_columns", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_columns", + "requires": "ByReturn" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_return_null", + "requires": "ByReturn" + }, + { + "from": "pgrx::rel::PgRelation", + "to": "pgrx_tests::tests::rel_tests::accept_relation", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_my_int4eq", + "requires": "By" + }, + { + "from": "alloc::vec::Vec<&str>", + "to": "pgrx_tests::tests::array_tests::return_text_array", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "requires": "By" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "requires": "ByArg" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fn_call_tests::tests::arg_might_be_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "requires": "By" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_subvec", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_result", + "requires": "By" + }, + { + "from": "core::result::Result", + "to": "pgrx_tests::tests::result_tests::tests::return_result", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonType", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_recv", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "By" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_oid", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "requires": "ByReturn" + }, + { + "from": "& '_ str", + "to": "pgrx_tests::tests::srf_tests::return_empty_iterator", + "requires": "ByReturn" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_no_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::issue1134::foo_foo_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgbox_tests::tests", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc0", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_large_date", + "requires": "By" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::proptests::nop_date", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::proptests::nop_date", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_ordering", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::oid_tests::tests", + "to": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::oid_tests::tests::oid_roundtrip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::enum_type_tests::tests", + "to": "pgrx_tests::tests::enum_type_tests::tests::test_foo_enum", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ne", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_bounds", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_int_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bgworker_tests::tests", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_background_worker_transaction_return", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "to": "pgrx_tests::tests::schema_tests::type_in_diff_schema", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_values", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_data_ptr_nth_elem", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::struct_type_tests::tests", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_2", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_i32", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_i32", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "ByArg" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_1", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_date", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_date", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_an_i32_numeric", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_7", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::lifetime_tests::customtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::lifetime_tests::CustomType", + "to": "pgrx_tests::tests::lifetime_tests::customtype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_random", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_option", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "By" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_ts", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_functional_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_random", + "requires": "By" + }, + { + "from": "pgrx::datum::array::VariadicArray>", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_strict_variadic", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32_deny_null", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::return_empty_setof_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::ResultTestsA", + "to": "pgrx_tests::tests::result_tests::resulttestsa_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::result_tests::resulttestsa_out", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "ByReturn" + }, + { + "from": "& '_ str", + "to": "pgrx_tests::tests::srf_tests::split_table_with_borrow", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_float_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_mytype", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_complex", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i32", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_char", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::example_generate_series", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::invalid_identifier", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_json_enum_type", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_notice", + "requires": "By" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_composite", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_i64", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_extern_tests::tests::overridden_sql_with_fn_name", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_out", + "requires": "ByReturn" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::srf_tests::return_empty_result_setof_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_display_get_arr_nullbitmap", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_val", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_zero_rows", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_now", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_sql_int4eq", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_variadic", + "requires": "By" + }, + { + "from": "f32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "requires": "ByArg" + }, + { + "from": "f32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::inet_tests::tests", + "to": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "requires": "By" + }, + { + "from": "pgrx::datum::inet::Inet", + "to": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::inet::Inet", + "to": "pgrx_tests::tests::inet_tests::tests::take_and_return_inet", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32_is_some_zero", + "requires": "By" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::uuid_tests::display_uuid", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::uuid_tests::display_uuid", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::fcinfo_tests::takes_str", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::fcinfo_tests::takes_str", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::oid_tests::tests", + "to": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::oid_tests::tests::test_completely_unreasonable_but_still_valid_oid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::uuid_tests::tests", + "to": "pgrx_tests::tests::uuid_tests::tests::test_display_uuid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_iterator", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_log", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_anynumeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_anynumeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::add_two_numbers", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run_with_args", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_uuid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::tests", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_is_implicit", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_no_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_1", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::date_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_1", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_us_eastern", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_default", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_values", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::default_arg_value_tests::tests", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument_specified", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_definer", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "requires": "By" + }, + { + "from": "&bool", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::geo_tests::tests", + "to": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::geo_tests::tests::test_box_into_datum", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_full", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_table_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_compatibility", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "By" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_anynumeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::timestamp_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_in", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_custom_state", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_anynumeric", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::demoops_recv", + "requires": "ByReturn" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "requires": "ByReturn" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_i64_slice", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete", + "requires": "By" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fcinfo_tests::takes_option", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_option", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_4", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i8", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_inserting_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "requires": "ByReturn" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_not_named_one_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::ResultTestsA", + "to": "pgrx_tests::tests::result_tests::resulttestsa_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::result_tests::resulttestsa_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::anyarray_tests::tests", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::anyarray_tests::tests::test_anyarray_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_i16_slice", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_i32_slice", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_panic", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_interval", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_field_update", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_bounds", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_xid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_null", + "requires": "By" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::lifetime_tests::type_ref_with_lifetime", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_two_args_return_void", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::result_tests::ResultTestsA", + "to": "pgrx_tests::tests::result_tests::result_tests_a_func", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::anynumeric_tests::anynumeric_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::default_arg_value_tests::tests", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_negative_default_argument", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f64", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_box", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_string", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_tuple", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_yesterday", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::default_arg_value_tests::tests", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::get_arr_nelems", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::get_arr_nelems", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_get_arr_ndim", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sum", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_val", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_cstring_array", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_values", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_ts", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "requires": "By" + }, + { + "from": "&i8", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "requires": "ByArg" + }, + { + "from": "i8", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i8", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::default_arg_value_tests::default_argument", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_date_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::xid64_tests::tests", + "to": "pgrx_tests::tests::xid64_tests::tests::test_convert_xid_to_u64", + "requires": "By" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_default", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata_safe", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq_with_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonType", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "By" + }, + { + "from": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::submodules::transaction_id::TransactionId", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_xid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_none", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_add_two_numbers", + "requires": "By" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_5_none", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_5_none", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_refstr", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "By" + }, + { + "from": "i16", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "ByArg" + }, + { + "from": "i16", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i16", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::array_tests::display_get_arr_nullbitmap", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_5", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_oid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_some_error", + "requires": "By" + }, + { + "from": "core::result::Result>", + "to": "pgrx_tests::tests::result_tests::tests::return_some_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_neg_random", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_debug2", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_explain_with_args", + "requires": "ByReturn" + }, + { + "from": "core::option::Option>", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "requires": "ByArg" + }, + { + "from": "core::option::Option>", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_time_interval", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_non_null_arg", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::lifetime_tests::CustomType", + "to": "pgrx_tests::tests::lifetime_tests::customtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::lifetime_tests::customtype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_neg_infinity", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonType", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_as_vec_string", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i8", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_ts", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_ts", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "By" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bool", + "requires": "ByReturn" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::complex::complex_in", + "requires": "ByArg" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::complex::complex_in", + "requires": "ByReturn" + }, + { + "from": "create_complex_shell_type", + "to": "pgrx_tests::tests::complex::complex_in", + "requires": "ByArg" + }, + { + "from": "pgrx::nullable::Nullable", + "to": "pgrx_tests::tests::fcinfo_tests::returns_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop_with_panic", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_overridden_sql_with_fn_name", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::timetz_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_offset_round_trip", + "requires": "By" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::complex::complex_out", + "requires": "ByArg" + }, + { + "from": "create_complex_shell_type", + "to": "pgrx_tests::tests::complex::complex_out", + "requires": "ByArg" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::complex::complex_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_random", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "requires": "By" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::numeric_tests::tests::return_an_i32_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_none_optional_result", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_error_report", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamptz", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_num_rt_bounds", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array>", + "to": "pgrx_tests::tests::range_tests::accept_range_date_array", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::range_tests::accept_range_date_array", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::demoops_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::aggregate_tests::demoops_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullError", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_recv", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_time", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullError", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_numeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_value", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_not_utc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_debug3", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_jsontype", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_error_report", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "to": "pgrx_tests::tests::result_tests::tests::return_error_report", + "requires": "ByReturn" + }, + { + "from": "core::option::Option>", + "to": "pgrx_tests::tests::array_tests::optional_array_arg", + "requires": "ByArg" + }, + { + "from": "f32", + "to": "pgrx_tests::tests::array_tests::optional_array_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::json_tests::tests", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::shmem_tests::tests", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_drop", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_neg_inf_inf", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::arr_into_vec", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::array_tests::arr_into_vec", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i32", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "By" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "ByArg" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "ByReturn" + }, + { + "from": "create_complex_shell_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_complex", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_serialization", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_out", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_setof_iterator", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::json_tests::tests", + "to": "pgrx_tests::tests::json_tests::tests::test_json", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::json_tests::tests::test_json", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "ByArg" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_full", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_char", + "requires": "ByReturn" + }, + { + "from": "i16", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "requires": "ByArg" + }, + { + "from": "i16", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i16", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_two_tuple_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_string_guc_null_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_no_catch", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_uuid", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "ByArg" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_2", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_field", + "requires": "By" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_default_arg", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::heap_tuple::tests::test_create_dog", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "ByArg" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_3", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::bgworker_tests::tests", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked_termination_handle", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bgworker_tests::tests", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_worker_allocation_failure", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_json", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_table_iterator_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::list_tests::tests", + "to": "pgrx_tests::tests::list_tests::tests::list_length_10", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::rel_tests::tests", + "to": "pgrx_tests::tests::rel_tests::tests::test_accept_relation", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::from_into_datum_tests::tests", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::null_string_is_none", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_debug4", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_and_ignore_and_finally", + "requires": "By" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::datetime_tests::accept_time", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::datetime_tests::accept_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readonly", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_out", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::default_arg_value_tests::negative_default_argument", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_4_err", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_4_err", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::tests", + "to": "pgrx_tests::tests::pg_cast_tests::tests::assert_cast_func_is_immutable", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "By" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_f32_slice", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::attributes_tests::tests", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_should_panic_attribute", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_check_hook", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "requires": "By" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::int4_from_json", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_name", + "requires": "By" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::datetime_tests::accept_date_round_trip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_panic_in_extern_c_fn", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "requires": "By" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::pg_extern_tests::tests::anyele_type", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_tomorrow", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_by_name", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema2", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::tests", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_explicit_type_cast", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_assign_hook", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch_rethrow", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_panics", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonType", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::jsontype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_timetz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_3", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_ts", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update_in_other_session", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_unknown", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::geo_tests::tests", + "to": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::geo_tests::tests::test_point_into_datum", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f64", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_via_getter", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_pg_epoch_days", + "requires": "By" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single_bare", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_2_args", + "requires": "By" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i32_rt_values", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "requires": "By" + }, + { + "from": "core::result::Result", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result", + "requires": "ByReturn" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fcinfo_tests::panics", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::enum_type_tests::Foo", + "to": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::enum_type_tests::Foo", + "to": "pgrx_tests::tests::enum_type_tests::take_foo_enum", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_one", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i8", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop", + "requires": "By" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::datetime_tests::accept_date", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::datetime_tests::accept_date", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "requires": "ByReturn" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::fcinfo_tests::takes_string", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::fcinfo_tests::takes_string", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_incompatible_return_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_4_err", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bytea", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::from_into_datum_tests::tests", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "requires": "By" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "requires": "ByArg" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::cstring_roundtrip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_anyelement", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::count_true", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::count_true", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::name_tests::tests", + "to": "pgrx_tests::tests::name_tests::tests::renamed_func", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_complex", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_one_col_table", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::numeric_tests::tests::test_option_anynumeric_sum", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "By" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_uuid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_definer", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_random", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_with_timezone_serialization", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn_in_other_module", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "By" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_interval", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_yesterday", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_immutable", + "requires": "By" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "requires": "ByReturn" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two", + "requires": "ByReturn" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::pg_try_tests::get_relation_name", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::composite_type_tests::tests", + "to": "pgrx_tests::tests::composite_type_tests::tests::test_array_of_composite_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_6", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::xact_callback_tests::tests", + "to": "pgrx_tests::tests::xact_callback_tests::tests::test_xact_callback", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_ereport", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_infinity", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_immutable", + "requires": "By" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_set", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "By" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_refstr", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_5", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_timetz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_f32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_ints", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i64", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_qualified_identifier", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_unspecified_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::elided_extern_is_elided", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_wrong_type_assumed", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::get_arr_ndim", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::get_arr_ndim", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_to_array", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_elided_from_schema", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_i64_rt_bounds", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_in", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::lifetime_tests::returns_ref_with_lifetime", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_interval", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field_strict", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_return_text_array", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_tstz", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_binary_coercible_types", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_random_data", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "requires": "By" + }, + { + "from": "&pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::submodules::oids::Oid", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_oid", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_oid", + "requires": "ByReturn" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::fcinfo_tests::takes_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::test_in_different_schema", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_ne", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_select_readwrite", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_numeric", + "requires": "ByReturn" + }, + { + "from": "i8", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "requires": "ByArg" + }, + { + "from": "i8", + "to": "pgrx_tests::tests::fcinfo_tests::takes_i8", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_eyre_result_error", + "requires": "By" + }, + { + "from": "core::option::Option<&str>", + "to": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::default_arg_value_tests::option_default_argument", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_generated_with_custom_sql", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::json_tests::tests", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::json_tests::tests::test_jsonb_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally_with_catch", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_subvec", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_infinity", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_bool", + "requires": "ByReturn" + }, + { + "from": ":: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust\n>", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_single", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_update_skip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_operator_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "By" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::pg_operator_tests::pg_catalog::concat_strings", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "By" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_tstz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_values", + "requires": "By" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_time_with_time_zone", + "requires": "ByReturn" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_guard_tests::extern_func", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_cstr", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::proptests::nop_time", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::proptests::nop_time", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "By" + }, + { + "from": "pgrx::datum::numeric::Numeric<100, 0>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::numeric::Numeric<100, 0>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_int4eq_eq", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_string", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_timestamp_with_time_zone", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::switch_to_should_switch_back_on_panic", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int8", + "requires": "By" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::array_tests::return_zero_length_vec", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::anyarray_tests::anyarray_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "requires": "ByArg" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::scritch_strict", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::blank_function", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::from_into_datum_tests::tests", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_cstring_roundtrip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_ambiguous", + "requires": "By" + }, + { + "from": "String", + "to": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "requires": "ByReturn" + }, + { + "from": "String", + "to": "pgrx_tests::tests::pg_extern_tests::returns_tuple_with_attributes", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_less_args", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::return_setof_iterator", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_val_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_i16", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_in", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::lifetime_tests::returns_iterator_with_lifetime", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::array_tests::arr_mapped_vec", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "requires": "ByReturn" + }, + { + "from": "String", + "to": "pgrx_tests::tests::fcinfo_tests::returns_tuple", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_add_intervals", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_info", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_literal", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_false_bool_is_some_false", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables_rev", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_check_for_interrupts", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_slice_with_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_non_mut", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_debug5", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_void", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_mismatched_signs", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::result_tests::resulttestsa_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::result_tests::ResultTestsA", + "to": "pgrx_tests::tests::result_tests::resulttestsa_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "requires": "By" + }, + { + "from": "&i16", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "requires": "ByArg" + }, + { + "from": "i16", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i16", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::struct_type_tests::tests", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_storage_and_retrieval", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_julian_days", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_too_many_args", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "requires": "By" + }, + { + "from": "core::result::Result, core::convert::Infallible>", + "to": "pgrx_tests::tests::result_tests::tests::return_none_optional_result", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_date", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::example_composite_set", + "requires": "ByReturn" + }, + { + "from": "& '_ str", + "to": "pgrx_tests::tests::srf_tests::example_composite_set", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_null_arg_some", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "requires": "By" + }, + { + "from": "core::result::Result, core::convert::Infallible>", + "to": "pgrx_tests::tests::result_tests::tests::return_some_optional_result", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_sub", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_to_posix_time", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_to_testcasttype", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_check_hook_fail", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_numeric", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::array_tests::validate_cstring_array", + "requires": "ByArg" + }, + { + "from": "core::result::Result>", + "to": "pgrx_tests::tests::array_tests::validate_cstring_array", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::anynumeric_tests::tests", + "to": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::anynumeric_tests::tests::test_anynumeric_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "requires": "By" + }, + { + "from": "&pgrx_pg_sys::include::pg18::Point", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::include::pg18::Point", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::date_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "requires": "By" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::bytea_tests::tests::return_vec_bytes", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "By" + }, + { + "from": "i8", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "ByArg" + }, + { + "from": "i8", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i8", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_round_trip_random", + "requires": "By" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::srf_tests::split_set_with_borrow", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::bgworker_tests::tests", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker_untracked", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_6", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_f64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::func_in_diff_schema2", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "requires": "By" + }, + { + "from": "core::result::Result", + "to": "pgrx_tests::tests::result_tests::tests::return_eyre_result_error", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::one_col_option", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::numeric_tests::tests::test_anynumeric_sum", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_not_found", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_extern", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_in", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "requires": "By" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_f64_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::return_3pm_mountain_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_f64_slice", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::one_col_result_option", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "requires": "By" + }, + { + "from": "&i32", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "requires": "By" + }, + { + "from": "&f64", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_f64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_missing_number", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_empty", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i64_rt_bounds", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_readwrite_in_readonly", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::list_tests::tests", + "to": "pgrx_tests::tests::list_tests::tests::list_length_drained", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_bytes_slice", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_serialization", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_random_data", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_tstz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_rethrow", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two_with_failure", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::datetime_tests::accept_interval", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::datetime_tests::accept_interval", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_ts_rt_values", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_string", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::custom_handwritten_to_sql_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_rethrow", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedenumtype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::VariadicArray>", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_variadic", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::elided_type_is_elided", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::internal_tests::tests", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_send", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "By" + }, + { + "from": "&[u8]", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "ByArg" + }, + { + "from": "&[u8]", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_bytea", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_can_nest", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i8", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types_based_on_domain_types", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::anyelement_tests::tests", + "to": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::anyelement_tests::tests::test_anyelement_arg", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "By" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_timetz", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_datetime_round_trip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_text_array_iter", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_uuid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::heap_tuple::tests::test_tuple_desc_clone", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_zero_i32", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "By" + }, + { + "from": "f32", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "ByArg" + }, + { + "from": "f32", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "requires": "By" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_setof", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_new_composite_type", + "requires": "By" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::uuid_tests::accept_uuid", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::uuid_tests::accept_uuid", + "requires": "ByReturn" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fcinfo_tests::returns_some", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_other", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::anyelement_tests::anyelement_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_date_rt_bounds", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i16", + "requires": "ByReturn" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::fcinfo_tests::takes_f64", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_old_date", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_sort_uniq", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::tests", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_assignment_type_cast", + "requires": "By" + }, + { + "from": "issue1293", + "to": "pgrx_tests::tests::composite_type_tests::create_result", + "requires": "By" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::composite_type_tests::create_result", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i8", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_panic_via_spi", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_finally", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_return_3pm_mountain_time", + "requires": "ByReturn" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "requires": "ByArg" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::returning::singleton::create_dog", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::struct_type_tests::tests", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_from_text", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_tstz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::shmem_tests::tests", + "to": "pgrx_tests::tests::shmem_tests::tests::test_behaves_normally_when_elog_while_holding_lock", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_empty", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_set_of_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_string", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::spi_tests::tests::can_return_borrowed_str", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "requires": "By" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_box", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_complex", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_random_data", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "ByArg" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_0", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::spi_can_read_domain_types", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_neg_inf_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop_when_set_current_twice", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::return_table_iterator", + "requires": "ByReturn" + }, + { + "from": "& '_ str", + "to": "pgrx_tests::tests::srf_tests::return_table_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_bounds", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::inet_tests::tests", + "to": "pgrx_tests::tests::inet_tests::tests::test_take_and_return_inet", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i16", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::varlenaenumtype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_strict_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_send", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "requires": "ByReturn" + }, + { + "from": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "requires": "ByReturn" + }, + { + "from": ":: std :: option :: Option < Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_,\n:: pgrx :: pgbox :: AllocatedByRust > > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_elems", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_same_name", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "requires": "By" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_extern_tests::tests::fn_custom", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::aggregate_tests::demoops_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::demoops_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_deserialize_numeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::default_arg_value_tests::tests", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_option_default_argument", + "requires": "By" + }, + { + "from": "pgrx::datum::array::VariadicArray>", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::heap_tuple::arguments::variadic_array::gets_name_field_default_variadic", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::interval::Interval", + "to": "pgrx_tests::tests::datetime_tests::accept_interval_round_trip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullError", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_out", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_3", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_3", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_postgres", + "requires": "By" + }, + { + "from": "core::option::Option<&str>", + "to": "pgrx_tests::tests::lifetime_tests::returns_option_ref_with_lifetime", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_connect_return_anything", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_some_optional_result", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_oid", + "requires": "ByReturn" + }, + { + "from": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "requires": "ByReturn" + }, + { + "from": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::return_table_two_optional", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_only_default_int4", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_from_str", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_value", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_tstz", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::accept_range_tstz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::support_fn_schema", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::pg_extern_tests::support_fn_schema::test_support_fn", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "requires": "By" + }, + { + "from": "pgrx::datum::numeric::AnyNumeric", + "to": "pgrx_tests::tests::numeric_tests::tests::return_a_u64_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_gets_name_field", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "requires": "By" + }, + { + "from": "&[u8]", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_mb_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_str", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_random_data", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_bad_conversions", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_f64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::internal_tests::tests", + "to": "pgrx_tests::tests::internal_tests::tests::internal_insert", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_my_enum_type", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_out", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "By" + }, + { + "from": "char", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_char_4", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::ElidedType", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::schema_tests::test_schema::elidedtype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array_with_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "requires": "By" + }, + { + "from": "String", + "to": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pg_extern_tests::tests::returns_named_tuple_with_rust_reserved_keyword", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "requires": "ByReturn" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_table", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::json_tests::json_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::json_tests::json_arg", + "requires": "ByReturn" + }, + { + "from": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "requires": "ByReturn" + }, + { + "from": ":: std :: option :: Option < Vec < Option < :: pgrx :: heap_tuple ::\nPgHeapTuple < '_, :: pgrx :: pgbox :: AllocatedByRust > > > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_array_optional_elems", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "requires": "By" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OtherType", + "to": "pgrx_tests::tests::schema_tests::test_schema::othertype_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::json_tests::tests", + "to": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::json_tests::tests::test_json_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_primitive", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_to_vec", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_srf_setof_datum_detoasting_with_borrow", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timezone_offset_cest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_proper_sql_errcode_from_error_report", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_strict", + "requires": "By" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_no_arg", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::RandomData", + "to": "pgrx_tests::tests::roundtrip_tests::randomdata_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error_no_catch", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_null_default", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::TestType", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::schema_tests::test_schema::testtype_send", + "requires": "ByReturn" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "requires": "ByArg" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::datetime_tests::timestamptz_to_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serializedtype", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_none", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_owned_prepared_statement", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::demoops_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::aggregate_tests::demoops_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_conversion", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::parent", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::time_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_add_field", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::variadic_tests::test", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::array::VariadicArray<&str>", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::variadic_tests::test::func_with_variadic_array_args", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullError", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::fcinfo_tests::nullerror_send", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema::OverriddenType", + "to": "pgrx_tests::tests::schema_tests::test_schema::overriddentype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone_offset_round_trip", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::proptests::nop_timestamp", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::proptests::nop_timestamp", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::derive_pgtype_lifetimes::ProximityPart", + "to": "pgrx_tests::tests::derive_pgtype_lifetimes::proximitypart_in", + "requires": "ByReturn" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::fcinfo_tests::returns_none", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "By" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::date::Date", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_date", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec", + "to": "pgrx_tests::tests::array_tests::arr_sort_uniq", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_round_trip_large_date", + "requires": "By" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time::Time", + "to": "pgrx_tests::tests::datetime_tests::convert_timetz_to_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_composite_set", + "requires": "By" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_result_option_set", + "requires": "ByReturn" + }, + { + "from": "char", + "to": "pgrx_tests::tests::fcinfo_tests::takes_char", + "requires": "ByArg" + }, + { + "from": "char", + "to": "pgrx_tests::tests::fcinfo_tests::takes_char", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_create_or_replace", + "requires": "By" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::pg_extern_tests::fdw_handler_return", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::inet_tests::tests", + "to": "pgrx_tests::tests::inet_tests::tests::test_deserialize_inet", + "requires": "By" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp::Timestamp", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date_array", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_catch_and_rethrow_with_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::internal_tests::tests", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_with", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_5_none", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_empty_setof_iterator", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_tomorrow", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_timetz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::result_tests::tests::test_return_result_table_iterator_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_bool_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::uuid_tests::tests", + "to": "pgrx_tests::tests::uuid_tests::tests::test_return_uuid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_enum_guc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::is_invoker", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_date", + "requires": "By" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field_strict", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_quote_identifier", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_7", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "By" + }, + { + "from": "pgrx_pg_sys::include::pg18::BOX", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::include::pg18::BOX", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_box", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_null_error_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_prepared_statement_argument_mismatch", + "requires": "By" + }, + { + "from": "pgrx::datum::uuid::Uuid", + "to": "pgrx_tests::tests::uuid_tests::return_uuid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_date_infinity", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_anyele_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_schema::demostate_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_f64_numeric", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_optional_array", + "requires": "By" + }, + { + "from": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "requires": "ByReturn" + }, + { + "from": "Option < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_optional_elems", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_2", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_2", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::sum_array_i64", + "requires": "ByArg" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::array_tests::sum_array_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_count_true", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_returns_some", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_two", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_char", + "requires": "By" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::proptests::nop_timetz", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_with_timezone::TimeWithTimeZone", + "to": "pgrx_tests::tests::proptests::nop_timetz", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_failure", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_leak_and_drop", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::heap_tuple::tests", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::heap_tuple::tests::test_scritch_strict", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method_first", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "requires": "By" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pg_extern_tests::tests::create_or_replace_method", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_string", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_schema::DemoState", + "to": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::local_support_fn", + "to": "pgrx_tests::tests::pg_extern_tests::test_using_support_fn", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_extern_tests::tests", + "to": "pgrx_tests::tests::pg_extern_tests::tests::test_security_invoker", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedType", + "to": "pgrx_tests::tests::postgres_type_tests::customtextformatserializedtype_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::fake_foo_operator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::variadic_tests::tests", + "to": "pgrx_tests::tests::variadic_tests::tests::test_func_with_variadic_array_args", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::test_type_in_different_schema", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "requires": "By" + }, + { + "from": "core::result::Result<(), std::io::error::Error>", + "to": "pgrx_tests::tests::result_tests::tests::test_return_io_error", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_time_now", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::NullStrict", + "to": "pgrx_tests::tests::fcinfo_tests::nullstrict_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::schema_tests::test_schema", + "to": "pgrx_tests::tests::schema_tests::test_schema::func_in_diff_schema", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_i32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_duration_to_interval_err", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_bool", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::timestamp_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::memcxt_tests::tests", + "to": "pgrx_tests::tests::memcxt_tests::tests::test_current_owned_memory_context_drop", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "requires": "By" + }, + { + "from": "&[u8]", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "requires": "ByArg" + }, + { + "from": "&[u8]", + "to": "pgrx_tests::tests::bytea_tests::tests::return_bytes_slice", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::tests", + "to": "pgrx_tests::tests::pg_cast_tests::tests::test_pg_cast_implicit_type_cast", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_generate_series", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::count_nulls", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::count_nulls", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_i16", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::borrow_datum::tests::test_clone_str", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_negative_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::lifetime_tests::CustomType", + "to": "pgrx_tests::tests::lifetime_tests::type_with_lifetime", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_call_with_enum_null", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::fn_call_tests::tests::my_int4eq", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_date", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_demo_percentile_disc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_has_sql_option_set", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_with_time_zone_utc", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_we_dont_blow_out_errdata_stack_size", + "requires": "By" + }, + { + "from": "pgrx::heap_tuple::PgHeapTuple", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::generate_lots_of_dogs", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::array_tests::serde_serialize_array_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::attributes_tests::tests", + "to": "pgrx_tests::tests::attributes_tests::tests::test_for_ignore_attribute", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_return_table_iterator", + "requires": "By" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::foo_set", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_return_zero_length_vec", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_show_hook", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_execute_prepared_statement_in_readwrite", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_sum_array_i32_overflow", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "By" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "ByArg" + }, + { + "from": "i64", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_ts", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_cast_tests::pg_catalog::TestCastType", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::pg_cast_tests::pg_catalog::testcasttype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgbox_tests::tests", + "to": "pgrx_tests::tests::pgbox_tests::tests::pgbox_alloc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_f32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::timetz_literal_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::schema_tests::tests", + "to": "pgrx_tests::tests::schema_tests::tests::custom_to_sql_type", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::fn_raises_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_date_serialization", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "requires": "ByArg" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::array_tests::get_arr_data_ptr_nth_elem", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_i16", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_array_interval", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::unknown_function", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::CustomTextFormatSerializedEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::postgres_type_tests::fn_takes_option_enum", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_ts_rt_values", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::borrow_datum::tests", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "requires": "By" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::borrow_datum::tests::clone_str", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_func_with_collation", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::oid_tests::tests", + "to": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::oid_tests::tests::test_reasonable_oid", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_warn", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timestamp_with_timezone_serialization", + "requires": "By" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "requires": "By" + }, + { + "from": "core::result::Result, pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_serde_serialize_array_i32_deny_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_arr_data_ptr", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::sum_array_i32", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::sum_array_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_metadata", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three_failure", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::guc_tests::tests", + "to": "pgrx_tests::tests::guc_tests::tests::test_guc_flags", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_with_crash_ignore", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_returns_str", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_time_serialization", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::list_tests::tests", + "to": "pgrx_tests::tests::list_tests::tests::list_length_1000", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_count_nulls", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::shmem_tests::tests", + "to": "pgrx_tests::tests::shmem_tests::tests::test_lock_is_released_on_unwind", + "requires": "By" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "requires": "ByArg" + }, + { + "from": "*mut pgrx_pg_sys::include::pg18::FunctionCallInfoBaseData", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::pgbox::PgBox", + "to": "pgrx_tests::tests::fcinfo_tests::fcinfo_renamed_one_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_date", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::tests", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::postgres_type_tests::tests::test_serialized_enum_type", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_two_defaults", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::zero_datum_edge_cases::tests", + "to": "pgrx_tests::tests::zero_datum_edge_cases::tests::test_vec_bool", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::log_tests::tests", + "to": "pgrx_tests::tests::log_tests::tests::test_debug1", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_3", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::from_into_datum_tests::tests", + "to": "pgrx_tests::tests::from_into_datum_tests::tests::test_incompatible_datum_returns_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_to_duration_conversion", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::inet_tests::tests", + "to": "pgrx_tests::tests::inet_tests::tests::test_serialize_inet", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::one_col", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_nan_ordering", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_bounds_inf", + "requires": "By" + }, + { + "from": "core::option::Option>", + "to": "pgrx_tests::tests::array_tests::optional_array_with_default", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::array_tests::optional_array_with_default", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::struct_type_tests::tests", + "to": "pgrx_tests::tests::struct_type_tests::tests::test_complex_out", + "requires": "By" + }, + { + "from": "pgrx::nullable::Nullable", + "to": "pgrx_tests::tests::fcinfo_tests::passes_null", + "requires": "ByArg" + }, + { + "from": "pgrx::nullable::Nullable", + "to": "pgrx_tests::tests::fcinfo_tests::passes_null", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_ignore_panic", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_accept_range_i64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_operator_tests::tests", + "to": "pgrx_tests::tests::pg_operator_tests::tests::test_correct_schema", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_cursor_prepared_statement_panics_more_args", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_drop_with_panic_catch_and_ignore", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_empty_anynumeric_range", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_ts", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_num_rt_values", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_num_rt_values", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::uuid_tests::tests", + "to": "pgrx_tests::tests::uuid_tests::tests::test_parse_uuid_v4", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bgworker_tests::tests", + "to": "pgrx_tests::tests::bgworker_tests::tests::test_dynamic_bgworker", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_get_three", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_run", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_failure", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_num_rt_bounds", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_update", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::do_panic", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::internal_tests::tests", + "to": "pgrx_tests::tests::internal_tests::tests::internal_get_or_insert_default", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_i32", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_timetz_from_time_and_zone", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::test_result_table_2", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::datetime_tests::tests::test_is_timestamp_utc", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_throw_different_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_spi_select_sees_run", + "requires": "ByReturn" + }, + { + "from": "core::option::Option>", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "requires": "ByArg" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::heap_tuple::arguments::singleton::gets_name_field", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_time", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::tests", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::aggregate_tests::tests::aggregate_first_jsonb", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_tstz", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::time_stamp_with_timezone::TimestampWithTimeZone", + "to": "pgrx_tests::tests::datetime_tests::accept_timestamp_with_time_zone", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "By" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "ByArg" + }, + { + "from": "alloc::string::String", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_string", + "requires": "ByReturn" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::fcinfo_tests::same_name", + "requires": "ByArg" + }, + { + "from": "&str", + "to": "pgrx_tests::tests::fcinfo_tests::same_name", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fn_call_tests::tests", + "to": "pgrx_tests::tests::fn_call_tests::tests::test_with_arg_and_two_defaults_no_args_1_arg", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "By" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "ByArg" + }, + { + "from": "&core::ffi::c_str::CStr", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_cstr", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::numeric_tests::tests::select_a_numeric", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::JsonEnumType", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::postgres_type_tests::jsonenumtype_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_date_rt_values_val_inf", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::test_rt_char_0", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "requires": "By" + }, + { + "from": "core::result::Result<(), alloc::boxed::Box>", + "to": "pgrx_tests::tests::array_tests::tests::test_array_of_points", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "requires": "ByArg" + }, + { + "from": "bool", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "requires": "ByReturn" + }, + { + "from": "core::option::Option<&core::ffi::c_str::CStr>", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "to": "pgrx_tests::tests::aggregate_tests::democustomstate_in", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::lifetime_tests::CustomType", + "to": "pgrx_tests::tests::lifetime_tests::returns_lifetime", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::spi_tests::tests", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::spi_tests::tests::test_open_multiple_tuptables", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_execute_no_error", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::bytea_tests::tests", + "to": "pgrx_tests::tests::bytea_tests::tests::test_return_vec_bytes", + "requires": "By" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "By" + }, + { + "from": "pgrx_pg_sys::include::pg18::Point", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "ByArg" + }, + { + "from": "pgrx_pg_sys::include::pg18::Point", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_point", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::srf_tests::tests", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "requires": "ByReturn" + }, + { + "from": "Option < String >", + "to": "pgrx_tests::tests::srf_tests::tests::spi_in_iterator", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::result_tests::tests::return_result_set_of", + "requires": "ByReturn" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::srf_tests::one_col_result", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "By" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_f64", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_interval_from_seconds", + "requires": "By" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::postgres_type_tests::VarlenaType", + "to": "pgrx_tests::tests::postgres_type_tests::varlenatype_recv", + "requires": "ByReturn" + }, + { + "from": "create_complex_type", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::roundtrip_tests::tests", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "By" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "ByArg" + }, + { + "from": "alloc::vec::Vec>", + "to": "pgrx_tests::tests::roundtrip_tests::tests::rt_array_f64", + "requires": "ByReturn" + }, + { + "from": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "requires": "ByReturn" + }, + { + "from": "Vec < :: pgrx :: heap_tuple :: PgHeapTuple < '_, :: pgrx :: pgbox ::\nAllocatedByRust > >", + "to": "pgrx_tests::tests::heap_tuple::sql_generator_tests::iterable_named_table_array_elems", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::uuid_tests::tests", + "to": "pgrx_tests::tests::uuid_tests::tests::test_accept_uuid", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pg_try_tests::tests", + "to": "pgrx_tests::tests::pg_try_tests::tests::test_pg_try_no_error_with_catch", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::before_insert_noop_rust", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_array_deny_nulls", + "requires": "ByReturn" + }, + { + "from": "pgrx::datum::internal::Internal", + "to": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::result_tests::ResultTestsA", + "to": "pgrx_tests::tests::result_tests::resulttestsa_recv", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::result_tests::tests", + "to": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx_pg_sys::submodules::panic::ErrorReport>", + "to": "pgrx_tests::tests::result_tests::tests::test_custom_ereport", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::proptests::tests", + "to": "pgrx_tests::tests::proptests::tests::time_spi_roundtrip", + "requires": "By" + }, + { + "from": "pgrx::datum::array::Array", + "to": "pgrx_tests::tests::array_tests::iterate_array_with_deny_null", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::datetime_tests::tests", + "to": "pgrx_tests::tests::datetime_tests::tests::test_accept_interval_neg_random", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::range_tests::tests", + "to": "pgrx_tests::tests::range_tests::tests::test_range_i32_rt_bounds", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::default_arg_value_tests::tests", + "to": "pgrx_tests::tests::default_arg_value_tests::tests::test_default_argument_specified", + "requires": "By" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::json_tests::jsonb_arg", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::json_tests::jsonb_arg", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "requires": "ByArg" + }, + { + "from": "alloc::ffi::c_str::CString", + "to": "pgrx_tests::tests::aggregate_tests::demopercentiledisc_out", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::fcinfo_tests::tests", + "to": "pgrx_tests::tests::fcinfo_tests::tests::test_takes_option_with_null_arg", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::numeric_tests::tests", + "to": "pgrx_tests::tests::numeric_tests::tests::test_return_a_u64_numeric", + "requires": "By" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_date_rt_values", + "requires": "ByArg" + }, + { + "from": "pgrx::datum::range::Range", + "to": "pgrx_tests::tests::range_tests::range_date_rt_values", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_1", + "requires": "ByReturn" + }, + { + "from": "Option < i32 >", + "to": "pgrx_tests::tests::srf_tests::result_table_1", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::array_tests::tests", + "to": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "requires": "By" + }, + { + "from": "core::result::Result<(), pgrx::spi::SpiError>", + "to": "pgrx_tests::tests::array_tests::tests::test_enum_array_roundtrip", + "requires": "ByReturn" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_cmp", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_ge", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_gt", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_lt", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_le", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_eq", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrxmodulequalificationtest_hash", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_combine", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sub_name_moving_state_inverse", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx::datum::json::Json", + "to": "pgrx_tests::tests::aggregate_tests::FirstJson", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::first_json_first_json_state", + "to": "pgrx_tests::tests::aggregate_tests::FirstJson", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_custom_state_demo_custom_state_finalize", + "to": "pgrx_tests::tests::aggregate_tests::DemoCustomState", + "requires": "By" + }, + { + "from": "pgrx::datum::anyelement::AnyElement", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::first_any_element_first_any_element_state", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyElement", + "requires": "By" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::issue1134::foo_foo_state", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::issue1134::foo_foo_finalize", + "to": "pgrx_tests::tests::issue1134::Foo", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "ByArg" + }, + { + "from": "f64", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_percentile_disc_demo_percentile_disc_finalize", + "to": "pgrx_tests::tests::aggregate_tests::DemoPercentileDisc", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "core::option::Option", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_state", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::pgrx_module_qualification_test_pgrx_mqt_name_finalize", + "to": "pgrx_tests::tests::pgrx_module_qualification::pgrx_modqual_tests::PgrxModuleQualificationTest", + "requires": "By" + }, + { + "from": "pgrx::datum::anyarray::AnyArray", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::first_any_array_first_any_array_state", + "to": "pgrx_tests::tests::aggregate_tests::FirstAnyArray", + "requires": "By" + }, + { + "from": "pgrx::datum::json::JsonB", + "to": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::first_json_b_first_json_b_state", + "to": "pgrx_tests::tests::aggregate_tests::FirstJsonB", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::DemoOps", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "ByArg" + }, + { + "from": "i32", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "ByArg" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_combine", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::aggregate_tests::demo_ops_demo_sum_name_moving_state_inverse", + "to": "pgrx_tests::tests::aggregate_tests::DemoOps", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::intercept_bears", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_postgres", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_standard", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::dont_delete_trigger", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::inserts_trigger_metadata_safe", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_postgres", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::has_sql_option_set", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::noop_rust", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_explicit_lifetimes", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::add_field_boopers", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_argument", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests", + "to": "pgrx_tests::tests::trigger_tests::tests::field_species_fox_to_bear", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_return", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_aliased_both", + "requires": "By" + }, + { + "from": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests", + "to": "pgrx_tests::tests::trigger_tests::tests::trigger_signature_compile_tests::signature_alloc_by_rust", + "requires": "By" + } + ], + "versioned_so": false +} \ No newline at end of file