detect new mariadb grammar class

tpetry · tpetry · commit f7eefa940070 · 2024-03-12T12:41:45.000+01:00
diff --git a/src/Concerns/IdentifiesDriver.php b/src/Concerns/IdentifiesDriver.php
@@ -5,10 +5,12 @@
 namespace Tpetry\QueryExpressions\Concerns;
 
 use Illuminate\Database\Grammar;
+use Illuminate\Database\Query\Grammars\MariaDbGrammar as MariaQueryGrammar;
 use Illuminate\Database\Query\Grammars\MySqlGrammar as MysqlQueryGrammar;
 use Illuminate\Database\Query\Grammars\PostgresGrammar as PgsqlQueryGrammar;
 use Illuminate\Database\Query\Grammars\SQLiteGrammar as SqliteQueryGrammar;
 use Illuminate\Database\Query\Grammars\SqlServerGrammar as SqlsrvQueryGrammar;
+use Illuminate\Database\Schema\Grammars\MariaDbGrammar as MariaSchemaGrammar;
 use Illuminate\Database\Schema\Grammars\MySqlGrammar as MysqlSchemaGrammar;
 use Illuminate\Database\Schema\Grammars\PostgresGrammar as PgsqlSchemaGrammar;
 use Illuminate\Database\Schema\Grammars\SQLiteGrammar as SqliteSchemaGrammar;
@@ -18,11 +20,12 @@
 trait IdentifiesDriver
 {
     /**
-     * @return 'mysql'|'pgsql'|'sqlite'|'sqlsrv'
+     * @return 'mariadb'|'mysql'|'pgsql'|'sqlite'|'sqlsrv'
      */
     protected function identify(Grammar $grammar): string
     {
         return match (true) {
+            $this->isMaria($grammar) => 'mariadb',
             $this->isMysql($grammar) => 'mysql',
             $this->isPgsql($grammar) => 'pgsql',
             $this->isSqlite($grammar) => 'sqlite',
@@ -31,6 +34,11 @@ protected function identify(Grammar $grammar): string
         };
     }
 
+    protected function isMaria(Grammar $grammar): bool
+    {
+        return $grammar instanceof MariaQueryGrammar || $grammar instanceof MariaSchemaGrammar;
+    }
+
     protected function isMysql(Grammar $grammar): bool
     {
         return $grammar instanceof MysqlQueryGrammar || $grammar instanceof MysqlSchemaGrammar;
diff --git a/src/Function/Aggregate/CountFilter.php b/src/Function/Aggregate/CountFilter.php
@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string
         $filter = $this->stringize($grammar, $this->filter);
 
         return match ($this->identify($grammar)) {
-            'mysql' => "sum({$filter})",
+            'mariadb', 'mysql' => "sum({$filter})",
             'pgsql', 'sqlite' => "count(*) filter (where {$filter})",
             'sqlsrv' => "sum(case when {$filter} then 1 else 0 end)",
         };
diff --git a/src/Function/Aggregate/SumFilter.php b/src/Function/Aggregate/SumFilter.php
@@ -26,7 +26,7 @@ public function getValue(Grammar $grammar): string
         $filter = $this->stringize($grammar, $this->filter);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlsrv' => "sum(case when {$filter} then {$value} else 0 end)",
+            'mariadb', 'mysql', 'sqlsrv' => "sum(case when {$filter} then {$value} else 0 end)",
             'pgsql', 'sqlite' => "sum({$value}) filter (where {$filter})",
         };
     }
diff --git a/src/Function/Comparison/StrListContains.php b/src/Function/Comparison/StrListContains.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
 
         // PostgreSQL: The string_to_array is not used because citext values would be cast to case-sensitive text type
         return match ($this->identify($grammar)) {
-            'mysql' => "FIND_IN_SET({$str}, {$strList}) > 0",
+            'mariadb', 'mysql' => "FIND_IN_SET({$str}, {$strList}) > 0",
             'pgsql', 'sqlite' => "({$strList} like {$str} or {$strList} like (({$str})||',%') or {$strList} like ('%,'||({$str})||',%') or {$strList} like ('%,'||({$str})))",
             'sqlsrv' => "({$strList} like {$str} or {$strList} like concat({$str},',%') or {$strList} like concat('%,',{$str},',%') or {$strList} like concat('%,',{$str}))",
         };
diff --git a/src/Function/Conditional/Greatest.php b/src/Function/Conditional/Greatest.php
@@ -20,7 +20,7 @@ public function getValue(Grammar $grammar): string
         $expressionsStr = implode(', ', $expressions);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'pgsql' => "greatest({$expressionsStr})",
+            'mariadb', 'mysql', 'pgsql' => "greatest({$expressionsStr})",
             'sqlite' => "max({$expressionsStr})",
             'sqlsrv' => "(select max(n) from (values {$expressionsStr}) as v(n))",
         };
diff --git a/src/Function/Conditional/Least.php b/src/Function/Conditional/Least.php
@@ -20,7 +20,7 @@ public function getValue(Grammar $grammar): string
         $expressionsStr = implode(', ', $expressions);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'pgsql' => "least({$expressionsStr})",
+            'mariadb', 'mysql', 'pgsql' => "least({$expressionsStr})",
             'sqlite' => "min({$expressionsStr})",
             'sqlsrv' => "(select min(n) from (values {$expressionsStr}) as v(n))",
         };
diff --git a/src/Function/Math/Abs.php b/src/Function/Math/Abs.php
@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string
         $expression = $this->stringize($grammar, $this->expression);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlite' => "(abs({$expression}))",
+            'mariadb', 'mysql', 'sqlite' => "(abs({$expression}))",
             'pgsql', 'sqlsrv' => "abs({$expression})",
         };
     }
diff --git a/src/Function/String/Concat.php b/src/Function/String/Concat.php
@@ -17,7 +17,7 @@ public function getValue(Grammar $grammar): string
         $expressions = $this->getExpressions($grammar);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlsrv' => sprintf('(concat(%s))', implode(',', $expressions)),
+            'mariadb', 'mysql', 'sqlsrv' => sprintf('(concat(%s))', implode(',', $expressions)),
             'pgsql', 'sqlite' => sprintf('(%s)', implode('||', $expressions)),
         };
     }
diff --git a/src/Function/String/Lower.php b/src/Function/String/Lower.php
@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string
         $expression = $this->stringize($grammar, $this->expression);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlite' => "(lower({$expression}))",
+            'mariadb', 'mysql', 'sqlite' => "(lower({$expression}))",
             'pgsql', 'sqlsrv' => "lower({$expression})",
         };
     }
diff --git a/src/Function/String/Upper.php b/src/Function/String/Upper.php
@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string
         $expression = $this->stringize($grammar, $this->expression);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlite' => "(upper({$expression}))",
+            'mariadb', 'mysql', 'sqlite' => "(upper({$expression}))",
             'pgsql', 'sqlsrv' => "upper({$expression})",
         };
     }
diff --git a/src/Function/String/Uuid4.php b/src/Function/String/Uuid4.php
@@ -18,7 +18,7 @@ public function getValue(Grammar $grammar)
         // SQLite: The expression needs to be enclosed by parentheses to be used as a default value in create table statements.
         // SQLite: First character in 4th group is hardcoded to 8 because the required 8, 9, A, or B can't be randomly generated.
         return match ($this->identify($grammar)) {
-            'mysql' => "(lower(concat(hex(random_bytes(4)),'-',hex(random_bytes(2)),'-4',substr(hex(random_bytes(2)), -3),'-',hex((ascii(random_bytes(1))>>6)+8),substr(hex(random_bytes(2)),-3),'-',hex(random_bytes(6)))))",
+            'mariadb', 'mysql' => "(lower(concat(hex(random_bytes(4)),'-',hex(random_bytes(2)),'-4',substr(hex(random_bytes(2)), -3),'-',hex((ascii(random_bytes(1))>>6)+8),substr(hex(random_bytes(2)),-3),'-',hex(random_bytes(6)))))",
             'pgsql' => 'gen_random_uuid()',
             'sqlite' => "(lower(hex(randomblob(4))||'-'||hex(randomblob(2))||'-4'||substr(hex(randomblob(2)), -3)||'-8'||substr(hex(randomblob(2)),-3)||'-'||hex(randomblob(6))))",
             'sqlsrv' => 'lower(newid())',
diff --git a/src/Function/Time/Now.php b/src/Function/Time/Now.php
@@ -18,7 +18,7 @@ public function getValue(Grammar $grammar)
         // PostgreSQL: The CURRENT_TIMESTAMP constant is frozen within transactions.
         // SQLite: The expression needs to be enclosed by parentheses to be used as a default value in create table statements.
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlite' => '(current_timestamp)',
+            'mariadb', 'mysql', 'sqlite' => '(current_timestamp)',
             'pgsql' => 'statement_timestamp()',
             'sqlsrv' => 'current_timestamp',
         };
diff --git a/src/Function/Time/TimestampBin.php b/src/Function/Time/TimestampBin.php
@@ -40,7 +40,7 @@ public function getValue(Grammar $grammar)
         // MySQL: The expression needs to be enclosed by parentheses to be used as a default value in create table statements.
         // SQLite: The expression needs to be enclosed by parentheses to be used as a default value in create table statements.
         return match ($this->identify($grammar)) {
-            'mysql' => "(from_unixtime(floor((unix_timestamp({$expression})-{$origin})/{$step})*{$step}+{$origin}))",
+            'mariadb', 'mysql' => "(from_unixtime(floor((unix_timestamp({$expression})-{$origin})/{$step})*{$step}+{$origin}))",
             'pgsql' => "to_timestamp(floor((extract(epoch from {$expression})-{$origin})/{$step})*{$step}+{$origin})",
             'sqlite' => "(datetime((strftime('%s',{$expression})-{$origin})/{$step}*{$step}+{$origin},'unixepoch'))",
             'sqlsrv' => "dateadd(s,(datediff(s,'1970-01-01',{$expression})-{$origin})/{$step}*{$step}+{$origin},'1970-01-01')",
diff --git a/src/Language/Alias.php b/src/Language/Alias.php
@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string
     {
         $expression = $this->stringize($grammar, $this->expression);
         $name = match ($this->identify($grammar)) {
-            'mysql' => '`'.str_replace('`', '``', $this->name).'`',
+            'mariadb', 'mysql' => '`'.str_replace('`', '``', $this->name).'`',
             'pgsql', 'sqlite' => '"'.str_replace('"', '""', $this->name).'"',
             'sqlsrv' => '['.str_replace(']', ']]', $this->name).']',
         };
diff --git a/src/Operator/Arithmetic/Power.php b/src/Operator/Arithmetic/Power.php
@@ -16,7 +16,7 @@ class Power extends ArithmeticExpression
     public function getValue(Grammar $grammar): string
     {
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlite', 'sqlsrv' => $this->buildPowerFunctionChain($grammar),
+            'mariadb', 'mysql', 'sqlite', 'sqlsrv' => $this->buildPowerFunctionChain($grammar),
             'pgsql' => parent::getValue($grammar),
         };
     }
diff --git a/src/Operator/Bitwise/BitXor.php b/src/Operator/Bitwise/BitXor.php
@@ -26,7 +26,7 @@ public function getValue(Grammar $grammar)
         $value2 = $this->stringize($grammar, $this->value2);
 
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlsrv' => "({$value1} ^ {$value2})",
+            'mariadb', 'mysql', 'sqlsrv' => "({$value1} ^ {$value2})",
             'pgsql' => "({$value1} # {$value2})",
             'sqlite' => "(({$value1} | {$value2}) - ({$value1} & {$value2}))",
         };
diff --git a/src/Operator/Bitwise/ShiftLeft.php b/src/Operator/Bitwise/ShiftLeft.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
         // Mysql: shifting negative numbers does not work because the result is always a positive 64-bit integer
         // Sqlsrv: shifting is not available in version 2017 and 2019
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlsrv' => "({$value} * power(2, {$times}))",
+            'mariadb', 'mysql', 'sqlsrv' => "({$value} * power(2, {$times}))",
             'pgsql', 'sqlite' => "({$value} << {$times})",
         };
     }
diff --git a/src/Operator/Bitwise/ShiftRight.php b/src/Operator/Bitwise/ShiftRight.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
         // Mysql: shifting negative numbers does not work because the result is always a positive 64-bit integer
         // Sqlsrv: shifting is not available in version 2017 and 2019
         return match ($this->identify($grammar)) {
-            'mysql', 'sqlsrv' => "floor({$value} / power(2, {$times}))",
+            'mariadb', 'mysql', 'sqlsrv' => "floor({$value} / power(2, {$times}))",
             'pgsql', 'sqlite' => "({$value} >> {$times})",
         };
     }
diff --git a/src/Operator/Comparison/DistinctFrom.php b/src/Operator/Comparison/DistinctFrom.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
 
         // Sqlsrv: IS DISTINCT FROM is not available in version 2017 and 2019
         return match ($this->identify($grammar)) {
-            'mysql' => "(not {$value1} <=> {$value2})",
+            'mariadb', 'mysql' => "(not {$value1} <=> {$value2})",
             'pgsql' => "({$value1} is distinct from {$value2})",
             'sqlite' => "({$value1} is not {$value2})",
             'sqlsrv' => "({$value1} != {$value2} or ({$value1} is not null and {$value2} is null) or ({$value1} is null and {$value2} is not null))",
diff --git a/src/Operator/Comparison/NotDistinctFrom.php b/src/Operator/Comparison/NotDistinctFrom.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
 
         // Sqlsrv: IS DISTINCT FROM is not available in version 2017 and 2019
         return match ($this->identify($grammar)) {
-            'mysql' => "({$value1} <=> {$value2})",
+            'mariadb', 'mysql' => "({$value1} <=> {$value2})",
             'pgsql' => "({$value1} is not distinct from {$value2})",
             'sqlite' => "({$value1} is {$value2})",
             'sqlsrv' => "({$value1} = {$value2} or ({$value1} is null and {$value2} is null))",
diff --git a/src/Operator/Logical/CondXor.php b/src/Operator/Logical/CondXor.php
@@ -28,7 +28,7 @@ public function getValue(Grammar $grammar)
         $value2 = $this->stringize($grammar, $this->value2);
 
         return match ($this->identify($grammar)) {
-            'mysql' => "({$value1} xor {$value2})",
+            'mariadb', 'mysql' => "({$value1} xor {$value2})",
             'pgsql', 'sqlite', 'sqlsrv' => "(({$value1} and not {$value2}) or (not {$value1} and {$value2}))",
         };
     }

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public function getValue(Grammar $grammar): string`
`26`	`26`	`$filter = $this->stringize($grammar, $this->filter);`
`27`	`27`
`28`	`28`	`return match ($this->identify($grammar)) {`
`29`		`- 'mysql', 'sqlsrv' => "sum(case when {$filter} then {$value} else 0 end)",`
	`29`	`+ 'mariadb', 'mysql', 'sqlsrv' => "sum(case when {$filter} then {$value} else 0 end)",`
`30`	`30`	`'pgsql', 'sqlite' => "sum({$value}) filter (where {$filter})",`
`31`	`31`	`};`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public function getValue(Grammar $grammar): string`
`24`	`24`	`$expression = $this->stringize($grammar, $this->expression);`
`25`	`25`
`26`	`26`	`return match ($this->identify($grammar)) {`
`27`		`- 'mysql', 'sqlite' => "(abs({$expression}))",`
	`27`	`+ 'mariadb', 'mysql', 'sqlite' => "(abs({$expression}))",`
`28`	`28`	`'pgsql', 'sqlsrv' => "abs({$expression})",`
`29`	`29`	`};`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public function getValue(Grammar $grammar): string`
`17`	`17`	`$expressions = $this->getExpressions($grammar);`
`18`	`18`
`19`	`19`	`return match ($this->identify($grammar)) {`
`20`		`- 'mysql', 'sqlsrv' => sprintf('(concat(%s))', implode(',', $expressions)),`
	`20`	`+ 'mariadb', 'mysql', 'sqlsrv' => sprintf('(concat(%s))', implode(',', $expressions)),`
`21`	`21`	`'pgsql', 'sqlite' => sprintf('(%s)', implode('\|\|', $expressions)),`
`22`	`22`	`};`
`23`	`23`	`}`