use crate::adapters::contract::constants::{BEGIN_STATEMENT, COMMIT_STATEMENT, STAGING_SUFFIX};
use crate::adapters::contract::main::_ranked_source::ranked_source;
use crate::adapters::contract::models::{
ChangeApply, CursorValue, TableName, WriteMode, WriteStatementsRequest,
};
use crate::adapters::contract::types::SqlAdapter;
use crate::adapters::postgres::_helpers::type_names::{logical_type, portable_type, staging_type};
use crate::adapters::postgres::constants::{BLOCK_QUOTE, TEMPORARY_SCHEMA, UNBOUNDED_NUMERIC};
use crate::adapters::postgres::models::PostgresSql;
use crate::column_types::models::{ColumnType, LiveColumnType, TypeFit, Warehouse, WarehouseType};
use crate::schema_plan::models::DesiredColumn;
fn is_folded(name: &str) -> bool {
name.chars()
.next()
.is_some_and(|first| first.is_ascii_uppercase() || first == '_')
&& name.chars().all(|character| {
character.is_ascii_uppercase() || character.is_ascii_digit() || character == '_'
})
}
impl SqlAdapter for PostgresSql {
fn merges_files(&self) -> bool {
true
}
fn warehouse(&self) -> Warehouse {
Warehouse::Postgres
}
fn max_identifier_length(&self) -> Option<usize> {
Some(63)
}
fn captures_changes(&self, _apply: ChangeApply) -> bool {
false
}
fn keeps_tables(&self) -> bool {
true
}
fn keeps_nanoseconds(&self) -> bool {
false
}
fn render_loader_logical_type(&self, column_type: &ColumnType) -> WarehouseType {
logical_type(column_type)
}
fn live_type(&self, live: &LiveColumnType) -> ColumnType {
portable_type(live).unwrap_or_else(|| ColumnType::Native(live.data_type.clone()))
}
fn assigns_exactly(&self, desired: &ColumnType, live: &ColumnType) -> bool {
let integer = matches!(desired, ColumnType::SmallInt | ColumnType::Int);
match (desired, live) {
_ if self.type_fit(desired, live) == TypeFit::Fits => true,
(_, ColumnType::SmallInt | ColumnType::Int | ColumnType::Decimal { .. }) if integer => {
true
}
(ColumnType::Text | ColumnType::Varchar(_), ColumnType::Varchar(_)) => true,
(ColumnType::Decimal { scale: from, .. }, ColumnType::Decimal { scale: to, .. }) => {
from <= to
}
(ColumnType::Decimal { .. }, ColumnType::Native(name)) => name == UNBOUNDED_NUMERIC,
(_, ColumnType::Native(name)) if integer => name == UNBOUNDED_NUMERIC,
_ => false,
}
}
fn widens_in_place(&self, _live: &ColumnType, _target: &ColumnType) -> bool {
true
}
fn stored_name(&self, name: &str) -> String {
match is_folded(name) {
true => name.to_ascii_lowercase(),
false => name.to_owned(),
}
}
fn render_qualified_name(&self, table: &TableName) -> String {
format!(
"{}.{}",
self.render_identifier(&table.schema),
self.render_identifier(&table.table)
)
}
fn render_create_schema(&self, table: &TableName) -> String {
let create = format!("CREATE SCHEMA {}", self.render_identifier(&table.schema));
if table.schema.contains(BLOCK_QUOTE) {
return format!(
"CREATE SCHEMA IF NOT EXISTS {}",
self.render_identifier(&table.schema)
);
}
format!(
"DO {BLOCK_QUOTE} BEGIN IF NOT EXISTS (SELECT FROM pg_catalog.pg_namespace WHERE nspname = {}) THEN {create}; END IF; END {BLOCK_QUOTE}",
self.render_loader_value_literal(&self.stored_name(&table.schema)),
)
}
fn render_staging_type(&self, column_type: &ColumnType) -> String {
staging_type(column_type)
}
fn render_source_expression_cast(&self, name: &str, column_type: &ColumnType) -> String {
let column = self.render_identifier(name);
match column_type {
ColumnType::Json | ColumnType::Uuid | ColumnType::Native(_) | ColumnType::Array(_) => {
format!(
"CAST({column} AS {})",
self.render_loader_logical_type(column_type).sql
)
}
_ => column,
}
}
fn staging_relation_name(&self, table: &TableName, staging_id: &str) -> TableName {
let safe_id: String = staging_id
.chars()
.filter(|character| character.is_ascii_alphanumeric() || *character == '_')
.collect();
TableName {
database: None,
schema: TEMPORARY_SCHEMA.to_owned(),
table: format!("{}{STAGING_SUFFIX}_{safe_id}", table.table),
}
}
fn render_create_staging_table(
&self,
table: &TableName,
columns: &[DesiredColumn],
staging_id: &str,
) -> (TableName, String) {
let staging = self.staging_relation_name(table, staging_id);
let definitions: Vec<String> = columns
.iter()
.map(|column| {
format!(
"{} {}",
self.render_identifier(&column.name),
self.render_staging_type(&column.column_type)
)
})
.collect();
let create = format!(
"CREATE TEMPORARY TABLE {} ({})",
self.render_qualified_name(&staging),
definitions.join(", ")
);
(staging, create)
}
fn render_alter_column_type(&self, target: &str, column: &str, sql_type: &str) -> String {
format!(
"ALTER TABLE {target} ALTER COLUMN {column} TYPE {sql_type} USING {column}::{sql_type}"
)
}
fn render_empty_staging(&self, staging: &TableName) -> String {
format!("TRUNCATE {}", self.render_qualified_name(staging))
}
fn render_key_equality(&self, (left, right): (&str, &str), nullable: bool) -> String {
match nullable {
true => format!("({left} = {right} OR ({left} IS NULL AND {right} IS NULL))"),
false => format!("{left} = {right}"),
}
}
fn render_merge(
&self,
request: &WriteStatementsRequest<'_>,
unique_key: &[String],
source: &str,
values: &[String],
) -> String {
let ranked = ranked_source(self, request, (source, values), false);
let (source, values) = ranked.as_ref().map_or((source, values), |(source, names)| {
(source.as_str(), names.as_slice())
});
let names: Vec<String> = request
.columns
.iter()
.map(|column| self.render_identifier(&column.name))
.collect();
let keys: Vec<String> = unique_key
.iter()
.map(|key| self.render_identifier(key))
.collect();
let updates: Vec<String> = names
.iter()
.filter(|name| !keys.contains(name))
.map(|name| format!("{name} = EXCLUDED.{name}"))
.collect();
let action = match updates.is_empty() {
true => "DO NOTHING".to_owned(),
false => format!("DO UPDATE SET {}", updates.join(", ")),
};
format!(
"INSERT INTO {} ({}) SELECT {} FROM {source} ON CONFLICT ({}) {action}",
self.render_qualified_name(request.table),
names.join(", "),
values.join(", "),
keys.join(", ")
)
}
fn render_replace(
&self,
request: &WriteStatementsRequest<'_>,
_staging: &TableName,
insert_from: &str,
) -> Vec<String> {
let target = self.render_qualified_name(request.table);
vec![
BEGIN_STATEMENT.to_owned(),
format!("DELETE FROM {target}"),
format!("INSERT INTO {target} {insert_from}"),
COMMIT_STATEMENT.to_owned(),
]
}
fn render_key_index(&self, table: &TableName, mode: &WriteMode) -> Option<String> {
let matched = mode.matched_keys();
let keys: Vec<String> = matched
.iter()
.map(|(key, _)| self.render_identifier(key))
.collect();
let nulls = match matched.iter().any(|(_, nullable)| *nullable) {
true => " NULLS NOT DISTINCT",
false => "",
};
(!keys.is_empty()).then(|| {
format!(
"CREATE UNIQUE INDEX IF NOT EXISTS {} ON {} ({}){nulls}",
self.render_identifier(&format!("{}_sqlload_key", table.table)),
self.render_qualified_name(table),
keys.join(", ")
)
})
}
fn render_cursor_text(&self, column: &str, value: CursorValue) -> String {
match value {
CursorValue::EpochMicros { .. } => format!(
"CAST(CAST(EXTRACT(EPOCH FROM date_trunc('second', MAX({column}))) AS bigint) * 1000000 + CAST(EXTRACT(MICROSECONDS FROM MAX({column})) AS bigint) % 1000000 AS text)"
),
CursorValue::Date => format!("to_char(MAX({column}), 'YYYY-MM-DD')"),
CursorValue::Plain => format!("CAST(MAX({column}) AS text)"),
}
}
fn render_binary_text(&self, expression: &str) -> String {
format!("{expression} COLLATE \"C\"")
}
}