use arrow_odbc::arrow_schema_from;
use arrow_odbc::odbc_api::Connection;
use arrow_odbc::odbc_api::parameter::VarCharArray;
use arrow_schema::{Field, Schema};
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
use crate::column_types::main::portable_type::portable_type;
use crate::odbc_source::_helpers::query::from_item;
use crate::odbc_source::constants::{ANY_NAME, TABLE_TYPES};
use crate::odbc_source::errors::OdbcSourceError;
use crate::postgres_source::models::{PgType, SourceColumn, SourceTable};
pub(crate) fn table_matcher(patterns: &[String]) -> Result<GlobSet, OdbcSourceError> {
let mut builder = GlobSetBuilder::new();
for pattern in patterns {
let glob = GlobBuilder::new(pattern)
.case_insensitive(true)
.build()
.map_err(|error| {
OdbcSourceError::Invalid(format!("invalid table pattern {pattern:?}: {error}"))
})?;
builder.add(glob);
}
builder
.build()
.map_err(|error| OdbcSourceError::Invalid(error.to_string()))
}
pub(crate) fn described(
connection: &Connection<'_>,
from: &str,
) -> Result<Vec<SourceColumn>, OdbcSourceError> {
let dbms: String = connection.database_management_system_name()?;
let mut prepared = connection.prepare(&format!("SELECT * FROM {from}"))?;
let schema: Schema = arrow_schema_from(&mut prepared, Some(&dbms), false)?;
Ok(schema
.fields()
.iter()
.map(|field| source_column(field))
.collect())
}
fn source_column(field: &Field) -> SourceColumn {
SourceColumn {
name: field.name().clone(),
postgres_type: field.data_type().to_string(),
pg_type: PgType::Other,
column_type: portable_type(field),
nullable: field.is_nullable(),
source_spelling: None,
}
}
pub(crate) fn source_table(
(schema, name): (String, String),
columns: Vec<SourceColumn>,
primary_key: Vec<String>,
) -> SourceTable {
SourceTable {
schema,
name,
columns,
primary_key,
indexed_columns: Vec::new(),
estimated_rows: -1,
estimated_bytes: -1,
comment: None,
}
}
pub(crate) fn catalog_tables(
connection: &Connection<'_>,
(include, exclude): (&[String], &[String]),
) -> Result<Vec<SourceTable>, OdbcSourceError> {
let include = table_matcher(include)?;
let exclude = table_matcher(exclude)?;
let mut names: Vec<(String, String)> = Vec::new();
let listed = match connection.tables("", ANY_NAME, ANY_NAME, TABLE_TYPES) {
Ok(listed) => listed,
Err(refused) => match connection.max_schema_name_len() {
Ok(0) => connection
.tables("", "", ANY_NAME, TABLE_TYPES)
.map_err(|_| refused)?,
_ => return Err(refused.into()),
},
};
for row in listed {
let row = row?;
let (schema, table) = (catalog_text(&row.schema)?, catalog_text(&row.table)?);
let qualified = match schema.is_empty() {
true => table.clone(),
false => format!("{schema}.{table}"),
};
if include.is_match(&qualified) && !exclude.is_match(&qualified) {
names.push((schema, table));
}
}
let mut tables: Vec<SourceTable> = Vec::with_capacity(names.len());
for (schema, table) in names {
let columns = described(connection, &from_item(&schema, &table, None))?;
let key = primary_key(connection, &schema, &table)?;
tables.push(source_table((schema, table), columns, key));
}
Ok(tables)
}
fn primary_key(
connection: &Connection<'_>,
schema: &str,
table: &str,
) -> Result<Vec<String>, OdbcSourceError> {
let mut key: Vec<(i16, String)> = Vec::new();
let schema_name = (!schema.is_empty()).then_some(schema);
for row in connection.primary_keys(None, schema_name, table)? {
let row = row?;
key.push((row.key_seq, catalog_text(&row.column)?));
}
key.sort();
let columns: Vec<String> = key.into_iter().map(|(_, column)| column).collect();
Ok(columns)
}
fn catalog_text<const LENGTH: usize>(
value: &VarCharArray<LENGTH>,
) -> Result<String, OdbcSourceError> {
match value.as_str() {
Ok(text) => Ok(text.unwrap_or_default().to_owned()),
Err(error) => Err(OdbcSourceError::Invalid(format!(
"the driver's catalog holds a name that is not UTF-8: {error}"
))),
}
}