refactors; extend unit tests; update docs

Author: themisvaltinos

docs/concepts/macros/sqlmesh_macros.md

@@ -855,7 +855,9 @@ FROM foo
 
 `@UNION` returns a `UNION` query that selects all columns with matching names and data types from the tables.
 
-Its first argument is the `UNION` "type", `'DISTINCT'` (removing duplicated rows) or `'ALL'` (returning all rows). Subsequent arguments are the tables to be combined.
+Its first argument can be either a condition or the `UNION` "type". If the first argument evaluates to a boolean (`TRUE` or `FALSE`), it's treated as a condition. If the condition is `FALSE`, only the first table is returned. If it's `TRUE`, the union operation is performed.
+
+If the first argument is not a boolean condition, it's treated as the `UNION` "type": either `'DISTINCT'` (removing duplicated rows) or `'ALL'` (returning all rows). Subsequent arguments are the tables to be combined.
 
 Let's assume that:
 
@@ -882,6 +884,47 @@ SELECT
 FROM bar
 ```
 
+If the union type is omitted, `'ALL'` is used as the default. So the following expression:
+
+```sql linenums="1"
+@UNION(foo, bar)
+```
+
+would be rendered as:
+
+```sql linenums="1"
+SELECT
+  CAST(a AS INT) AS a,
+  CAST(c AS TEXT) AS c
+FROM foo
+UNION ALL
+SELECT
+  CAST(a AS INT) AS a,
+  CAST(c AS TEXT) AS c
+FROM bar
+```
+
+You can also use a condition to control whether the union happens:
+
+```sql linenums="1"
+@UNION(1 > 0, 'all', foo, bar)
+```
+
+This would render the same as above. However, if the condition is `FALSE`:
+
+```sql linenums="1"
+@UNION(1 > 2, 'all', foo, bar)
+```
+
+Only the first table would be selected:
+
+```sql linenums="1"
+SELECT
+  CAST(a AS INT) AS a,
+  CAST(c AS TEXT) AS c
+FROM foo
+```
+
 ### @HAVERSINE_DISTANCE
 
 `@HAVERSINE_DISTANCE` returns the [haversine distance](https://en.wikipedia.org/wiki/Haversine_formula) between two geographic points.

sqlmesh/core/macros.py

@@ -994,33 +994,29 @@ def union(
     """
 
     if not args:
-        raise SQLMeshError("At least one table is required for UNION.")
+        raise SQLMeshError("At least one table is required for the @UNION macro.")
 
     arg_idx = 0
     # Check for condition
     condition = evaluator.eval_expression(args[arg_idx])
     if isinstance(condition, bool):
         arg_idx += 1
         if arg_idx >= len(args):
-            raise SQLMeshError("Expected more arguments after condition.")
+            raise SQLMeshError("Expected more arguments after the condition of the `@UNION` macro.")
 
     # Check for union type
     type_ = exp.Literal.string("ALL")
-    if arg_idx < len(args) and isinstance(args[arg_idx], exp.Literal):
+    if isinstance(args[arg_idx], exp.Literal):
         type_ = args[arg_idx]  # type: ignore
         arg_idx += 1
     kind = type_.name.upper()
     if kind not in ("ALL", "DISTINCT"):
         raise SQLMeshError(f"Invalid type '{type_}'. Expected 'ALL' or 'DISTINCT'.")
 
     # Remaining args should be tables
-    tables = []
-    for table in args[arg_idx:]:
-        if isinstance(table, exp.Column):
-            table = exp.table_(table.this, db=table.args.get("table"), catalog=table.args.get("db"))
-        else:
-            table = exp.to_table(table, dialect=evaluator.dialect)  # type: ignore
-        tables.append(table)
+    tables = [
+        exp.to_table(e.sql(evaluator.dialect), dialect=evaluator.dialect) for e in args[arg_idx:]
+    ]
 
     columns = {
         column

tests/core/test_model.py

@@ -318,6 +318,46 @@ def test_model_union_query(sushi_context, assert_exp_eq):
             2,
             lambda expected_select: f"{expected_select}\nUNION ALL\n{expected_select}\n",
         ),
+        # Test case 7: Missing union type AND condition
+        (
+            "test_7",
+            "",
+            "",
+            2,
+            lambda expected_select: f"{expected_select}\nUNION ALL\n{expected_select}\n",
+        ),
+        # Test case 8: Missing union type AND condition multiple tables
+        (
+            "test_8",
+            "",
+            "",
+            3,
+            lambda expected_select: f"{expected_select}\nUNION ALL\n{expected_select}\n\nUNION ALL\n{expected_select}\n",
+        ),
+        # Test case 9: Missing union type AND condition one table
+        (
+            "test_9",
+            "",
+            "",
+            1,
+            lambda expected_select: f"{expected_select}",
+        ),
+        # Test case 10: Union type with one table
+        (
+            "test_10",
+            "",
+            "'distinct'",
+            1,
+            lambda expected_select: f"{expected_select}",
+        ),
+        # Test case 11: Condition with one table
+        (
+            "test_9",
+            "True",
+            "",
+            1,
+            lambda expected_select: f"{expected_select}",
+        ),
     ],
 )
 def test_model_union_conditional(