Rework ColumnRef and TableRef (#927)

Extracted the `foo.bar.baz` qualification logic that was duplicated
across several variants of `ColumnRef` and `TableRef`.

I need this to implement `schema.type`: #827, #922

I'll also need this to implement `schema.function` later:
#795 (reply in thread)

There are also immediate benefits. IMO, `ColumnRef` and `TableRef` (and
their pattern-matching) look considerably cleaner now. The `database.`
prefix is guaranteed to be supported everywhere where it may be needed.

The detailed changelog is in the diff. I fully preserved (and
documented) the existing codegen behavior, as evidenced by unchanged
output in tests. If this documented behavior looks suspicious (it kinda
does to me), let's fix that later in a separate PR. Here, the only
changes in tests are the refactoring that's needed for the new variants
to compile.

This is a relatively big breaking change for those users who dig within
the internals of `ColumnRef`, `TableRef`, and `SchemaTable`. But that's
very low-level and should be rare. My work project never does that,
despite depending on SeaORM/SeaQuery/SQLx very closely and frequently
getting generic or low-level.

## PR Info

- Dependents:
  - #922

Author: Expurple

CHANGELOG.md

@@ -31,6 +31,7 @@ pub struct SeaRc;                                 // new
 ```
 * `impl From<Expr> for Condition`. Now you can use that instead of
   `ConditionExpression`, which has been removed.
+* Addded `DatabaseName`, `SchemaName`, `TableName`, `ColumnName` types.
 
 ### Breaking Changes
 
@@ -125,6 +126,9 @@ impl Iden for Glyph {
     }
 }
 ```
+* Reworked `TableRef` and `ColumnRef` variants.
+* Turned `SchemaTable` into a type alias of `TableName`. Code that accesses the
+  fields inside may not compile. Other existing code should still compile.
 * Removed `ConditionExpression` from the public API. Instead, just convert
   between `Condition` and `Expr` using `From`/`Into`.
 * Blanket-implemented `SqliteExpr` and `PgExpr` for `T where T: ExprTrait`.

src/audit/common.rs

@@ -5,13 +5,7 @@ pub(super) fn parse_audit_table(table_ref: &TableRef) -> Option<SchemaTable> {
     match table_ref {
         TableRef::SubQuery(_, _) => None,
         TableRef::FunctionCall(_, _) => None,
-        TableRef::Table(tbl) | TableRef::TableAlias(tbl, _) => Some(SchemaTable(None, tbl.clone())),
-        TableRef::SchemaTable(sch, tbl)
-        | TableRef::DatabaseSchemaTable(_, sch, tbl)
-        | TableRef::SchemaTableAlias(sch, tbl, _)
-        | TableRef::DatabaseSchemaTableAlias(_, sch, tbl, _) => {
-            Some(SchemaTable(Some(sch.clone()), tbl.clone()))
-        }
+        TableRef::Table(tbl, _) => Some(tbl.clone()),
         TableRef::ValuesList(_, _) => None,
     }
 }

src/audit/mod.rs

@@ -4,7 +4,7 @@ mod insert;
 mod select;
 mod update;
 
-use crate::DynIden;
+use crate::{DynIden, TableName};
 
 pub trait AuditTrait {
     fn audit(&self) -> Result<QueryAccessAudit, Error>;
@@ -25,7 +25,10 @@ pub struct QueryAccessAudit {
 #[non_exhaustive]
 pub struct QueryAccessRequest {
     pub access_type: AccessType,
-    pub schema_table: SchemaTable,
+    /// Legacy naming, kept for compatibility. It should be `table_name`.
+    ///
+    /// The table name can be qualified as `(database.)(schema.)table`.
+    pub schema_table: TableName,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -47,8 +50,11 @@ pub enum SchemaOper {
     Truncate,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SchemaTable(pub Option<DynIden>, pub DynIden);
+/// A table name, optionally qualified as `(database.)(schema.)table`.
+///
+/// This is a legacy type alias, to preserve some compatibility.
+/// It's going to be deprecated in the future.
+pub type SchemaTable = TableName;
 
 impl QueryAccessAudit {
     /// This filters the selects from access requests.

src/audit/select.rs

@@ -80,19 +80,10 @@ impl Walker {
         match table_ref {
             TableRef::SubQuery(select, _) => self.recurse_audit_select(select)?,
             TableRef::FunctionCall(function, _) => self.recurse_audit_function(function)?,
-            TableRef::Table(tbl) | TableRef::TableAlias(tbl, _) => {
+            TableRef::Table(table_name, _) => {
                 self.access.push(QueryAccessRequest {
                     access_type: AccessType::Select,
-                    schema_table: SchemaTable(None, tbl.clone()),
-                });
-            }
-            TableRef::SchemaTable(sch, tbl)
-            | TableRef::DatabaseSchemaTable(_, sch, tbl)
-            | TableRef::SchemaTableAlias(sch, tbl, _)
-            | TableRef::DatabaseSchemaTableAlias(_, sch, tbl, _) => {
-                self.access.push(QueryAccessRequest {
-                    access_type: AccessType::Select,
-                    schema_table: SchemaTable(Some(sch.clone()), tbl.clone()),
+                    schema_table: table_name.clone(),
                 });
             }
             TableRef::ValuesList(_, _) => (),
@@ -179,7 +170,7 @@ impl Walker {
         // remove cte alias
         for cte in &with_clause.cte_expressions {
             if let Some(table_name) = &cte.table_name {
-                self.remove_item(AccessType::Select, &SchemaTable(None, table_name.clone()));
+                self.remove_item(AccessType::Select, &TableName(None, table_name.clone()));
             }
         }
     }

src/backend/mysql/foreign_key.rs

@@ -3,7 +3,10 @@ use super::*;
 impl ForeignKeyBuilder for MysqlQueryBuilder {
     fn prepare_table_ref_fk_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
         match table_ref {
-            TableRef::Table(_) => self.prepare_table_ref_iden(table_ref, sql),
+            // Support only "naked" table names with no schema or alias.
+            TableRef::Table(TableName(None, _), None) => {
+                self.prepare_table_ref_iden(table_ref, sql)
+            }
             _ => panic!("Not supported"),
         }
     }

src/backend/mysql/index.rs

@@ -60,7 +60,10 @@ impl IndexBuilder for MysqlQueryBuilder {
 
     fn prepare_table_ref_index_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
         match table_ref {
-            TableRef::Table(_) => self.prepare_table_ref_iden(table_ref, sql),
+            // Support only "naked" table names with no schema or alias.
+            TableRef::Table(TableName(None, _), None) => {
+                self.prepare_table_ref_iden(table_ref, sql)
+            }
             _ => panic!("Not supported"),
         }
     }

src/backend/mysql/query.rs

@@ -96,11 +96,10 @@ impl QueryBuilder for MysqlQueryBuilder {
             self.prepare_iden(column, sql);
         } else {
             if let Some(table) = table {
-                if let TableRef::Table(table) = table.deref() {
-                    self.prepare_column_ref(
-                        &ColumnRef::TableColumn(table.clone(), column.clone()),
-                        sql,
-                    );
+                // Support only "naked" table names with no schema or alias.
+                if let TableRef::Table(TableName(None, table), None) = table.deref() {
+                    let column_name = ColumnName::from((table.clone(), column.clone()));
+                    self.prepare_column_ref(&ColumnRef::Column(column_name), sql);
                     return;
                 }
             }

src/backend/postgres/foreign_key.rs

@@ -101,9 +101,8 @@ impl ForeignKeyBuilder for PostgresQueryBuilder {
 
     fn prepare_table_ref_fk_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
         match table_ref {
-            TableRef::Table(_)
-            | TableRef::SchemaTable(_, _)
-            | TableRef::DatabaseSchemaTable(_, _, _) => self.prepare_table_ref_iden(table_ref, sql),
+            // Support only unaliased (but potentialy qualified) table names.
+            TableRef::Table(.., None) => self.prepare_table_ref_iden(table_ref, sql),
             _ => panic!("Not supported"),
         }
     }

src/backend/postgres/index.rs

@@ -78,11 +78,14 @@ impl IndexBuilder for PostgresQueryBuilder {
     }
 
     fn prepare_table_ref_index_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
-        match table_ref {
-            TableRef::Table(_) | TableRef::SchemaTable(_, _) => {
-                self.prepare_table_ref_iden(table_ref, sql)
-            }
-            _ => panic!("Not supported"),
+        // Support only `table` and `schema.table` forms.
+        // No `database.schema.table` or aliases.
+        let TableRef::Table(table_name, None) = table_ref else {
+            panic!("Not supported");
+        };
+        match table_name.as_iden_tuple() {
+            (Some(_db), _schema, _table) => panic!("Not supported"),
+            (None, _schema, _table) => self.prepare_table_ref_iden(table_ref, sql),
         }
     }
 
@@ -94,13 +97,18 @@ impl IndexBuilder for PostgresQueryBuilder {
         }
 
         if let Some(table) = &drop.table {
-            match table {
-                TableRef::Table(_) => {}
-                TableRef::SchemaTable(schema, _) => {
+            // Support only `table` and `schema.table` forms.
+            // No `database.schema.table` or aliases.
+            let TableRef::Table(table_name, None) = table else {
+                panic!("Not supported");
+            };
+            match table_name.as_iden_tuple() {
+                (None, None, _table) => {}
+                (None, Some(schema), _table) => {
                     self.prepare_iden(schema, sql);
                     write!(sql, ".").unwrap();
                 }
-                _ => panic!("Not supported"),
+                (Some(_db), _schema, _table) => panic!("Not supported"),
             }
         }
         if let Some(name) = &drop.index.name {

src/backend/query_builder.rs

@@ -596,27 +596,21 @@ pub trait QueryBuilder:
 
     fn prepare_column_ref(&self, column_ref: &ColumnRef, sql: &mut dyn SqlWriter) {
         match column_ref {
-            ColumnRef::Column(column) => self.prepare_iden(column, sql),
-            ColumnRef::TableColumn(table, column) => {
-                self.prepare_iden(table, sql);
-                write!(sql, ".").unwrap();
-                self.prepare_iden(column, sql);
-            }
-            ColumnRef::SchemaTableColumn(schema, table, column) => {
-                self.prepare_iden(schema, sql);
-                write!(sql, ".").unwrap();
-                self.prepare_iden(table, sql);
-                write!(sql, ".").unwrap();
+            ColumnRef::Column(ColumnName(table_name, column)) => {
+                if let Some(table_name) = table_name {
+                    self.prepare_table_name(table_name, sql);
+                    write!(sql, ".").unwrap();
+                }
                 self.prepare_iden(column, sql);
             }
-            ColumnRef::Asterisk => {
+            ColumnRef::Asterisk(table_name) => {
+                if let Some(table_name) = table_name {
+                    self.prepare_table_name(table_name, sql);
+                    write!(sql, ".").unwrap();
+                }
                 write!(sql, "*").unwrap();
             }
-            ColumnRef::TableAsterisk(table) => {
-                self.prepare_iden(table, sql);
-                write!(sql, ".*").unwrap();
-            }
-        };
+        }
     }
 
     /// Translate [`UnOper`] into SQL statement.