Replace FlatNum with PrestyledAssoc, use aliased SELECT columns

Switch from FETCH_NUM + getColumnMeta() to FETCH_ASSOC with explicit
aliased columns (e.g. post.id AS post__id). The hydrator now parses
alias keys directly, removing the PDO driver dependency.

buildSelectStatement() uses EntityFactory::enumerateFields() to emit
per-column aliases, and Composite::COMPOSITION_MARKER for join prefixes.

Author: alganet

src/Hydrators/FlatNum.php

@@ -14,12 +14,11 @@
 use Respect\Data\Collections\Filtered;
 use Respect\Data\EntityFactory;
 use Respect\Data\Hydrator;
-use Respect\Relational\Hydrators\FlatNum;
+use Respect\Data\Hydrators\PrestyledAssoc;
 use SplObjectStorage;
 use Throwable;
 
 use function array_keys;
-use function array_merge;
 use function array_push;
 use function array_values;
 use function is_array;
@@ -32,8 +31,6 @@ final class Mapper extends AbstractMapper
 {
     public readonly Db $db;
 
-    private PDOStatement $lastStatement;
-
     /** @var SplObjectStorage<object, true> */
     private SplObjectStorage $persisting;
 
@@ -133,7 +130,7 @@ public function flush(): void
 
     protected function defaultHydrator(Collection $collection): Hydrator
     {
-        return new FlatNum($this->lastStatement);
+        return new PrestyledAssoc();
     }
 
     /** Resolve related entity from relation property or FK field */
@@ -374,48 +371,53 @@ private function buildSelectStatement(Sql $sql, array $collections): Sql
     {
         $selectTable = [];
         foreach ($collections as $tableSpecifier => $c) {
-            if ($c instanceof Composite) {
-                foreach ($c->compositions as $composition => $columns) {
-                    foreach ($columns as $col) {
-                        $selectTable[] = $tableSpecifier . '_comp' . $composition . '.' . $col;
-                    }
-                }
-            }
-
             if ($c instanceof Filtered) {
                 $filters = $c->filters;
                 if ($filters) {
-                    $pkName = $tableSpecifier . '.' .
-                        $this->style->identifier($c->name);
-
-                    if ($c->identifierOnly) {
-                        $selectColumns = [$pkName];
-                    } else {
-                        $selectColumns = [
-                            $tableSpecifier . '.' .
-                            $this->style->identifier($c->name),
-                        ];
+                    $fields = $this->entityFactory->enumerateFields($c->name);
+                    $pk = $this->style->identifier($c->name);
+                    $selectTable[] = self::aliasedColumn($tableSpecifier, $pk, $fields[$pk] ?? $pk);
+
+                    if (!$c->identifierOnly) {
                         foreach ($filters as $f) {
-                            $selectColumns[] = $tableSpecifier . '.' . $f;
+                            $selectTable[] = self::aliasedColumn($tableSpecifier, $f, $fields[$f] ?? $f);
                         }
                     }
 
                     $nextName = $c->next?->name;
                     if ($nextName !== null) {
-                        $selectColumns[] = $tableSpecifier . '.' .
-                            $this->style->remoteIdentifier($nextName);
+                        $fk = $this->style->remoteIdentifier($nextName);
+                        $selectTable[] = self::aliasedColumn($tableSpecifier, $fk, $fields[$fk] ?? $fk);
                     }
-
-                    $selectTable = array_merge($selectTable, $selectColumns);
                 }
             } else {
-                $selectTable[] = $tableSpecifier . '.*';
+                foreach ($this->entityFactory->enumerateFields($c->name) as $dbCol => $styledProp) {
+                    $selectTable[] = self::aliasedColumn($tableSpecifier, $dbCol, $styledProp);
+                }
+            }
+
+            // Composition columns come after entity columns so they override on collision
+            if (!$c instanceof Composite) {
+                continue;
+            }
+
+            foreach ($c->compositions as $composition => $columns) {
+                $compPrefix = $tableSpecifier . Composite::COMPOSITION_MARKER . $composition;
+                foreach ($columns as $col) {
+                    $selectTable[] = self::aliasedColumn($compPrefix, $col, $col);
+                }
             }
         }
 
         return $sql->select(...$selectTable);
     }
 
+    /** @return array<string, string> Alias array for Sql::select() */
+    private static function aliasedColumn(string $specifier, string $dbCol, string $prop): array
+    {
+        return [$specifier . '__' . $prop => $specifier . '.' . $dbCol];
+    }
+
     /** @param array<string, Collection> $collections */
     private function buildTables(Sql $sql, array $collections): Sql
     {
@@ -466,7 +468,7 @@ private function parseCompositions(Sql $sql, Collection $collection, string $ent
         }
 
         foreach (array_keys($collection->compositions) as $comp) {
-            $alias = $entity . '_comp' . $comp;
+            $alias = $entity . Composite::COMPOSITION_MARKER . $comp;
             $sql->innerJoin($comp);
             $sql->as($alias);
             $sql->on([
@@ -569,9 +571,8 @@ private function parseHydrated(SplObjectStorage $hydrated): object
     /** @return SplObjectStorage<object, Collection>|false */
     private function fetchHydrated(Collection $collection, PDOStatement $statement): SplObjectStorage|false
     {
-        $this->lastStatement = $statement;
         $hydrator = $this->resolveHydrator($collection);
-        $row = $statement->fetch(PDO::FETCH_NUM);
+        $row = $statement->fetch(PDO::FETCH_ASSOC);
 
         return $hydrator->hydrate($row, $collection, $this->entityFactory);
     }
@@ -586,7 +587,7 @@ private function createStatement(
             $query->concat($withExtra);
         }
 
-        $statement = $this->db->prepare((string) $query, PDO::FETCH_NUM);
+        $statement = $this->db->prepare((string) $query, PDO::FETCH_ASSOC);
         $statement->execute($query->params);
 
         return $statement;

src/Mapper.php

@@ -24,8 +24,11 @@
 /** Fluent SQL builder with shape-based argument detection */
 class Sql
 {
-    /** Instructions where assoc array values are raw identifiers, not parameterized */
-    private const array RAW = ['on', 'select'];
+    /** Instructions where a single assoc-array arg means raw `key = value` pairs */
+    private const array RAW_PAIRS = ['on'];
+
+    /** Instructions where args are always comma-listed (aliases, not pairs) */
+    private const array COMMA_ONLY = ['select'];
 
     /**
      * Operators that expand an array value into multiple placeholders.
@@ -343,6 +346,10 @@ public function __call(string $name, array $args): static
             return $this;
         }
 
+        if (in_array($name, self::COMMA_ONLY)) {
+            return $this->commaList(...$args);
+        }
+
         if (!is_array($args[0])) {
             if (count($args) > 1 && is_array($args[1]) && array_is_list($args[1])) {
                 return $this->namedList((string) $args[0], $args[1]);
@@ -352,7 +359,7 @@ public function __call(string $name, array $args): static
         }
 
         if (!array_is_list($args[0])) {
-            if (in_array($name, self::RAW)) {
+            if (in_array($name, self::RAW_PAIRS)) {
                 return $this->rawPairs($args[0]);
             }
 

src/Sql.php

@@ -66,6 +66,29 @@ public function testSelectUsingAliasedColumns(): void
         $this->assertEmpty($this->object->params);
     }
 
+    public function testSelectWithAllAliasedColumns(): void
+    {
+        $sql = (string) $this->object->select(
+            ['t__id' => 't.id'],
+            ['t__name' => 't.name'],
+        )->from('t');
+        $this->assertEquals(
+            'SELECT t.id AS t__id, t.name AS t__name FROM t',
+            $sql,
+        );
+    }
+
+    public function testSelectWithSingleAliasedColumn(): void
+    {
+        $sql = (string) $this->object->select(
+            ['t__id' => 't.id'],
+        )->from('t');
+        $this->assertEquals(
+            'SELECT t.id AS t__id FROM t',
+            $sql,
+        );
+    }
+
     public function testSelectWithAggregateFunctions(): void
     {
         $sql = (string) $this->object->select('column', 'COUNT(column)', 'SUM(amount)')