Fixed support for comparing data types with or operator for fql syntax

Author: lebeda

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [2.0.7]
+
+- Fixed support for comparing data types with `IS` or `IS_NOT` operator for fql syntax
+
 ## [2.0.6]
 
 - Fiquela conditions support compare values between row fields

docs/file-query-language.md

@@ -297,7 +297,13 @@ LEFT JOIN
 ```sql
 logical_operator:
     AND | OR | XOR
-                
+
+compare_type_value:
+    BOOLEAN | TRUE | FALSE | NUMBER | INT | DOUBLE | STRING | NULL | ARRAY | OBJECT
+
+value_type:
+    string | float | int | array | null | bool
+
 where_condition:
     expr OR expr
   | expr XOR expr
@@ -312,7 +318,7 @@ field_expr:
 comparison_operator: = | >= | > | <= | < | <> | != | !== | == | LIKE | NOT LIKE | IS | IS NOT | IN | NOT IN
 
 value_expr:
-    string | number | boolean | NULL | ARRAY | OBJECT | ENUM
+    value_type | compare_type_value
 
 [[WHERE | HAVING]
     where_condition

docs/fluent-api.md

@@ -254,22 +254,22 @@ Operators are enums that represent the comparison operators used in the conditio
 use FQL\Enum\Operator;
 ```
 
-| Operator                | Description |
-|-------------------------|-------------|
-| `EQUAL`                 | `=`         |
-| `EQUAL_STRICT`          | `==`        |
-| `NOT_EQUAL`             | `!=`        |
-| `NOT_EQUAL_STRICT`      | `!==`       |
-| `GREATER_THAN`          | `>`         |
-| `GREATER_THAN_OR_EQUAL` | `>=`        |
-| `LESS_THAN`             | `<`         |
-| `LESS_THAN_OR_EQUAL`    | `<=`        |
-| `IN`                    | `IN`        |
-| `NOT_IN`                | `NOT IN`    |
-| `LIKE`                  | `LIKE`      |
-| `NOT_LIKE`              | `NOT LIKE`  |
-| `IS`                    | `IS`        |
-| `NOT_IS`                | `IS NOT`    |
+| Enum constant           | Operator   | Description                                                                                                 |
+|-------------------------|------------|-------------------------------------------------------------------------------------------------------------|
+| `EQUAL`                 | `=`        |                                                                                                             |
+| `EQUAL_STRICT`          | `==`       |                                                                                                             |
+| `NOT_EQUAL`             | `!=`       |                                                                                                             |
+| `NOT_EQUAL_STRICT`      | `!==`      |                                                                                                             |
+| `GREATER_THAN`          | `>`        |                                                                                                             |
+| `GREATER_THAN_OR_EQUAL` | `>=`       |                                                                                                             |
+| `LESS_THAN`             | `<`        |                                                                                                             |
+| `LESS_THAN_OR_EQUAL`    | `<=`       |                                                                                                             |
+| `IN`                    | `IN`       | Compare if field is in array list.                                                                          |
+| `NOT_IN`                | `NOT IN`   | Same as `IN` operator but with oposite result.                                                              |
+| `LIKE`                  | `LIKE`     | Fully compatible `LIKE` in MYSQL databases. Supports `_` and `%`.                                           |
+| `NOT_LIKE`              | `NOT LIKE` | Same as `LIKE` operator but with oposite result.                                                            |
+| `IS`                    | `IS`       | Supported types: `BOOLEAN`, `TRUE`, `FALSE`, `NUMBER`, `INT`, `DOUBLE`, `STRING`, `NULL`, `ARRAY`, `OBJECT` |
+| `NOT_IS`                | `IS NOT`   | Same as `IS` operator but with oposite result.                                                              |
 
 **Example:**
 

examples/data/products-array.json

@@ -2,21 +2,29 @@
   {
     "id": 1,
     "name": "Product A",
-    "price": 100
+    "price": 100,
+    "code": "A1B2C3",
+    "isAvailable": true
   },
   {
     "id": 2,
     "name": "Product B",
-    "price": 200
+    "price": 200,
+    "code": "Z1B2C4",
+    "isAvailable": false
   },
   {
     "id": 3,
     "name": "Product C",
-    "price": 300
+    "price": 300,
+    "code": null,
+    "isAvailable": true
   },
   {
     "id": 4,
     "name": "Product D",
-    "price": 400
+    "price": 400,
+    "code": null,
+    "isAvailable": false
   }
 ]

src/Enum/Operator.php

@@ -58,7 +58,12 @@ public function render(mixed $value, mixed $right): string
         return match ($this) {
             self::IN, self::NOT_IN => sprintf('%s %s (%s)', $value, $this->value, implode(', ', $right)),
             self::LIKE, self::NOT_LIKE => sprintf('%s %s "%s"', $value, $this->value, $right),
-            default => sprintf('%s %s %s', $value, $this->value, is_string($right) ? "'$right'" : $right),
+            default => sprintf(
+                '%s %s %s',
+                $value,
+                $this->value,
+                is_string($right) ? "'$right'" : ($right instanceof Type ? strtoupper($right->value) : $right)
+            ),
         };
     }
 

src/Enum/Type.php

@@ -7,15 +7,15 @@
 enum Type: string
 {
     case BOOLEAN = 'boolean';
-    case TRUE = 'TRUE';
-    case FALSE = 'FALSE';
+    case TRUE = 'true';
+    case FALSE = 'false';
 
     case NUMBER = 'number';
     case INTEGER = 'int';
     case FLOAT = 'double';
 
     case STRING = 'string';
-    case NULL = 'NULL';
+    case NULL = 'null';
 
     case ARRAY = 'array';
     case OBJECT = 'object';
@@ -25,7 +25,7 @@ enum Type: string
     case RESOURCE = 'resource';
     case RESOURCE_CLOSED = 'resource (closed)';
 
-    case UNKNOWN = 'unknown type';
+    case UNKNOWN = 'unknown';
 
     public static function castValue(mixed $value, ?Type $type = null): mixed
     {
@@ -70,12 +70,12 @@ public static function match(mixed $value): self
     public static function matchByString(string $value): mixed
     {
         // Null
-        if (in_array($value, ['null', self::NULL->value])) {
+        if (in_array($value, ['null', 'NULL'])) {
             return null;
         }
 
         // Boolean
-        if (in_array($value, ['true', self::TRUE->value, 'false', self::FALSE->value], true)) {
+        if (in_array($value, ['true', 'TRUE', 'false', 'FALSE'], true)) {
             return self::castValue(strtolower($value) === 'true' ? 1 : 0, self::BOOLEAN);
         }
 

src/Sql/Sql.php

@@ -345,10 +345,10 @@ private function parseConditions(Interface\Query $query, string $context): void
             }
 
             $operator = Enum\Operator::fromOrFail($operator);
-            $value = Enum\Type::matchByString($this->nextToken());
-            $value = $operator === Enum\Operator::IS
-                ? Enum\Type::match($value)
-                : $value;
+            $value = $this->nextToken();
+            $value = $operator === Enum\Operator::IS || $operator === Enum\Operator::NOT_IS
+                ? Enum\Type::from(strtolower($value))
+                : Enum\Type::matchByString($value);
             if ($firstIter && $context === Condition::WHERE && $logicalOperator === Enum\LogicalOperator::AND) {
                 $query->where($field, $operator, $value);
                 $firstIter = false;