fn starts_with_at(s: &str, i: usize, pat: &str) -> bool {
s.as_bytes().get(i..).is_some_and(|b| b.starts_with(pat.as_bytes()))
}
use dsl_catalog::{
CATALOG_VERSION, Catalog, Column, Constraint, ConstraintKind, ConstraintRef, Extension, Function, FunctionArg,
IndexDef, Policy, Schema, Sequence, Table, TableKind, Trigger, Type, TypeKind,
};
use dsl_parse::{ParsedFile, StatementKind};
pub fn from_file(file: &ParsedFile) -> Catalog {
let mut public = Schema { name: "public".into(), tables: Vec::new() };
let mut other: std::collections::BTreeMap<String, Schema> = Default::default();
for stmt in &file.statements {
let StatementKind::CreateTable(ct) = &stmt.kind else {
continue;
};
let schema_name = ct.table.schema.clone().unwrap_or_else(|| "public".into());
let table = Table {
schema: schema_name.clone(),
name: ct.table.name.clone(),
kind: TableKind::Table,
columns: ct
.columns
.iter()
.map(|c| Column {
name: c.name.clone(),
data_type: c.type_name.clone(),
nullable: c.nullable,
default: c.default.clone(),
comment: None,
generated: None,
json_keys: None,
})
.collect(),
constraints: Vec::new(),
indexes: Vec::new(),
triggers: Vec::new(),
policies: Vec::new(),
comment: None,
row_estimate: None,
owner: None,
definition: None,
strict: false,
options: None,
};
if schema_name.eq_ignore_ascii_case("public") {
public.tables.push(table);
} else {
other
.entry(schema_name.clone())
.or_insert_with(|| Schema { name: schema_name, tables: Vec::new() })
.tables
.push(table);
}
}
let mut schemas = Vec::new();
if !public.tables.is_empty() {
schemas.push(public);
}
schemas.extend(other.into_values());
Catalog {
version: CATALOG_VERSION,
connection_id: "<source>".into(),
schemas,
functions: Vec::new(),
types: Vec::new(),
roles: Vec::new(),
sequences: Vec::new(),
extensions: Vec::new(),
}
}
pub fn from_source(file: &ParsedFile, source: &str) -> Catalog {
let mut cat = from_file(file);
recover_failed_create_tables(&mut cat, source);
cat.sequences = scan_sequences(source);
cat.types = scan_types(source);
cat.extensions = scan_extensions(source);
cat.functions = scan_functions(source);
cat.roles = scan_roles(source);
inherit_partition_columns(&mut cat, source);
let comments_by_col = scan_column_comments(source);
let table_comments = scan_table_comments(source);
let indexes_by_table = scan_indexes(source);
let triggers_by_table = scan_triggers(source);
let policies_by_table = scan_policies(source);
let insert_counts = scan_dml_row_deltas(source);
for schema in cat.schemas.iter_mut() {
for table in schema.tables.iter_mut() {
table.constraints = scan_constraints_for(source, &table.name);
let key = table.name.to_ascii_lowercase();
if let Some(c) = table_comments.get(&key) {
table.comment = Some(c.clone());
}
if let Some(idxs) = indexes_by_table.get(&key) {
table.indexes = idxs.clone();
}
if let Some(trgs) = triggers_by_table.get(&key) {
table.triggers = trgs.clone();
}
if let Some(pols) = policies_by_table.get(&key) {
table.policies = pols.clone();
}
if let Some(&n) = insert_counts.get(&key) {
table.row_estimate = Some((n.max(0)) as f64);
}
let generated_by_col = scan_generated_for(source, &table.name);
let json_keys_by_col = scan_json_keys_for(source, &table.name);
let defaults_by_col = scan_defaults_for(source, &table.name);
if let Some(o) = scan_owner_for(source, &table.name) {
table.owner = Some(o);
}
for col in table.columns.iter_mut() {
let ckey = format!("{}.{}", table.name.to_ascii_lowercase(), col.name.to_ascii_lowercase());
if let Some(c) = comments_by_col.get(&ckey) {
col.comment = Some(c.clone());
}
if let Some(g) = generated_by_col.get(&col.name.to_ascii_lowercase()) {
col.generated = Some(g.clone());
}
if let Some(keys) = json_keys_by_col.get(&col.name.to_ascii_lowercase()) {
col.json_keys = Some(keys.clone());
}
if col.default.is_none()
&& let Some(d) = defaults_by_col.get(&col.name.to_ascii_lowercase())
{
col.default = Some(d.clone());
}
}
}
}
for (schema_name, name, kind, columns, definition) in scan_views(source) {
if cat
.schemas
.iter()
.any(|s| s.name.eq_ignore_ascii_case(&schema_name) && s.tables.iter().any(|t| t.name.eq_ignore_ascii_case(&name)))
{
continue; }
let cols: Vec<Column> = columns
.into_iter()
.map(|c| Column {
name: c,
data_type: String::new(),
nullable: true,
default: None,
comment: None,
generated: None,
json_keys: None,
})
.collect();
let view = Table {
schema: schema_name.clone(),
name,
kind,
columns: cols,
constraints: Vec::new(),
indexes: Vec::new(),
triggers: Vec::new(),
policies: Vec::new(),
comment: None,
row_estimate: None,
owner: None,
definition: Some(definition),
strict: false,
options: None,
};
if let Some(s) = cat.schemas.iter_mut().find(|s| s.name.eq_ignore_ascii_case(&schema_name)) {
s.tables.push(view);
} else {
cat.schemas.push(Schema { name: schema_name, tables: vec![view] });
}
}
cat
}
#[allow(clippy::type_complexity)]
fn scan_views(src: &str) -> Vec<(String, String, TableKind, Vec<String>, String)> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let n = bytes.len();
let is_ident = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
let skip_ws = |mut i: usize| {
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
i
};
let read_word = |i: usize| -> (String, usize) {
let mut j = i;
while j < n && is_ident(bytes[j]) {
j += 1;
}
(upper[i..j].to_string(), j)
};
let mut out = Vec::new();
let mut from = 0usize;
while let Some(rel) = upper[from..].find("CREATE") {
let at = from + rel;
from = at + 6;
if at > 0 && is_ident(bytes[at - 1]) {
continue;
}
let mut p = at + 6;
let mut materialized = false;
let mut is_view = false;
loop {
p = skip_ws(p);
let (w, np) = read_word(p);
if np == p {
break;
}
match w.as_str() {
"OR" | "REPLACE" | "TEMP" | "TEMPORARY" | "GLOBAL" | "LOCAL" | "RECURSIVE" | "UNLOGGED" => p = np,
"MATERIALIZED" => {
materialized = true;
p = np;
},
"VIEW" => {
p = np;
is_view = true;
break;
},
_ => break,
}
}
if !is_view {
continue;
}
{
let (w1, q1) = read_word(skip_ws(p));
if w1 == "IF" {
let (w2, q2) = read_word(skip_ws(q1));
let (w3, q3) = read_word(skip_ws(q2));
if w2 == "NOT" && w3 == "EXISTS" {
p = q3;
}
}
}
let Some((schema_opt, name, after)) = read_qualified_ident(src, skip_ws(p)) else { continue };
let schema = schema_opt.unwrap_or_else(|| "public".into());
p = skip_ws(after);
let mut columns = Vec::new();
if p < n && bytes[p] == b'(' {
if let Some(close) = find_matching_paren(src, p) {
for c in src[p + 1..close].split(',') {
let c = c.trim().trim_matches('"');
if !c.is_empty() {
columns.push(c.to_string());
}
}
p = skip_ws(close + 1);
} else {
continue;
}
}
let (w, np) = read_word(p);
if w != "AS" {
continue;
}
let body_start = skip_ws(np);
let end = view_stmt_end(bytes, body_start);
let definition = src[body_start..end].trim().to_string();
if definition.is_empty() {
continue;
}
let kind = if materialized { TableKind::MaterializedView } else { TableKind::View };
out.push((schema, name, kind, columns, definition));
from = end;
}
out
}
fn view_stmt_end(bytes: &[u8], start: usize) -> usize {
let n = bytes.len();
let mut i = start;
let mut depth = 0i32;
while i < n {
match bytes[i] {
b'\'' | b'"' | b'`' => {
let q = bytes[i];
i += 1;
while i < n && bytes[i] != q {
i += 1;
}
},
b'(' => depth += 1,
b')' => depth -= 1,
b';' if depth == 0 => return i,
_ => {},
}
i += 1;
}
n
}
fn recover_failed_create_tables(cat: &mut Catalog, src: &str) {
let cleaned = strip_string_literals(src);
let upper = cleaned.to_ascii_uppercase();
let bytes = cleaned.as_bytes();
let n = bytes.len();
let needle = "CREATE TABLE";
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let at = from + rel;
if at > 0 {
let prev = bytes[at - 1] as char;
if prev.is_ascii_alphanumeric() || prev == '_' {
from = at + needle.len();
continue;
}
}
let mut k = at + needle.len();
for kw in ["IF NOT EXISTS", "UNLOGGED", "TEMP", "TEMPORARY", "GLOBAL", "LOCAL"] {
while k < n && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k + kw.len() <= n && upper.as_bytes()[k..k + kw.len()] == *kw.as_bytes() {
k += kw.len();
}
}
while k < n && bytes[k].is_ascii_whitespace() {
k += 1;
}
let (schema, name, after_name) = match read_qualified_ident(&cleaned, k) {
Some(t) => t,
None => {
from = at + needle.len();
continue;
},
};
from = at + needle.len();
if name.is_empty() {
continue;
}
let schema_name = schema.unwrap_or_else(|| "public".to_string()).to_ascii_lowercase();
let table_name_lc = name.to_ascii_lowercase();
if cat.schemas.iter().any(|s| {
s.name.eq_ignore_ascii_case(&schema_name) && s.tables.iter().any(|t| t.name.eq_ignore_ascii_case(&table_name_lc))
}) {
continue;
}
let mut p = after_name;
while p < n && bytes[p].is_ascii_whitespace() {
p += 1;
}
if p >= n || bytes[p] != b'(' {
continue;
}
let body_start = p + 1;
let body_end = match find_matching_paren(&cleaned, p) {
Some(e) => e,
None => continue,
};
let body = &cleaned[body_start..body_end];
let columns = parse_create_table_columns(body);
if columns.is_empty() {
continue;
}
let table = Table {
schema: schema_name.clone(),
name: name.clone(),
kind: TableKind::Table,
columns,
constraints: Vec::new(),
indexes: Vec::new(),
triggers: Vec::new(),
policies: Vec::new(),
comment: None,
row_estimate: None,
owner: None,
definition: None,
strict: false,
options: None,
};
if let Some(s) = cat.schemas.iter_mut().find(|s| s.name.eq_ignore_ascii_case(&schema_name)) {
s.tables.push(table);
} else {
cat.schemas.push(Schema { name: schema_name, tables: vec![table] });
}
}
}
fn read_qualified_ident(src: &str, pos: usize) -> Option<(Option<String>, String, usize)> {
let (first, after_first) = read_ident_simple(src, pos)?;
if first.is_empty() {
return None;
}
let bytes = src.as_bytes();
let mut p = after_first;
while p < bytes.len() && bytes[p].is_ascii_whitespace() {
p += 1;
}
if p < bytes.len() && bytes[p] == b'.' {
let (second, after_second) = read_ident_simple(src, p + 1)?;
if !second.is_empty() {
return Some((Some(first), second, after_second));
}
}
Some((None, first, after_first))
}
fn ident_close(open: u8) -> Option<u8> {
match open {
b'"' => Some(b'"'),
b'[' => Some(b']'),
b'`' => Some(b'`'),
_ => None,
}
}
pub(crate) fn unquote_ident(raw: &str) -> &str {
let bytes = raw.as_bytes();
let (Some(&first), Some(&last)) = (bytes.first(), bytes.last()) else {
return raw;
};
if bytes.len() >= 2 && ident_close(first) == Some(last) && !bytes[1..bytes.len() - 1].contains(&last) {
if let Some(inner) = raw.get(1..raw.len() - 1) {
return inner;
}
}
raw
}
fn read_ident_simple(src: &str, pos: usize) -> Option<(String, usize)> {
let bytes = src.as_bytes();
let n = bytes.len();
let mut i = pos;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i >= n {
return None;
}
if let Some(close) = ident_close(bytes[i]) {
let start = i + 1;
let mut j = start;
while j < n && bytes[j] != close {
j += 1;
}
if j >= n {
return None;
}
return Some((src[start..j].to_string(), j + 1));
}
let start = i;
while i < n && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
i += 1;
}
if i == start {
return None;
}
Some((src[start..i].to_string(), i))
}
fn find_matching_paren(src: &str, open: usize) -> Option<usize> {
let bytes = src.as_bytes();
if open >= bytes.len() || bytes[open] != b'(' {
return None;
}
let mut depth = 1i32;
let mut i = open + 1;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => {
depth -= 1;
if depth == 0 {
return Some(i);
}
},
_ => {},
}
i += 1;
}
None
}
fn parse_create_table_columns(body: &str) -> Vec<Column> {
let mut out = Vec::new();
for raw_line in split_top_level_commas(body) {
let trimmed = raw_line.trim();
if trimmed.is_empty() {
continue;
}
let upper = trimmed.to_ascii_uppercase();
if upper.starts_with("PRIMARY KEY")
|| upper.starts_with("UNIQUE")
|| upper.starts_with("CHECK")
|| upper.starts_with("FOREIGN KEY")
|| upper.starts_with("CONSTRAINT")
|| upper.starts_with("LIKE")
|| upper.starts_with("EXCLUDE")
{
continue;
}
let (name, after_name) = match read_ident_simple(trimmed, 0) {
Some(t) => t,
None => continue,
};
let rest = trimmed[after_name..].trim();
if rest.is_empty() {
continue;
}
let stop_words: &[&str] = &[
"NOT NULL",
"NULL",
"DEFAULT",
"PRIMARY",
"UNIQUE",
"CHECK",
"REFERENCES",
"GENERATED",
"COLLATE",
"CONSTRAINT",
];
let upper_rest = rest.to_ascii_uppercase();
let mut cut = upper_rest.len();
for kw in stop_words {
if let Some(at) = find_word(&upper_rest, kw)
&& at < cut
{
cut = at;
}
}
let type_text = rest[..cut].trim().to_string();
if type_text.is_empty() {
continue;
}
let nullable = !upper_rest[..cut.min(upper_rest.len())].contains("NOT NULL") && !upper_rest.contains("PRIMARY KEY");
out.push(Column {
name,
data_type: type_text,
nullable,
default: None,
comment: None,
generated: None,
json_keys: None,
});
}
out
}
fn split_top_level_commas(body: &str) -> Vec<&str> {
let mut out = Vec::new();
let bytes = body.as_bytes();
let mut depth = 0i32;
let mut start = 0usize;
let mut i = 0usize;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
b',' if depth == 0 => {
out.push(&body[start..i]);
start = i + 1;
},
_ => {},
}
i += 1;
}
if start < bytes.len() {
out.push(&body[start..]);
}
out
}
fn find_word(haystack: &str, kw: &str) -> Option<usize> {
let mut from = 0;
while let Some(rel) = haystack[from..].find(kw) {
let at = from + rel;
let prev_ok = at == 0 || {
let p = haystack.as_bytes()[at - 1];
!(p.is_ascii_alphanumeric() || p == b'_')
};
let end = at + kw.len();
let next_ok = end == haystack.len() || {
let n = haystack.as_bytes()[end];
!(n.is_ascii_alphanumeric() || n == b'_')
};
if prev_ok && next_ok {
return Some(at);
}
from = at + kw.len();
}
None
}
fn inherit_partition_columns(cat: &mut Catalog, src: &str) {
let cleaned = strip_string_literals(src);
let upper = cleaned.to_ascii_uppercase();
let bytes = cleaned.as_bytes();
let n = bytes.len();
let needle = "CREATE TABLE";
let mut from = 0usize;
let mut pairs: Vec<(String, String)> = Vec::new();
while let Some(rel) = upper[from..].find(needle) {
let at = from + rel;
let mut k = at + needle.len();
while k < n && bytes[k].is_ascii_whitespace() {
k += 1
}
if starts_with_at(&upper, k, "IF NOT EXISTS") {
k += "IF NOT EXISTS".len();
while k < n && bytes[k].is_ascii_whitespace() {
k += 1
}
}
let id_start = k;
while k < n && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"') {
k += 1
}
let child = cleaned[id_start..k].trim_matches('"').to_string();
from = k;
while k < n && bytes[k].is_ascii_whitespace() {
k += 1
}
if !starts_with_at(&upper, k, "PARTITION OF") {
continue;
}
k += "PARTITION OF".len();
while k < n && bytes[k].is_ascii_whitespace() {
k += 1
}
let p_start = k;
while k < n && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"') {
k += 1
}
let parent = cleaned[p_start..k].trim_matches('"').to_string();
pairs.push((child, parent));
}
if pairs.is_empty() {
return;
}
for (child_fq, parent_fq) in pairs {
let p_bare = parent_fq.rsplit('.').next().unwrap_or(&parent_fq).to_string();
let c_bare = child_fq.rsplit('.').next().unwrap_or(&child_fq).to_string();
let parent_cols: Option<Vec<Column>> = cat
.schemas
.iter()
.flat_map(|s| s.tables.iter())
.find(|t| t.name.eq_ignore_ascii_case(&p_bare))
.map(|t| t.columns.clone());
let Some(cols) = parent_cols else { continue };
for schema in cat.schemas.iter_mut() {
for t in schema.tables.iter_mut() {
if t.name.eq_ignore_ascii_case(&c_bare) && t.columns.is_empty() {
t.columns = cols.clone();
}
}
}
}
}
fn strip_string_literals(s: &str) -> String {
let mut out: Vec<u8> = s.as_bytes().to_vec();
let n = out.len();
let mut i = 0usize;
while i < n {
if i + 1 < n && out[i] == b'-' && out[i + 1] == b'-' {
while i < n && out[i] != b'\n' {
out[i] = b' ';
i += 1
}
continue;
}
if out[i] == b'\'' {
out[i] = b' ';
i += 1;
while i < n && out[i] != b'\'' {
out[i] = b' ';
i += 1
}
if i < n {
out[i] = b' ';
i += 1
}
continue;
}
i += 1;
}
String::from_utf8(out).unwrap_or_else(|_| s.to_string())
}
fn scan_policies(src: &str) -> std::collections::HashMap<String, Vec<Policy>> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let mut out: std::collections::HashMap<String, Vec<Policy>> = std::collections::HashMap::new();
for needle in ["CREATE OR REPLACE POLICY ", "CREATE POLICY "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let name_start = k;
while k < bytes.len() && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'"') {
k += 1;
}
let name = src[name_start..k].trim_matches('"').to_string();
let stmt_end = src[after..].find(';').map(|i| after + i).unwrap_or(src.len());
let stmt = &src[after..stmt_end];
let stmt_upper = stmt.to_ascii_uppercase();
let tbl = if let Some(on_at) = stmt_upper.find(" ON ") {
let rest = &stmt[on_at + 4..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end =
raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_ascii_lowercase()
} else {
from = after;
continue;
};
let permissive = if stmt_upper.contains("RESTRICTIVE") { "RESTRICTIVE" } else { "PERMISSIVE" };
let command = ["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]
.iter()
.find(|c| stmt_upper.contains(&format!(" FOR {c}")))
.map(|s| s.to_string())
.unwrap_or_else(|| "ALL".into());
let roles = if let Some(to_at) = stmt_upper.find(" TO ") {
let rest = &stmt[to_at + 4..];
let end = rest.find([';', '\n']).unwrap_or(rest.len());
let raw = rest[..end].trim();
let raw_upper = raw.to_ascii_uppercase();
let cut = ["USING", "WITH CHECK"].iter().filter_map(|kw| raw_upper.find(kw)).min().unwrap_or(raw.len());
raw[..cut].trim().to_string()
} else {
"PUBLIC".into()
};
let using_expr = extract_paren_after(stmt, "USING");
let check_expr = extract_paren_after(stmt, "WITH CHECK");
out.entry(tbl).or_default().push(Policy {
name,
permissive: permissive.to_string(),
roles,
command,
using_expr,
check_expr,
});
from = after;
}
}
out
}
fn extract_paren_after(stmt: &str, kw: &str) -> Option<String> {
let upper = stmt.to_ascii_uppercase();
let at = upper.find(kw)?;
let after = at + kw.len();
let rest_bytes = stmt.as_bytes();
let mut k = after;
while k < rest_bytes.len() && rest_bytes[k].is_ascii_whitespace() {
k += 1;
}
if k >= rest_bytes.len() || rest_bytes[k] != b'(' {
return None;
}
let close = match_paren(rest_bytes, k);
if close >= rest_bytes.len() {
return None;
}
Some(stmt[k + 1..close].trim().to_string())
}
fn scan_table_comments(src: &str) -> std::collections::HashMap<String, String> {
let upper = src.to_ascii_uppercase();
let mut out = std::collections::HashMap::new();
let mut from = 0usize;
while let Some(rel) = upper[from..].find("COMMENT ON TABLE ") {
let after = from + rel + "COMMENT ON TABLE ".len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1;
}
let id = &src[id_start..k];
let bare = id.rsplit('.').next().unwrap_or(id).trim_matches('"').to_ascii_lowercase();
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k + 2 > bytes.len() || !starts_with_at(&upper, k, "IS") {
from = after;
continue;
}
k += 2;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k >= bytes.len() || bytes[k] != b'\'' {
from = after;
continue;
}
let s_start = k + 1;
let mut s_end = s_start;
while s_end < bytes.len() && bytes[s_end] != b'\'' {
s_end += 1;
}
if s_end >= bytes.len() {
break;
}
out.insert(bare, src[s_start..s_end].to_string());
from = s_end + 1;
}
out
}
fn scan_indexes(src: &str) -> std::collections::HashMap<String, Vec<IndexDef>> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let mut out: std::collections::HashMap<String, Vec<IndexDef>> = std::collections::HashMap::new();
for (needle, unique) in [
("CREATE UNIQUE INDEX IF NOT EXISTS ", true),
("CREATE UNIQUE INDEX ", true),
("CREATE INDEX IF NOT EXISTS ", false),
("CREATE INDEX ", false),
] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let name_start = k;
while k < bytes.len() && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'"') {
k += 1;
}
let name = src[name_start..k].trim_matches('"').to_string();
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if starts_with_at(&upper, k, "ON ") {
k += 3;
} else {
from = after;
continue;
}
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let tbl_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1;
}
let raw_tbl = &src[tbl_start..k];
let bare = raw_tbl.rsplit('.').next().unwrap_or(raw_tbl).trim_matches('"').to_ascii_lowercase();
while k < bytes.len() && bytes[k] != b'(' && bytes[k] != b';' {
k += 1;
}
let cols = if k < bytes.len() && bytes[k] == b'(' {
let end = match_paren(bytes, k);
let body = &src[k + 1..end];
split_top_commas(body)
.into_iter()
.map(|c| c.trim().trim_matches('"').to_string())
.filter(|c| !c.is_empty())
.collect()
} else {
Vec::new()
};
let stmt_end = src[name_start..].find(';').map(|i| name_start + i + 1).unwrap_or(src.len());
let definition = src[from + rel..stmt_end].trim().to_string();
out.entry(bare).or_default().push(IndexDef { name, columns: cols, unique, definition: Some(definition) });
from = after;
}
}
out
}
fn scan_triggers(src: &str) -> std::collections::HashMap<String, Vec<Trigger>> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let mut out: std::collections::HashMap<String, Vec<Trigger>> = std::collections::HashMap::new();
for needle in ["CREATE OR REPLACE TRIGGER ", "CREATE TRIGGER ", "CREATE CONSTRAINT TRIGGER "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let name_start = k;
while k < bytes.len() && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'"') {
k += 1;
}
let name = src[name_start..k].trim_matches('"').to_string();
let stmt_end = src[after..].find(';').map(|i| after + i).unwrap_or(src.len());
let stmt = &src[after..stmt_end];
let stmt_upper = stmt.to_ascii_uppercase();
let timing = if stmt_upper.contains("INSTEAD OF") {
"INSTEAD OF"
} else if stmt_upper.contains("BEFORE") {
"BEFORE"
} else if stmt_upper.contains("AFTER") {
"AFTER"
} else {
""
};
let mut events = Vec::new();
if stmt_upper.contains("INSERT") {
events.push("INSERT");
}
if stmt_upper.contains("UPDATE") {
events.push("UPDATE");
}
if stmt_upper.contains("DELETE") {
events.push("DELETE");
}
if stmt_upper.contains("TRUNCATE") {
events.push("TRUNCATE");
}
let event = events.join(" OR ");
let tbl = if let Some(on_at) = stmt_upper.find(" ON ") {
let after_on = on_at + 4;
let rest = &stmt[after_on..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end =
raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_ascii_lowercase()
} else {
String::new()
};
let granularity = if stmt_upper.contains("FOR EACH ROW") {
"ROW"
} else if stmt_upper.contains("FOR EACH STATEMENT") {
"STATEMENT"
} else {
"ROW"
};
let function =
if let Some(at) = stmt_upper.find("EXECUTE FUNCTION ").or_else(|| stmt_upper.find("EXECUTE PROCEDURE ")) {
let after_kw = at + "EXECUTE FUNCTION ".len();
let rest = &stmt[after_kw..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.').unwrap_or(raw.len());
raw[..id_end].to_string()
} else {
String::new()
};
if !tbl.is_empty() {
out.entry(tbl).or_default().push(Trigger {
name,
timing: timing.to_string(),
event,
granularity: granularity.to_string(),
function,
});
}
from = after;
}
}
out
}
fn scan_column_comments(src: &str) -> std::collections::HashMap<String, String> {
let upper = src.to_ascii_uppercase();
let mut out = std::collections::HashMap::new();
let mut from = 0usize;
while let Some(rel) = upper[from..].find("COMMENT ON COLUMN ") {
let after = from + rel + "COMMENT ON COLUMN ".len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1;
}
let id = &src[id_start..k];
let parts: Vec<&str> = id.split('.').map(|s| s.trim_matches('"')).collect();
if parts.len() < 2 {
from = after;
continue;
}
let tbl = parts[parts.len() - 2].to_ascii_lowercase();
let col = parts[parts.len() - 1].to_ascii_lowercase();
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k + 2 > bytes.len() || !starts_with_at(&upper, k, "IS") {
from = after;
continue;
}
k += 2;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k >= bytes.len() || bytes[k] != b'\'' {
from = after;
continue;
}
let s_start = k + 1;
let mut s_end = s_start;
while s_end < bytes.len() && bytes[s_end] != b'\'' {
s_end += 1;
}
if s_end >= bytes.len() {
break;
}
let text = src[s_start..s_end].to_string();
out.insert(format!("{tbl}.{col}"), text);
from = s_end + 1;
}
out
}
fn scan_generated_for(src: &str, name: &str) -> std::collections::HashMap<String, String> {
let upper = src.to_ascii_uppercase();
let mut out: std::collections::HashMap<String, String> = Default::default();
for needle in ["CREATE TABLE IF NOT EXISTS ", "CREATE TEMP TABLE ", "CREATE TEMPORARY TABLE ", "CREATE TABLE "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1
}
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"');
if !bare.eq_ignore_ascii_case(name) {
from = after;
continue;
}
while k < bytes.len() && bytes[k] != b'(' {
k += 1
}
if k >= bytes.len() {
return out;
}
let body_start = k + 1;
let body_end = match_paren(bytes, k);
let body = &src[body_start..body_end];
for line in split_top_level(body) {
let upper_line = line.to_ascii_uppercase();
let Some(g_at) = upper_line.find("GENERATED") else { continue };
let post = &line[g_at..];
let post_upper = post.to_ascii_uppercase();
if !post_upper.starts_with("GENERATED ALWAYS AS") {
continue;
}
let after_kw = g_at + "GENERATED ALWAYS AS".len();
let rest = line[after_kw..].trim_start();
if !rest.starts_with('(') {
continue;
}
let abs_open = after_kw + (line[after_kw..].len() - rest.len());
let Some(close_rel) = match_paren_offset(&line, abs_open) else { continue };
let expr = &line[abs_open + 1..close_rel];
let col_name = line.split_whitespace().next().unwrap_or("").trim_matches('"').to_ascii_lowercase();
if !col_name.is_empty() {
out.insert(col_name, expr.to_string());
}
}
return out;
}
}
out
}
fn scan_owner_for(src: &str, name: &str) -> Option<String> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let needle = "ALTER TABLE";
let mut from = 0usize;
let mut last: Option<String> = None;
while let Some(rel) = upper[from..].find(needle) {
let at = from + rel;
let mut k = at + needle.len();
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
if starts_with_at(&upper, k, "IF EXISTS") {
k += 9;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
}
if starts_with_at(&upper, k, "ONLY") {
k += 4;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1;
}
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"');
if !bare.eq_ignore_ascii_case(name) {
from = at + needle.len();
continue;
}
let after = upper[k..].trim_start();
if !after.starts_with("OWNER TO") {
from = k;
continue;
}
let skip = " OWNER TO ".len();
let owner_start_rel = upper[k..].find("OWNER TO")? + "OWNER TO".len();
let owner_start = k + owner_start_rel;
let mut j = owner_start;
while j < bytes.len() && bytes[j].is_ascii_whitespace() {
j += 1;
}
let id_start = j;
while j < bytes.len() && (bytes[j].is_ascii_alphanumeric() || bytes[j] == b'_' || bytes[j] == b'"') {
j += 1;
}
let role = src[id_start..j].trim_matches('"').to_string();
if !role.is_empty() {
last = Some(role);
}
let _ = skip;
from = j;
}
last
}
fn scan_defaults_for(src: &str, name: &str) -> std::collections::HashMap<String, String> {
let upper = src.to_ascii_uppercase();
let mut out: std::collections::HashMap<String, String> = Default::default();
for needle in ["CREATE TABLE IF NOT EXISTS ", "CREATE TEMP TABLE ", "CREATE TEMPORARY TABLE ", "CREATE TABLE "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1
}
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"');
if !bare.eq_ignore_ascii_case(name) {
from = after;
continue;
}
while k < bytes.len() && bytes[k] != b'(' {
k += 1
}
if k >= bytes.len() {
return out;
}
let body_start = k + 1;
let body_end = match_paren(bytes, k);
let body = &src[body_start..body_end];
for line in split_top_level(body) {
let upper_line = line.to_ascii_uppercase();
let head_upper = upper_line.split_whitespace().next().unwrap_or("");
if matches!(head_upper, "CONSTRAINT" | "PRIMARY" | "UNIQUE" | "FOREIGN" | "CHECK" | "EXCLUDE" | "LIKE") {
continue;
}
let line_bytes = line.as_bytes();
let mut depth = 0i32;
let mut def_at: Option<usize> = None;
let mut i = 0usize;
while i < line_bytes.len() {
match line_bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
b'\'' => {
i += 1;
while i < line_bytes.len() && line_bytes[i] != b'\'' {
i += 1;
}
},
_ => {},
}
if depth == 0
&& starts_with_at(&upper_line, i, "DEFAULT")
&& (i == 0 || !line_bytes[i - 1].is_ascii_alphanumeric() && line_bytes[i - 1] != b'_')
&& i + 7 < line_bytes.len()
&& line_bytes[i + 7].is_ascii_whitespace()
{
def_at = Some(i);
break;
}
i += 1;
}
let Some(def_at) = def_at else { continue };
let mut j = def_at + "DEFAULT".len();
while j < line_bytes.len() && line_bytes[j].is_ascii_whitespace() {
j += 1;
}
let mut depth = 0i32;
let expr_start = j;
let mut expr_end = line_bytes.len();
while j < line_bytes.len() {
match line_bytes[j] {
b'(' => depth += 1,
b')' => depth -= 1,
b'\'' => {
j += 1;
while j < line_bytes.len() && line_bytes[j] != b'\'' {
j += 1;
}
},
_ => {},
}
if depth == 0
&& (line_bytes[j] == b','
|| [" NOT NULL", " CHECK", " REFERENCES", " UNIQUE", " PRIMARY KEY", " GENERATED", " COLLATE"]
.iter()
.any(|kw| starts_with_at(&upper_line, j, kw)))
{
expr_end = j;
break;
}
j += 1;
}
let expr = line[expr_start..expr_end].trim().to_string();
let col_name = line.split_whitespace().next().unwrap_or("").trim_matches('"').to_ascii_lowercase();
if !col_name.is_empty() && !expr.is_empty() {
out.insert(col_name, expr);
}
}
return out;
}
}
out
}
fn scan_json_keys_for(src: &str, name: &str) -> std::collections::HashMap<String, Vec<String>> {
let upper = src.to_ascii_uppercase();
let mut out: std::collections::HashMap<String, Vec<String>> = Default::default();
for needle in ["CREATE TABLE IF NOT EXISTS ", "CREATE TEMP TABLE ", "CREATE TEMPORARY TABLE ", "CREATE TABLE "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1
}
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"');
if !bare.eq_ignore_ascii_case(name) {
from = after;
continue;
}
while k < bytes.len() && bytes[k] != b'(' {
k += 1
}
if k >= bytes.len() {
return out;
}
let body_start = k + 1;
let body_end = match_paren(bytes, k);
let body = &src[body_start..body_end];
let mut pending: Option<Vec<String>> = None;
let mut paren_depth = 0i32;
for line in body.lines() {
let trimmed = line.trim();
if let Some(at) = trimmed.find("@json-keys:") {
let payload = &trimmed[at + "@json-keys:".len()..];
let keys: Vec<String> =
payload.split(',').map(|s| s.trim().trim_matches('"').to_string()).filter(|s| !s.is_empty()).collect();
if !keys.is_empty() {
pending = Some(keys);
}
continue;
}
if trimmed.is_empty() || trimmed.starts_with("--") {
continue;
}
let entered_at = paren_depth;
for b in trimmed.as_bytes() {
match b {
b'(' => paren_depth += 1,
b')' => paren_depth -= 1,
_ => {},
}
}
if entered_at != 0 {
continue;
}
let Some(keys) = pending.take() else { continue };
let head = trimmed.split_whitespace().next().unwrap_or("");
let head_upper = head.to_ascii_uppercase();
if matches!(head_upper.as_str(), "CONSTRAINT" | "PRIMARY" | "UNIQUE" | "FOREIGN" | "CHECK" | "EXCLUDE" | "LIKE")
{
continue;
}
let col_name = head.trim_matches('"').trim_end_matches(',').to_ascii_lowercase();
if !col_name.is_empty() {
out.insert(col_name, keys);
}
}
return out;
}
}
out
}
fn split_top_level(text: &str) -> Vec<String> {
let mut out = Vec::new();
let bytes = text.as_bytes();
let mut depth = 0i32;
let mut start = 0usize;
let mut i = 0usize;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
b',' if depth == 0 => {
out.push(text[start..i].trim().to_string());
start = i + 1;
},
b'\'' => {
i += 1;
while i < bytes.len() && bytes[i] != b'\'' {
i += 1
}
},
_ => {},
}
i += 1;
}
out.push(text[start..].trim().to_string());
out
}
fn match_paren_offset(s: &str, open: usize) -> Option<usize> {
let bytes = s.as_bytes();
let mut depth = 0i32;
let mut i = open;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => {
depth -= 1;
if depth == 0 {
return Some(i);
}
},
b'\'' => {
i += 1;
while i < bytes.len() && bytes[i] != b'\'' {
i += 1
}
},
_ => {},
}
i += 1;
}
None
}
fn scan_constraints_for(src: &str, name: &str) -> Vec<Constraint> {
let upper = src.to_ascii_uppercase();
let mut out: Vec<Constraint> = Vec::new();
for needle in ["CREATE TABLE IF NOT EXISTS ", "CREATE TEMP TABLE ", "CREATE TEMPORARY TABLE ", "CREATE TABLE "] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let after = from + rel + needle.len();
let bytes = src.as_bytes();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let id_start = k;
while k < bytes.len()
&& (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"')
{
k += 1;
}
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"');
if !bare.eq_ignore_ascii_case(name) {
from = after;
continue;
}
while k < bytes.len() && bytes[k] != b'(' {
k += 1;
}
if k >= bytes.len() {
return out;
}
let body_start = k + 1;
let body_end = match_paren(bytes, k);
let body = &src[body_start..body_end];
out.extend(parse_constraints(body));
return out;
}
}
out
}
fn match_paren(bytes: &[u8], open: usize) -> usize {
let n = bytes.len();
let mut depth = 0i32;
let mut i = open;
while i < n {
match bytes[i] {
b'(' => depth += 1,
b')' => {
depth -= 1;
if depth == 0 {
return i;
}
},
b'\'' => {
i += 1;
while i < n && bytes[i] != b'\'' {
i += 1;
}
},
_ => {},
}
i += 1;
}
n
}
fn parse_constraints(body: &str) -> Vec<Constraint> {
let mut out = Vec::new();
for entry in split_top_commas(body) {
let mut entry = entry;
loop {
let t = entry.trim_start_matches(['\n', '\r', ' ', '\t']);
if let Some(rest) = t.strip_prefix("--") {
let end = rest.find('\n').map(|i| i + 1).unwrap_or(rest.len());
entry = &rest[end..];
continue;
}
if t.starts_with("/*")
&& let Some(close) = t.find("*/")
{
entry = &t[close + 2..];
continue;
}
entry = t;
break;
}
let trimmed = entry.trim();
if trimmed.is_empty() {
continue;
}
let upper = trimmed.to_ascii_uppercase();
if upper.starts_with("PRIMARY KEY") {
if let Some(cols) = paren_csv(trimmed) {
out.push(Constraint {
name: "pk".into(),
kind: ConstraintKind::PrimaryKey,
columns: cols,
references: None,
definition: Some(trimmed.to_string()),
inline: false,
});
}
continue;
}
if upper.starts_with("UNIQUE") {
if let Some(cols) = paren_csv(trimmed) {
out.push(Constraint {
name: "uniq".into(),
kind: ConstraintKind::Unique,
columns: cols,
references: None,
definition: Some(trimmed.to_string()),
inline: false,
});
}
continue;
}
if upper.starts_with("FOREIGN KEY") {
if let (Some(local), Some(refs)) = (paren_csv(trimmed), parse_references(trimmed)) {
out.push(Constraint {
name: "fk".into(),
kind: ConstraintKind::ForeignKey,
columns: local,
references: Some(refs),
definition: Some(trimmed.to_string()),
inline: false,
});
}
continue;
}
if upper.starts_with("CHECK") {
out.push(Constraint {
name: "ck".into(),
kind: ConstraintKind::Check,
columns: Vec::new(),
references: None,
definition: Some(trimmed.to_string()),
inline: false,
});
continue;
}
if upper.starts_with("CONSTRAINT") {
let rest = trimmed[10..].trim_start();
let name_end = rest.find(char::is_whitespace).unwrap_or(rest.len());
let cname = rest[..name_end].trim_matches('"').to_string();
let body = rest[name_end..].trim_start();
let body_upper = body.to_ascii_uppercase();
if body_upper.starts_with("PRIMARY KEY") {
out.push(Constraint {
name: cname,
kind: ConstraintKind::PrimaryKey,
columns: paren_csv(body).unwrap_or_default(),
references: None,
definition: Some(body.to_string()),
inline: false,
});
} else if body_upper.starts_with("UNIQUE") {
out.push(Constraint {
name: cname,
kind: ConstraintKind::Unique,
columns: paren_csv(body).unwrap_or_default(),
references: None,
definition: Some(body.to_string()),
inline: false,
});
} else if body_upper.starts_with("FOREIGN KEY") {
out.push(Constraint {
name: cname,
kind: ConstraintKind::ForeignKey,
columns: paren_csv(body).unwrap_or_default(),
references: parse_references(body),
definition: Some(body.to_string()),
inline: false,
});
} else if body_upper.starts_with("CHECK") {
out.push(Constraint {
name: cname,
kind: ConstraintKind::Check,
columns: Vec::new(),
references: None,
definition: Some(body.to_string()),
inline: false,
});
}
continue;
}
let col = unquote_ident(trimmed.split_whitespace().next().unwrap_or("")).to_string();
if col.is_empty() {
continue;
}
if upper.contains(" PRIMARY KEY") || upper.contains("\tPRIMARY KEY") {
out.push(Constraint {
name: format!("pk_{col}"),
kind: ConstraintKind::PrimaryKey,
columns: vec![col.clone()],
references: None,
definition: Some(format!("PRIMARY KEY ({col})")),
inline: true,
});
}
if upper.contains("UNIQUE") && !upper.starts_with("UNIQUE") {
out.push(Constraint {
name: format!("uniq_{col}"),
kind: ConstraintKind::Unique,
columns: vec![col.clone()],
references: None,
definition: Some(format!("UNIQUE ({col})")),
inline: true,
});
}
if let Some(refs) = inline_references(trimmed) {
let def = format!("FOREIGN KEY ({col}) REFERENCES {}.{} ({})", refs.schema, refs.table, refs.columns.join(", "));
out.push(Constraint {
name: format!("fk_{col}"),
kind: ConstraintKind::ForeignKey,
columns: vec![col],
references: Some(refs),
definition: Some(def),
inline: true,
});
}
}
out
}
fn paren_csv(s: &str) -> Option<Vec<String>> {
let open = s.find('(')?;
let close = match_paren(s.as_bytes(), open);
if close >= s.len() {
return None;
}
Some(
s.get(open + 1..close)?.split(',').map(|c| unquote_ident(c.trim()).to_string()).filter(|c| !c.is_empty()).collect(),
)
}
fn parse_references(s: &str) -> Option<ConstraintRef> {
let upper = s.to_ascii_uppercase();
let at = upper.find("REFERENCES")?;
let rest = s[at + "REFERENCES".len()..].trim_start();
let name_end = rest
.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"' && c != '[' && c != ']' && c != '`')
.unwrap_or(rest.len());
let raw = rest.get(..name_end).unwrap_or("");
let unquoted = unquote_ident(raw);
let dot = if unquoted == raw { raw.find('.') } else { None };
let (schema, table) = match dot {
Some(at) => (unquote_ident(&raw[..at]).to_string(), unquote_ident(&raw[at + 1..]).to_string()),
None => ("public".into(), unquoted.to_string()),
};
let cols = paren_csv(&rest[name_end..]).unwrap_or_default();
Some(ConstraintRef { schema, table, columns: cols })
}
fn inline_references(s: &str) -> Option<ConstraintRef> {
if !s.to_ascii_uppercase().contains("REFERENCES") {
return None;
}
parse_references(s)
}
pub fn default_offline_roles() -> Vec<String> {
vec![
"postgres".into(),
"pg_read_all_data".into(),
"pg_write_all_data".into(),
"pg_monitor".into(),
"pg_signal_backend".into(),
]
}
fn scan_sequences(src: &str) -> Vec<Sequence> {
scan_create_named(src, &["CREATE SEQUENCE "])
.into_iter()
.map(|name| Sequence {
schema: "public".into(),
name,
data_type: "bigint".into(),
start_value: 1,
min_value: 1,
max_value: i64::MAX,
increment_by: 1,
cycle: false,
owned_by_column: None,
comment: Some("defined in current buffer".into()),
})
.collect()
}
fn scan_extensions(src: &str) -> Vec<Extension> {
let mut out = Vec::new();
for name in scan_create_named(src, &["CREATE EXTENSION IF NOT EXISTS ", "CREATE EXTENSION "]) {
out.push(Extension {
name: name.trim_matches('"').to_string(),
schema: "public".into(),
version: "?".into(),
comment: Some("declared in current buffer".into()),
});
}
out
}
fn scan_types(src: &str) -> Vec<Type> {
let mut out = Vec::new();
let upper = src.to_ascii_uppercase();
for (prefix, kind) in [("CREATE TYPE ", TypeKind::Composite), ("CREATE DOMAIN ", TypeKind::Domain)] {
for name in scan_create_named_with_upper(src, &upper, prefix) {
let resolved_kind = if name_followed_by_as_enum(src, &upper, prefix, &name) { TypeKind::Enum } else { kind };
out.push(Type { schema: "public".into(), name, kind: resolved_kind });
}
}
out
}
fn name_followed_by_as_enum(src: &str, upper: &str, prefix: &str, name: &str) -> bool {
let needle = format!("{prefix}{name}");
let needle_upper = needle.to_ascii_uppercase();
let Some(rel) = upper.find(&needle_upper) else {
return false;
};
let after = rel + needle.len();
let tail = src[after..].trim_start();
tail.to_ascii_uppercase().starts_with("AS ENUM")
}
fn extract_arguments(src: &str, name_end: usize) -> Vec<FunctionArg> {
let bytes = src.as_bytes();
let n = bytes.len();
let mut i = name_end;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i >= n || bytes[i] != b'(' {
return Vec::new();
}
let Some(close) = match_paren_opt(bytes, i) else { return Vec::new() };
let body = &src[i + 1..close];
if body.trim().is_empty() {
return Vec::new();
}
let mut out = Vec::new();
for raw in split_top_level_commas(body) {
let trimmed = raw.trim();
if trimmed.is_empty() {
continue;
}
let mut rest = trimmed;
let upper = rest.to_ascii_uppercase();
for mode in ["VARIADIC ", "INOUT ", "IN ", "OUT "] {
if upper.starts_with(mode) {
rest = rest[mode.len()..].trim_start();
break;
}
}
let (name, ty) = match rest.find(char::is_whitespace) {
Some(at) => {
let head = &rest[..at];
let tail = rest[at..].trim();
if tail.is_empty() { (None, head.to_string()) } else { (Some(head.to_string()), tail.to_string()) }
},
None => (None, rest.to_string()),
};
let data_type = if ty.is_empty() { "?".to_string() } else { ty };
out.push(FunctionArg { name, data_type });
}
out
}
fn extract_returns(ddl: &str) -> String {
let upper = ddl.to_ascii_uppercase();
let Some(at) = upper.find(" RETURNS ") else { return "?".into() };
let after = at + 9;
let rest = &ddl[after..];
let stop = rest
.find('\n')
.or_else(|| {
let u = rest.to_ascii_uppercase();
u.find(" AS ").or_else(|| u.find(" LANGUAGE "))
})
.unwrap_or(rest.len());
let raw = rest[..stop].trim();
let bare = raw.split_whitespace().next().unwrap_or(raw).trim_end_matches(',');
if bare.is_empty() { "?".into() } else { bare.to_string() }
}
fn scan_functions(src: &str) -> Vec<Function> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let mut out = Vec::new();
for prefix in [
"CREATE OR REPLACE FUNCTION ",
"CREATE FUNCTION ",
"CREATE PROCEDURE ",
"CREATE OR REPLACE PROCEDURE ",
"CREATE AGGREGATE ",
"CREATE OR REPLACE AGGREGATE ",
] {
let mut from = 0usize;
while let Some(rel) = upper[from..].find(prefix) {
let stmt_start = from + rel;
let after = stmt_start + prefix.len();
let mut k = after;
while k < bytes.len() && bytes[k].is_ascii_whitespace() {
k += 1;
}
let name_start = k;
while k < bytes.len() && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.') {
k += 1;
}
if k == name_start {
from = after;
continue;
}
let raw = &src[name_start..k];
let (schema, bare) = match raw.rsplit_once('.') {
Some((s, n)) => (s.trim_matches('"').to_ascii_lowercase(), n.trim_matches('"').to_string()),
None => ("public".into(), raw.to_string()),
};
let stmt_end = find_function_end(src, k);
let full_ddl = src[stmt_start..stmt_end].trim().to_string();
let return_type = extract_returns(&full_ddl);
let arguments = extract_arguments(src, k);
out.push(Function {
schema,
name: bare,
arguments,
return_type,
comment: Some(full_ddl),
});
from = after;
}
}
out
}
fn find_function_end(src: &str, start: usize) -> usize {
let bytes = src.as_bytes();
let n = bytes.len();
let mut i = start;
let mut in_dollar: Option<String> = None;
while i < n {
if let Some(tag) = &in_dollar {
if i + tag.len() <= n && src.as_bytes()[i..i + tag.len()] == *tag.as_bytes() {
i += tag.len();
in_dollar = None;
continue;
}
i += 1;
continue;
}
let c = bytes[i];
if c == b'$' {
let mut j = i + 1;
while j < n && (bytes[j].is_ascii_alphanumeric() || bytes[j] == b'_') {
j += 1;
}
if j < n && bytes[j] == b'$' {
in_dollar = Some(src[i..=j].to_string());
i = j + 1;
continue;
}
}
if c == b';' {
return i + 1;
}
if c == b'\'' {
i += 1;
while i < n && bytes[i] != b'\'' {
i += 1;
}
i = (i + 1).min(n);
continue;
}
i += 1;
}
n
}
fn scan_dml_row_deltas(src: &str) -> std::collections::HashMap<String, i64> {
let mut events: Vec<(usize, String, Event)> = Vec::new();
for (pos, name, n) in scan_insert_inserts(src) {
events.push((pos, name.to_ascii_lowercase(), Event::Insert(n)));
}
for (pos, name, kind) in scan_clears(src) {
events.push((pos, name.to_ascii_lowercase(), Event::Clear(kind)));
}
events.sort_by_key(|(p, _, _)| *p);
let mut out: std::collections::HashMap<String, i64> = Default::default();
for (_, key, e) in events {
match e {
Event::Insert(n) => {
*out.entry(key).or_insert(0) += n;
},
Event::Clear(ClearKind::Truncate | ClearKind::DeleteAll) => {
out.insert(key, 0);
},
Event::Clear(ClearKind::DeleteWhere) => {
let entry = out.entry(key).or_insert(0);
*entry = (*entry - 1).max(0);
},
}
}
out
}
enum Event {
Insert(i64),
Clear(ClearKind),
}
enum ClearKind {
Truncate,
DeleteAll,
DeleteWhere,
}
fn scan_clears(src: &str) -> Vec<(usize, String, ClearKind)> {
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let n = bytes.len();
let mut out = Vec::new();
let mut from = 0usize;
while let Some(rel) = upper[from..].find("TRUNCATE") {
let at = from + rel;
let prev_ok = at == 0 || !is_word_char(bytes[at - 1]);
if !prev_ok {
from = at + 8;
continue;
}
let mut i = at + "TRUNCATE".len();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if starts_with_at(&upper, i, "TABLE") && i + 5 < n && bytes[i + 5].is_ascii_whitespace() {
i += 5;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
loop {
if starts_with_at(&upper, i, "ONLY") && i + 4 < n && bytes[i + 4].is_ascii_whitespace() {
i += 4;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
let id_start = i;
while i < n && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' || bytes[i] == b'.' || bytes[i] == b'"') {
i += 1;
}
if i > id_start {
let raw = &src[id_start..i];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_string();
if !bare.is_empty() {
out.push((at, bare, ClearKind::Truncate));
}
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b',' {
i += 1;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
continue;
}
break;
}
from = i.max(at + 8);
}
let mut from = 0usize;
while let Some(rel) = upper[from..].find("DELETE") {
let at = from + rel;
let prev_ok = at == 0 || !is_word_char(bytes[at - 1]);
if !prev_ok {
from = at + 6;
continue;
}
let mut i = at + "DELETE".len();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !starts_with_at(&upper, i, "FROM") {
from = at + 6;
continue;
}
i += "FROM".len();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if starts_with_at(&upper, i, "ONLY") && i + 4 < n && bytes[i + 4].is_ascii_whitespace() {
i += 4;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
let id_start = i;
while i < n && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' || bytes[i] == b'.' || bytes[i] == b'"') {
i += 1;
}
if i == id_start {
from = at + 6;
continue;
}
let raw = &src[id_start..i];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_string();
let stmt_end = src[i..].find(';').map(|p| i + p).unwrap_or(n);
let stmt_tail_upper = upper[i..stmt_end].to_string();
let has_where = stmt_tail_upper.split(|c: char| !c.is_ascii_alphanumeric() && c != '_').any(|w| w == "WHERE");
if !bare.is_empty() {
out.push((at, bare, if has_where { ClearKind::DeleteWhere } else { ClearKind::DeleteAll }));
}
from = stmt_end.max(at + 6);
}
out
}
fn scan_insert_inserts(src: &str) -> Vec<(usize, String, i64)> {
let mut out = Vec::new();
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let n = bytes.len();
let needle = "INSERT INTO";
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let at = from + rel;
let prev_ok = at == 0 || !is_word_char(bytes[at - 1]);
if !prev_ok {
from = at + needle.len();
continue;
}
let mut i = at + needle.len();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if starts_with_at(&upper, i, "ONLY") && i + 4 < n && bytes[i + 4].is_ascii_whitespace() {
i += 4;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
let id_start = i;
while i < n && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' || bytes[i] == b'.' || bytes[i] == b'"') {
i += 1;
}
if i == id_start {
from = at + needle.len();
continue;
}
let raw = &src[id_start..i];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_ascii_lowercase();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b'(' {
if let Some(close) = match_paren_opt(bytes, i) {
i = close + 1;
} else {
from = i;
continue;
}
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
let stmt_end = src[i..].find(';').map(|p| i + p).unwrap_or(n);
if starts_with_at(&upper, i, "VALUES") {
i += "VALUES".len();
let mut tuples = 0i64;
loop {
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i >= n || bytes[i] != b'(' {
break;
}
let Some(close) = match_paren_opt(bytes, i) else { break };
tuples += 1;
i = close + 1;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b',' {
i += 1;
} else {
break;
}
}
if !bare.is_empty() && tuples > 0 {
out.push((at, bare, tuples));
}
from = i.max(at + needle.len());
continue;
}
if upper[i..stmt_end].contains("SELECT") {
if let Some(rows) = generate_series_literal_count(&src[i..stmt_end])
&& !bare.is_empty()
{
out.push((at, bare, rows));
}
}
from = stmt_end.max(at + needle.len());
}
out
}
fn generate_series_literal_count(chunk: &str) -> Option<i64> {
let upper = chunk.to_ascii_uppercase();
let at = upper.find("GENERATE_SERIES")?;
let after = chunk[at + "GENERATE_SERIES".len()..].trim_start();
let after = after.strip_prefix('(')?;
let mut depth = 1i32;
let mut end = 0usize;
for (k, b) in after.bytes().enumerate() {
match b {
b'(' => depth += 1,
b')' => {
depth -= 1;
if depth == 0 {
end = k;
break;
}
},
_ => {},
}
}
if depth != 0 {
return None;
}
let args: Vec<&str> = after[..end].split(',').map(|s| s.trim()).collect();
if args.len() < 2 {
return None;
}
let a: i64 = args[0].parse().ok()?;
let b: i64 = args[1].parse().ok()?;
let step: i64 = if args.len() >= 3 { args[2].parse().ok().unwrap_or(1) } else { 1 };
if step == 0 {
return None;
}
if (a < b && step < 0) || (a > b && step > 0) {
return Some(0);
}
Some(((b - a) / step).abs() + 1)
}
#[allow(dead_code)]
fn scan_insert_tuple_counts(src: &str) -> std::collections::HashMap<String, usize> {
let mut out: std::collections::HashMap<String, usize> = Default::default();
let upper = src.to_ascii_uppercase();
let bytes = src.as_bytes();
let n = bytes.len();
let needle = "INSERT INTO";
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let at = from + rel;
let prev_ok = at == 0 || !is_word_char(bytes[at - 1]);
if !prev_ok {
from = at + needle.len();
continue;
}
let mut i = at + needle.len();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if starts_with_at(&upper, i, "ONLY") && i + 4 < n && (bytes[i + 4] as char).is_whitespace() {
i += 4;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
let id_start = i;
while i < n && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_' || bytes[i] == b'.' || bytes[i] == b'"') {
i += 1;
}
if i == id_start {
from = at + needle.len();
continue;
}
let raw = &src[id_start..i];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_ascii_lowercase();
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b'(' {
if let Some(close) = match_paren_opt(bytes, i) {
i = close + 1;
} else {
from = i;
continue;
}
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !starts_with_at(&upper, i, "VALUES") {
from = i;
continue;
}
i += "VALUES".len();
let mut tuples = 0usize;
loop {
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i >= n || bytes[i] != b'(' {
break;
}
let Some(close) = match_paren_opt(bytes, i) else { break };
tuples += 1;
i = close + 1;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b',' {
i += 1;
} else {
break;
}
}
if !bare.is_empty() && tuples > 0 {
*out.entry(bare).or_insert(0) += tuples;
}
from = i.max(at + needle.len());
}
out
}
fn match_paren_opt(bytes: &[u8], open: usize) -> Option<usize> {
let mut depth = 0i32;
let mut i = open;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => {
depth -= 1;
if depth == 0 {
return Some(i);
}
},
b'\'' => {
i += 1;
while i < bytes.len() && bytes[i] != b'\'' {
i += 1;
}
},
_ => {},
}
i += 1;
}
None
}
fn is_word_char(b: u8) -> bool {
b.is_ascii_alphanumeric() || b == b'_'
}
fn scan_roles(src: &str) -> Vec<String> {
let mut out: std::collections::BTreeSet<String> = default_offline_roles().into_iter().collect();
for prefix in ["CREATE ROLE ", "CREATE USER ", "CREATE GROUP "] {
for name in scan_create_named(src, &[prefix]) {
out.insert(name);
}
}
out.into_iter().collect()
}
fn scan_create_named(src: &str, prefixes: &[&str]) -> Vec<String> {
let upper = src.to_ascii_uppercase();
let mut out = Vec::new();
for prefix in prefixes {
out.extend(scan_create_named_with_upper(src, &upper, prefix));
}
out.sort();
out.dedup();
out
}
fn scan_create_named_with_upper(src: &str, upper: &str, prefix: &str) -> Vec<String> {
let bytes = src.as_bytes();
let n = bytes.len();
let mut out = Vec::new();
let mut from = 0usize;
while let Some(rel) = upper[from..].find(prefix) {
let after = from + rel + prefix.len();
let mut k = after;
while k < n && bytes[k].is_ascii_whitespace() {
k += 1;
}
let id_start = k;
while k < n && (bytes[k].is_ascii_alphanumeric() || bytes[k] == b'_' || bytes[k] == b'.' || bytes[k] == b'"') {
k += 1;
}
if k > id_start {
let raw = &src[id_start..k];
let bare = raw.rsplit('.').next().unwrap_or(raw).trim_matches('"').to_string();
if !bare.is_empty() {
out.push(bare);
}
}
from = after;
}
out
}
pub fn buffer_column_names(source: &str, table: &str) -> Vec<String> {
let upper_target = table.to_ascii_uppercase();
let mut from = 0usize;
let upper = source.to_ascii_uppercase();
while let Some(rel) = upper[from..].find("CREATE TABLE") {
let start = from + rel;
let after = start + "CREATE TABLE".len();
let mut rest_start = after;
let after_str = &source[rest_start..];
let trim_lead = after_str.len() - after_str.trim_start().len();
rest_start += trim_lead;
if starts_with_at(&upper, rest_start, "IF NOT EXISTS") {
rest_start += "IF NOT EXISTS".len();
let after2 = &source[rest_start..];
rest_start += after2.len() - after2.trim_start().len();
}
let name: String =
source[rest_start..].chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
let name_only = name.rsplit('.').next().unwrap_or(&name);
if !name_only.eq_ignore_ascii_case(table) && !name.to_ascii_uppercase().contains(&upper_target) {
from = after;
continue;
}
let body_open = source[rest_start + name.len()..].find('(');
let Some(rel_open) = body_open else {
from = after;
continue;
};
let open = rest_start + name.len() + rel_open + 1;
let bytes = source.as_bytes();
let n = bytes.len();
let mut depth = 1i32;
let mut i = open;
let close;
loop {
if i >= n {
close = n;
break;
}
match bytes[i] {
b'\'' => {
i += 1;
while i < n {
if bytes[i] == b'\'' {
i += 1;
break;
}
i += 1;
}
},
b'(' => {
depth += 1;
i += 1;
},
b')' => {
depth -= 1;
i += 1;
if depth == 0 {
close = i - 1;
break;
}
},
_ => i += 1,
}
}
let body = &source[open..close.min(n)];
return harvest_names(body);
}
Vec::new()
}
fn harvest_names(body: &str) -> Vec<String> {
let mut out = Vec::new();
for raw in split_top_commas(body) {
let trimmed = raw.trim();
if trimmed.is_empty() {
continue;
}
let head_upper = trimmed.to_ascii_uppercase();
let first = head_upper.split_ascii_whitespace().next().unwrap_or("");
if matches!(first, "CONSTRAINT" | "PRIMARY" | "FOREIGN" | "UNIQUE" | "CHECK" | "EXCLUDE" | "LIKE") {
continue;
}
let name: String = trimmed.chars().take_while(|c| c.is_alphanumeric() || *c == '_').collect();
if !name.is_empty() && !out.contains(&name) {
out.push(name);
}
}
out
}
fn split_top_commas(s: &str) -> Vec<&str> {
let bytes = s.as_bytes();
let n = bytes.len();
let mut depth = 0i32;
let mut last = 0usize;
let mut out = Vec::new();
let mut i = 0usize;
while i < n {
match bytes[i] {
b'\'' => {
i += 1;
while i < n {
if bytes[i] == b'\'' {
i += 1;
break;
}
i += 1;
}
},
b'(' => {
depth += 1;
i += 1;
},
b')' => {
depth -= 1;
i += 1;
},
b',' if depth == 0 => {
out.push(&s[last..i]);
last = i + 1;
i += 1;
},
_ => i += 1,
}
}
out.push(&s[last..]);
out
}
pub fn merge(live: &Catalog, derived: &Catalog) -> Catalog {
let mut out = live.clone();
for ds in &derived.schemas {
let target = match out.schemas.iter_mut().find(|s| s.name.eq_ignore_ascii_case(&ds.name)) {
Some(s) => s,
None => {
out.schemas.push(Schema { name: ds.name.clone(), tables: Vec::new() });
out.schemas.last_mut().unwrap()
},
};
for dt in &ds.tables {
if !target.tables.iter().any(|t| t.name.eq_ignore_ascii_case(&dt.name)) {
target.tables.push(dt.clone());
}
}
}
for s in &derived.sequences {
if !out.sequences.iter().any(|x| x.name.eq_ignore_ascii_case(&s.name)) {
out.sequences.push(s.clone());
}
}
for t in &derived.types {
if !out.types.iter().any(|x| x.name.eq_ignore_ascii_case(&t.name)) {
out.types.push(t.clone());
}
}
for e in &derived.extensions {
if !out.extensions.iter().any(|x| x.name.eq_ignore_ascii_case(&e.name)) {
out.extensions.push(e.clone());
}
}
for f in &derived.functions {
if !out.functions.iter().any(|x| x.name.eq_ignore_ascii_case(&f.name)) {
out.functions.push(f.clone());
}
}
for r in &derived.roles {
if !out.roles.iter().any(|x| x.eq_ignore_ascii_case(r)) {
out.roles.push(r.clone());
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use dsl_parse::Dialect;
#[test]
fn json_keys_annotation_populates_column() {
let src = "CREATE TABLE event (\n id int,\n -- @json-keys: name, age, tier\n payload jsonb\n);\n";
let parsed = dsl_parse::parse(src, Dialect::Postgres);
let cat = from_source(&parsed, src);
let tbl = cat.schemas.iter().flat_map(|s| s.tables.iter()).find(|t| t.name == "event").expect("event table");
let payload = tbl.columns.iter().find(|c| c.name == "payload").expect("payload col");
assert_eq!(payload.json_keys.as_deref(), Some(&["name".to_string(), "age".to_string(), "tier".to_string()][..]));
let id = tbl.columns.iter().find(|c| c.name == "id").expect("id col");
assert!(id.json_keys.is_none());
}
#[test]
fn json_keys_annotation_quoted_keys() {
let src = "CREATE TABLE t (\n -- @json-keys: \"a-b\", c\n data jsonb\n);\n";
let parsed = dsl_parse::parse(src, Dialect::Postgres);
let cat = from_source(&parsed, src);
let tbl = cat.schemas.iter().flat_map(|s| s.tables.iter()).find(|t| t.name == "t").unwrap();
let col = tbl.columns.iter().find(|c| c.name == "data").unwrap();
assert_eq!(col.json_keys.as_deref(), Some(&["a-b".to_string(), "c".to_string()][..]));
}
#[test]
fn scan_views_basic_and_modifiers() {
let src = "\
CREATE VIEW active_users AS SELECT * FROM users WHERE active;\n\
CREATE OR REPLACE MATERIALIZED VIEW reporting.daily (d, total) AS\n\
SELECT day, sum(amount) FROM sales GROUP BY day;\n";
let views = scan_views(src);
assert_eq!(views.len(), 2);
let (schema, name, kind, cols, def) = &views[0];
assert_eq!(schema, "public");
assert_eq!(name, "active_users");
assert_eq!(*kind, TableKind::View);
assert!(cols.is_empty());
assert_eq!(def, "SELECT * FROM users WHERE active");
let (schema, name, kind, cols, def) = &views[1];
assert_eq!(schema, "reporting");
assert_eq!(name, "daily");
assert_eq!(*kind, TableKind::MaterializedView);
assert_eq!(cols, &vec!["d".to_string(), "total".to_string()]);
assert!(def.starts_with("SELECT day, sum(amount)"));
assert!(!def.contains(';'));
}
#[test]
fn from_source_surfaces_view_definition() {
let src = "CREATE VIEW v AS SELECT id, name FROM t WHERE id > 0;";
let parsed = dsl_parse::parse(src, Dialect::Postgres);
let cat = from_source(&parsed, src);
let view = cat.schemas.iter().flat_map(|s| s.tables.iter()).find(|t| t.name == "v").expect("view v");
assert_eq!(view.kind, TableKind::View);
assert_eq!(view.definition.as_deref(), Some("SELECT id, name FROM t WHERE id > 0"));
}
#[test]
fn scan_views_ignores_create_table() {
assert!(scan_views("CREATE TABLE t (id int);").is_empty());
}
#[test]
fn unquote_ident_handles_every_dialects_quoting() {
assert_eq!(unquote_ident("plain"), "plain");
assert_eq!(unquote_ident("\"quoted\""), "quoted");
assert_eq!(unquote_ident("[bracketed]"), "bracketed");
assert_eq!(unquote_ident("`backticked`"), "backticked");
assert_eq!(unquote_ident("[half"), "[half");
assert_eq!(unquote_ident("\"a\" = \"b\""), "\"a\" = \"b\"");
assert_eq!(unquote_ident(""), "");
assert_eq!(unquote_ident("\""), "\"");
}
#[test]
fn bracket_quoted_sqlite_ddl_yields_columns_and_constraints() {
let src = "\
CREATE TABLE \"albums\"\n\
(\n\
[AlbumId] INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n\
[Title] NVARCHAR(160) NOT NULL,\n\
[ArtistId] INTEGER NOT NULL,\n\
FOREIGN KEY ([ArtistId]) REFERENCES \"artists\" ([ArtistId])\n\
);\n";
let parsed = dsl_parse::parse(src, Dialect::SQLite);
let cat = from_source(&parsed, src);
let table = cat
.schemas
.iter()
.flat_map(|s| s.tables.iter())
.find(|t| t.name.eq_ignore_ascii_case("albums"))
.expect("albums table");
let columns: Vec<&str> = table.columns.iter().map(|c| c.name.as_str()).collect();
assert_eq!(columns, vec!["AlbumId", "Title", "ArtistId"], "brackets are not part of the name");
let pk = table.constraints.iter().find(|c| c.kind == ConstraintKind::PrimaryKey).expect("the primary key");
assert_eq!(pk.columns, vec!["AlbumId".to_string()]);
assert_eq!(pk.name, "pk_AlbumId");
let fk = table.constraints.iter().find(|c| c.kind == ConstraintKind::ForeignKey).expect("the foreign key");
assert_eq!(fk.columns, vec!["ArtistId".to_string()]);
let reference = fk.references.as_ref().expect("the foreign key names a target");
assert_eq!(reference.table, "artists");
assert_eq!(reference.columns, vec!["ArtistId".to_string()]);
}
#[test]
fn a_dot_inside_quoting_is_part_of_the_name() {
let one = parse_references("REFERENCES [my.table] ([id])").expect("a reference");
assert_eq!((one.schema.as_str(), one.table.as_str()), ("public", "my.table"));
let qualified = parse_references("REFERENCES [dbo].[users] ([id])").expect("a reference");
assert_eq!((qualified.schema.as_str(), qualified.table.as_str()), ("dbo", "users"));
}
#[test]
fn backtick_quoted_mysql_ddl_yields_columns() {
let src = "CREATE TABLE `orders` (\n `id` INT NOT NULL,\n `total` DECIMAL(10,2)\n);\n";
let parsed = dsl_parse::parse(src, Dialect::MySql);
let cat = from_source(&parsed, src);
let table = cat.schemas.iter().flat_map(|s| s.tables.iter()).find(|t| t.name == "orders").expect("orders table");
assert_eq!(table.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), vec!["id", "total"]);
}
}