fix: compileUpdate er compileSelect

- les jointures lors des updates ne sont supportées que par mysql/mariadb et differement par postgre

- dans le compile select, les unions viennent avant orders

Author: dimtrovich

src/Builder/Compilers/MySQL.php

@@ -15,6 +15,39 @@
 
 class MySQL extends QueryCompiler
 {
+    /**
+     * {@inheritDoc}
+     */
+    public function compileUpdate(BaseBuilder $builder): string
+    {
+        $table = $this->db->makeTableName($builder->getTable());
+        
+        $sql = ["UPDATE {$table}"];
+
+        if ([] !== $builder->joins) {
+            $sql[] = $this->compileJoins($builder->joins);
+        }
+
+        $sets = [];
+        foreach ($builder->values as $column => $value) {
+            $column = $this->db->escapeIdentifiers($column);
+            $sets[] = "{$column} = " . $this->wrapValue($value);
+        }
+
+        $sql[] = "SET " . implode(', ', $sets);
+
+        if ([] !== $builder->wheres) {
+            $sql[] = 'WHERE';
+            $sql[] = $this->compileWheres($builder->wheres);
+        }
+
+        if ('' !== $limit = $this->compileLimit($builder->limit, null)) {
+            $sql[] = $limit;
+        }
+
+        return implode(' ', array_filter($sql));
+    }
+
     /**
      * {@inheritDoc}
      */

src/Builder/Compilers/Postgre.php

@@ -12,6 +12,7 @@
 namespace BlitzPHP\Database\Builder\Compilers;
 
 use BlitzPHP\Database\Builder\BaseBuilder;
+use BlitzPHP\Database\Builder\JoinClause;
 
 class Postgre extends QueryCompiler
 {
@@ -61,11 +62,15 @@ public function compileInsertUsing(BaseBuilder $builder): string
      */
     public function compileUpdate(BaseBuilder $builder): string
     {
-        $sql = parent::compileUpdate($builder);
+        if ($builder->joins === []) {
+            $sql = $this->compileUpdateStandard($builder);
+            
+            return "{$sql} RETURNING *";
+        }
 
-        return "{$sql} RETURNING *";
+        return $this->compileUpdateWithFrom($builder);
     }
-
+    
     /**
      * {@inheritDoc}
      */
@@ -190,4 +195,54 @@ protected function compileAnyAll(string $type, string $column, string $operator,
 
         return "{$column} {$operator} {$type} ({$placeholders})";
     }
+
+    /**
+     * Compilation PostgreSQL avec FROM
+     */
+    protected function compileUpdateWithFrom(BaseBuilder $builder): string
+    {
+        $table = $this->db->makeTableName($builder->getTable());
+        
+        $sets = [];
+        foreach ($builder->values as $column => $value) {
+            $column = $this->db->escapeIdentifiers($column);
+            $sets[] = "{$column} = " . $this->wrapValue($value);
+        }
+
+        $sql = ["UPDATE {$table}"];
+        $sql[] = "SET " . implode(', ', $sets);
+
+        // Construction de la clause FROM
+        $fromTables = [];
+        $joinConditions = [];
+
+        foreach ($builder->joins as $join) {
+            if ($join instanceof JoinClause) {
+                $fromTables[] = $join->getTable();
+                
+                // Convertir les conditions ON en conditions WHERE
+                foreach ($join->getConditions() as $condition) {
+                    if ($condition['type'] === 'basic') {
+                        $joinConditions[] = $condition['first'] . ' ' . 
+                                           $condition['operator'] . ' ' . 
+                                           $condition['second'];
+                    }
+                }
+            }
+        }
+
+        if ($fromTables !== []) {
+            $sql[] = "FROM " . implode(', ', $fromTables);
+        }
+
+        // Fusionner les conditions WHERE originales avec les conditions de jointure
+        $allConditions = array_merge($joinConditions, $builder->wheres);
+        
+        if ($allConditions !== []) {
+            $sql[] = 'WHERE';
+            $sql[] = $this->compileWheres($allConditions);
+        }
+
+        return implode(' ', array_filter($sql));
+    }
 }

src/Builder/Compilers/QueryCompiler.php

@@ -14,6 +14,7 @@
 use BlitzPHP\Database\Builder\BaseBuilder;
 use BlitzPHP\Database\Builder\JoinClause;
 use BlitzPHP\Database\Connection\BaseConnection;
+use BlitzPHP\Database\Exceptions\DatabaseException;
 use BlitzPHP\Database\Query\Expression;
 use BlitzPHP\Database\Utils;
 use InvalidArgumentException;
@@ -78,15 +79,15 @@ public function compileSelect(BaseBuilder $builder): string
             $sql[] = $this->compileHavings($builder->havings);
         }
 
+        if ([] !== $builder->unions) {
+            $sql[] = $this->compileUnions($builder->unions);
+        }
+
         if ([] !== $builder->orders) {
             $sql[] = 'ORDER BY';
             $sql[] = $this->compileOrders($builder->orders);
         }
 
-        if ([] !== $builder->unions) {
-            $sql[] = $this->compileUnions($builder->unions);
-        }
-
         if ('' !== $limit = $this->compileLimit($builder->limit, $builder->offset)) {
             $sql[] = $limit;
         }
@@ -144,20 +145,33 @@ public function compileInsertUsing(BaseBuilder $builder): string
      */
     public function compileUpdate(BaseBuilder $builder): string
     {
-        $table = $this->db->escapeIdentifiers($builder->getTable());
+        return $this->compileUpdateStandard($builder);
+    }
+
+    /**
+     * Compilation standard sans jointure
+     */
+    protected function compileUpdateStandard(BaseBuilder $builder): string
+    {
+        $table = $this->db->makeTableName($builder->getTable());
+        
+        $sql = ["UPDATE {$table}"];
 
         $sets = [];
         foreach ($builder->values as $column => $value) {
             $column = $this->db->escapeIdentifiers($column);
             $sets[] = "{$column} = " . $this->wrapValue($value);
         }
-
-        $sql = ["UPDATE {$table} SET " . implode(', ', $sets)];
-
+        
         if ([] !== $builder->joins) {
-            $sql[] = $this->compileJoins($builder->joins);
+            // Si des jointures sont présentes mais non supportées, on lève une exception.
+            throw new DatabaseException(
+                "Les jointures dans UPDATE ne sont pas supportées par " . $this->db->getDriver()
+            );
         }
 
+        $sql[] = "SET " . implode(', ', $sets);
+
         if ([] !== $builder->wheres) {
             $sql[] = 'WHERE';
             $sql[] = $this->compileWheres($builder->wheres);

src/Builder/Compilers/SQLite.php

@@ -12,9 +12,25 @@
 namespace BlitzPHP\Database\Builder\Compilers;
 
 use BlitzPHP\Database\Builder\BaseBuilder;
+use BlitzPHP\Database\Exceptions\DatabaseException;
 
 class SQLite extends QueryCompiler
 {
+    /**
+     * {@inheritDoc}
+     */
+    public function compileUpdate(BaseBuilder $builder): string
+    {
+        if ($builder->joins !== []) {
+            throw new DatabaseException(
+                "SQLite ne supporte pas les jointures dans les requêtes UPDATE. " .
+                "Utilisez des sous-requêtes à la place."
+            );
+        }
+
+        return $this->compileUpdateStandard($builder);
+    }
+    
     /**
      * {@inheritDoc}
      */