Restore to post-ColumnRef/OrderSpec state

simon-mundy · simon-mundy · commit 09ba68024966 · 2026-02-28T19:12:56.000+11:00
Reverts the temporary baseline test commit. This is the state after
polymorphic argument rendering with SqlFragment fluent chain intact.

Signed-off-by: Simon Mundy &lt;simon.mundy@peptolab.com&gt;
diff --git a/src/Sql/Part/ColumnRef.php b/src/Sql/Part/ColumnRef.php
@@ -4,61 +4,34 @@
 
 namespace PhpDb\Sql\Part;
 
-use PhpDb\Sql\Argument\Identifier;
-use PhpDb\Sql\Argument\Literal;
-use PhpDb\Sql\Argument\Select as SelectArgument;
-use PhpDb\Sql\ArgumentInterface;
 use PhpDb\Sql\Expression;
 use PhpDb\Sql\ExpressionInterface;
 use PhpDb\Sql\Select;
 
 use function is_string;
 use function stripos;
 
-/**
- * Normalized column reference for SELECT column lists.
- * Type discrimination happens at construction time, not at render time.
- *
- * Argument types determine rendering:
- * - Literal       → star column (*), prefixed, no alias
- * - Identifier    → column name, prefixed, alias handling
- * - SelectArgument → expression/subselect, alias handling
- *
- * Alias rules:
- * - $alias is set      → always render AS $alias
- * - $containsAlias     → expression already has AS in its spec, no extra alias
- * - expression w/o alias → auto-generate alias as Expression{N} at render time
- * - string w/o alias   → $alias is set to the column name itself (auto-alias)
- */
 final readonly class ColumnRef
 {
-    public ArgumentInterface $arg;
+    public ExpressionInterface|string $column;
+    public bool $isStar;
     public ?string $alias;
     public bool $containsAlias;
 
-    /**
-     * @param int|string                 $key    Array key (int = auto-alias, string = explicit alias)
-     * @param ExpressionInterface|string $column The column value
-     * @param string                     $star   The SQL_STAR constant value
-     */
     public function __construct(
         int|string $key,
         ExpressionInterface|string $column,
         string $star = Select::SQL_STAR,
     ) {
-        if ($column === $star) {
-            $this->arg           = new Literal('*');
+        $this->column = $column;
+        $this->isStar = ($column === $star);
+
+        if ($this->isStar) {
             $this->alias         = null;
             $this->containsAlias = false;
             return;
         }
 
-        if ($column instanceof ExpressionInterface) {
-            $this->arg = new SelectArgument($column);
-        } else {
-            $this->arg = new Identifier($column);
-        }
-
         if (is_string($key)) {
             $this->alias         = $key;
             $this->containsAlias = false;
diff --git a/src/Sql/Part/Columns.php b/src/Sql/Part/Columns.php
@@ -4,16 +4,16 @@
 
 namespace PhpDb\Sql\Part;
 
-use PhpDb\Sql\Argument\Identifier;
-use PhpDb\Sql\Argument\Literal;
 use PhpDb\Sql\ExpressionInterface;
 use PhpDb\Sql\Select;
 
 use function count;
 use function current;
+use function explode;
 use function implode;
 use function is_array;
 use function is_numeric;
+use function is_string;
 use function key;
 
 /**
@@ -51,29 +51,27 @@ public function toSql(SqlProcessor $processor): ?string
         $refs       = $this->columnRefs;
         $fromPrefix = $this->fromTablePrefix;
 
-        if (isset($refs[0]) && ! isset($refs[1]) && $refs[0]->arg instanceof Literal && $this->joinSpecs === []) {
-            return $fromPrefix . $refs[0]->arg->getValue();
+        if (isset($refs[0]) && ! isset($refs[1]) && $refs[0]->isStar && $this->joinSpecs === []) {
+            return $fromPrefix . '*';
         }
 
         $fragments   = [];
         $exprCounter = 1;
         $platform    = $processor->platform;
 
         foreach ($refs as $ref) {
-            $arg = $ref->arg;
-
-            if ($arg instanceof Literal) {
-                $fragments[] = $fromPrefix . $arg->getValue();
+            if ($ref->isStar) {
+                $fragments[] = $fromPrefix . '*';
                 continue;
             }
 
-            if ($arg instanceof Identifier) {
-                $columnSql = $fromPrefix . $platform->quoteIdentifier($arg->segments[0], $arg->segments[1] ?? null);
+            $column = $ref->column;
+
+            if (is_string($column)) {
+                $parts     = explode('.', $column, 2);
+                $columnSql = $fromPrefix . $platform->quoteIdentifier($parts[0], $parts[1] ?? null);
             } else {
-                $columnSql = $processor->renderExpression(
-                    $arg->getValue(),
-                    $ref->alias ?? 'column',
-                );
+                $columnSql = $processor->renderExpression($column, $ref->alias ?? 'column');
             }
 
             if ($ref->alias !== null) {
@@ -93,20 +91,18 @@ public function toSql(SqlProcessor $processor): ?string
                 }
                 $joinPrefix = $processor->resolveTable($spec->alias ?? $spec->table) . $separator;
                 foreach ($spec->columnRefs as $ref) {
-                    $arg = $ref->arg;
-
-                    if ($arg instanceof Literal) {
-                        $fragments[] = $joinPrefix . $arg->getValue();
+                    if ($ref->isStar) {
+                        $fragments[] = $joinPrefix . '*';
                         continue;
                     }
 
-                    if ($arg instanceof Identifier) {
-                        $columnSql = $joinPrefix . $platform->quoteIdentifier($arg->segments[0], $arg->segments[1] ?? null);
+                    $column = $ref->column;
+
+                    if (is_string($column)) {
+                        $parts     = explode('.', $column, 2);
+                        $columnSql = $joinPrefix . $platform->quoteIdentifier($parts[0], $parts[1] ?? null);
                     } else {
-                        $columnSql = $processor->renderExpression(
-                            $arg->getValue(),
-                            $ref->alias ?? 'column',
-                        );
+                        $columnSql = $processor->renderExpression($column, $ref->alias ?? 'column');
                     }
 
                     if ($ref->alias !== null) {
diff --git a/src/Sql/Part/GroupBy.php b/src/Sql/Part/GroupBy.php
@@ -4,11 +4,12 @@
 
 namespace PhpDb\Sql\Part;
 
-use PhpDb\Sql\ArgumentType;
-use ValueError;
+use PhpDb\Sql\ExpressionInterface;
 
+use function explode;
 use function implode;
 use function is_array;
+use function is_string;
 
 /**
  * Holds and renders GROUP BY clause.
@@ -25,15 +26,18 @@ public function toSql(SqlProcessor $processor): ?string
             return null;
         }
 
-        $groups = [];
-        $pi     = 0;
+        $platform = $processor->platform;
+        $groups   = [];
+
         foreach ($this->group as $ref) {
-            $groups[] = match ($ref->arg->getType()) {
-                ArgumentType::Identifier => $ref->arg->render($processor, '', $pi),
-                ArgumentType::Select     => $processor->renderExpression($ref->arg->getValue()),
-                ArgumentType::Literal    => $ref->arg->getValue(),
-                default => throw new ValueError('Unexpected ArgumentType: ' . $ref->arg->getType()->name),
-            };
+            $column = $ref->column;
+
+            if (is_string($column)) {
+                $parts    = explode('.', $column, 2);
+                $groups[] = $platform->quoteIdentifier($parts[0], $parts[1] ?? null);
+            } else {
+                $groups[] = $processor->renderExpression($column);
+            }
         }
 
         return 'GROUP BY ' . implode(', ', $groups);
@@ -67,7 +71,7 @@ public function get(): ?array
 
         $result = [];
         foreach ($this->group as $ref) {
-            $result[] = $ref->arg->getValue();
+            $result[] = $ref->column;
         }
         return $result;
     }
diff --git a/src/Sql/Part/OrderBy.php b/src/Sql/Part/OrderBy.php
@@ -4,9 +4,7 @@
 
 namespace PhpDb\Sql\Part;
 
-use PhpDb\Sql\ArgumentType;
 use PhpDb\Sql\ExpressionInterface;
-use ValueError;
 
 use function explode;
 use function implode;
@@ -33,15 +31,19 @@ public function toSql(SqlProcessor $processor): ?string
             return null;
         }
 
-        $orders = [];
-        $pi     = 0;
+        $platform = $processor->platform;
+        $orders   = [];
+
         foreach ($this->order as $spec) {
-            $orders[] = match ($spec->column->getType()) {
-                ArgumentType::Select     => $processor->renderExpression($spec->column->getValue()),
-                ArgumentType::Identifier => $spec->column->render($processor, '', $pi)
-                                             . ' ' . $spec->direction,
-                default => throw new ValueError('Unexpected ArgumentType: ' . $spec->column->getType()->name),
-            };
+            $column = $spec->column;
+
+            if (is_string($column)) {
+                $parts     = explode('.', $column, 2);
+                $orders[]  = $platform->quoteIdentifier($parts[0], $parts[1] ?? null)
+                           . ' ' . $spec->direction;
+            } else {
+                $orders[] = $processor->renderExpression($column);
+            }
         }
 
         return 'ORDER BY ' . implode(', ', $orders);
@@ -86,10 +88,10 @@ public function get(): array
     {
         $result = [];
         foreach ($this->order as $spec) {
-            if ($spec->column->getType() === ArgumentType::Select) {
-                $result[] = $spec->column->getValue();
+            if ($spec->column instanceof ExpressionInterface) {
+                $result[] = $spec->column;
             } else {
-                $result[] = $spec->column->getValue() . ' ' . $spec->direction;
+                $result[] = $spec->column . ' ' . $spec->direction;
             }
         }
         return $result;
diff --git a/src/Sql/Part/OrderSpec.php b/src/Sql/Part/OrderSpec.php
@@ -4,36 +4,24 @@
 
 namespace PhpDb\Sql\Part;
 
-use PhpDb\Sql\Argument\Identifier;
-use PhpDb\Sql\Argument\Select as SelectArgument;
-use PhpDb\Sql\ArgumentInterface;
 use PhpDb\Sql\ExpressionInterface;
 
 use function strcasecmp;
 use function trim;
 
-/**
- * Normalized order-by item with column (as ArgumentInterface) and direction.
- * Parsing of "column DESC" strings and direction normalization happens at construction time.
- */
 final readonly class OrderSpec
 {
     public const ORDER_ASCENDING  = 'ASC';
     public const ORDER_DESCENDING = 'DESC';
 
-    public ArgumentInterface $column;
+    public ExpressionInterface|string $column;
     public string $direction;
 
     public function __construct(
         ExpressionInterface|string $column,
         string $direction = self::ORDER_ASCENDING,
     ) {
-        if ($column instanceof ExpressionInterface) {
-            $this->column = new SelectArgument($column);
-        } else {
-            $this->column = new Identifier($column);
-        }
-
+        $this->column    = $column;
         $this->direction = strcasecmp(trim($direction), self::ORDER_DESCENDING) === 0
             ? self::ORDER_DESCENDING
             : self::ORDER_ASCENDING;
