use crate::adapters::bigquery::_helpers::dialect::type_names::{
logical_type, portable_type, widens_in_place,
};
use crate::adapters::bigquery::_helpers::dialect::write::write_statements;
use crate::adapters::bigquery::models::BigQuerySql;
use crate::adapters::contract::constants::STAGING_SUFFIX;
use crate::adapters::contract::models::{
ChangeApply, CursorValue, TableName, WriteStatementsRequest,
};
use crate::adapters::contract::types::SqlAdapter;
use crate::column_types::models::{ColumnType, LiveColumnType, Warehouse, WarehouseType};
impl SqlAdapter for BigQuerySql {
fn warehouse(&self) -> Warehouse {
Warehouse::BigQuery
}
fn captures_changes(&self, _apply: ChangeApply) -> bool {
false
}
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 widens_in_place(&self, live: &ColumnType, target: &ColumnType) -> bool {
widens_in_place(live, target)
}
fn render_exact_identifier(&self, name: &str) -> String {
format!("`{}`", name.replace('\\', "\\\\").replace('`', "\\`"))
}
fn render_identifier(&self, name: &str) -> String {
self.render_exact_identifier(&self.stored_name(name))
}
fn render_loader_value_literal(&self, text: &str) -> String {
format!(
"'{}'",
text.replace('\\', "\\\\")
.replace('\'', "\\'")
.replace('\n', "\\n")
.replace('\r', "\\r")
)
}
fn render_source_expression_cast(&self, name: &str, column_type: &ColumnType) -> String {
let column = self.render_identifier(name);
match column_type {
ColumnType::Json => format!("PARSE_JSON({column})"),
_ => column,
}
}
fn render_table_comment(&self, table: &TableName, description: &str) -> Option<String> {
(!description.is_empty()).then(|| {
format!(
"ALTER TABLE {} SET OPTIONS (description = {})",
self.render_qualified_name(table),
self.render_loader_value_literal(description)
)
})
}
fn render_alter_column_type(&self, target: &str, column: &str, sql_type: &str) -> String {
format!("ALTER TABLE {target} ALTER COLUMN {column} SET DATA TYPE {sql_type}")
}
fn render_rebuild_table(&self, target: &str, select: &str) -> String {
format!("CREATE OR REPLACE TABLE {target} AS SELECT {select} FROM {target}")
}
fn render_empty_staging(&self, staging: &TableName) -> String {
format!(
"DELETE FROM {} WHERE TRUE",
self.render_qualified_name(staging)
)
}
fn render_swap(
&self,
target: &TableName,
build: &TableName,
_indexes: &[String],
) -> Vec<String> {
let (old, new) = (
self.render_qualified_name(target),
self.render_qualified_name(build),
);
vec![
format!("CREATE OR REPLACE TABLE {old} AS SELECT * FROM {new}"),
format!("DROP TABLE IF EXISTS {new}"),
]
}
fn render_write(
&self,
request: &WriteStatementsRequest<'_>,
staging: &TableName,
) -> Vec<String> {
write_statements(self, request, staging)
}
fn commits_alone(&self, _statement: &str) -> bool {
true
}
fn render_text_cast(&self, expression: &str) -> String {
format!("CAST({expression} AS STRING)")
}
fn render_cursor_text(&self, column: &str, value: CursorValue) -> String {
match value {
CursorValue::EpochMicros { zoned: true } => {
format!("CAST(UNIX_MICROS(MAX({column})) AS STRING)")
}
CursorValue::EpochMicros { zoned: false } => {
format!("CAST(UNIX_MICROS(TIMESTAMP(MAX({column}), 'UTC')) AS STRING)")
}
CursorValue::Date => format!("FORMAT_DATE('%F', MAX({column}))"),
CursorValue::Plain => format!("CAST(MAX({column}) AS STRING)"),
}
}
fn render_staging_filter(&self, suffix: &str) -> String {
format!(
"LOWER(table_name) LIKE {}",
self.render_loader_value_literal(&format!("%{}%", suffix.to_ascii_lowercase()))
)
}
fn list_staging_relations_sql(&self, table: &TableName, database: Option<&str>) -> String {
let project = table
.database
.as_deref()
.or(database)
.map(|name| format!("{}.", self.render_identifier(name)))
.unwrap_or_default();
format!(
"SELECT table_name FROM {project}{}.INFORMATION_SCHEMA.TABLES WHERE {}",
self.render_identifier(&table.schema),
self.render_staging_filter(&format!("{STAGING_SUFFIX}_"))
)
}
}