Add KeyFilter and deprecate KeyValue object

Signed-off-by: davidarendsen <davidarendsen@hey.com>

README.md

@@ -15,14 +15,15 @@ composer require arendsen/fluxquerybuilder
 <?php
 
 use Arendsen\FluxQueryBuilder\QueryBuilder;
-use Arendsen\FluxQueryBuilder\Expression\KeyValue;
+use Arendsen\FluxQueryBuilder\Expression\KeyFilter;
 
 $queryBuilder = new QueryBuilder();
 $queryBuilder->fromBucket('test_bucket')
     ->addRangeStart(new DateTime('3 hours ago'))
     ->fromMeasurement('test_measurement')
-    ->addFilter(
+    ->addFieldFilter(['username', 'email'])
-        KeyValue::setEqualTo('_field', 'username')
+    ->addKeyFilter(
+        KeyFilter::setEqualTo('_field', 'username')
             ->orEqualTo('_field', 'email')
     )
     ->addMap('r with name: r.user')

composer.json

@@ -14,7 +14,8 @@
     ],
     "autoload": {
         "psr-4": {
-            "Arendsen\\FluxQueryBuilder\\": "src/"
+            "Arendsen\\FluxQueryBuilder\\": "src/",
+            "Tests\\": "tests/"
         }
     },
     "require": {

src/Expression/KeyFilter.php

@@ -0,0 +1,207 @@
+<?php
+
+namespace Arendsen\FluxQueryBuilder\Expression;
+
+use Arendsen\FluxQueryBuilder\Type;
+use Exception;
+
+class KeyFilter extends Base
+{
+    public const EQUAL_TO = '==';
+    public const NOT_EQUAL_TO = '!=';
+    public const GREATER_THAN = '>';
+    public const GREATER_EQUAL_TO = '>=';
+    public const LESS_THAN = '<';
+    public const LESS_EQUAL_TO = '<=';
+    public const EQUAL_TO_REGEX = '=~';
+    public const NOT_EQUAL_TO_REGEX = '!~';
+
+    public const COMPARISON_OPERATORS = [
+        self::EQUAL_TO,
+        self::NOT_EQUAL_TO,
+        self::GREATER_THAN,
+        self::GREATER_EQUAL_TO,
+        self::LESS_THAN,
+        self::LESS_EQUAL_TO,
+        self::EQUAL_TO_REGEX,
+        self::NOT_EQUAL_TO_REGEX,
+    ];
+
+    /**
+     * @var array $expressions
+     */
+    private $expressions;
+
+    private function __construct(string $key, string $operator, $value)
+    {
+        $this->checkOperator($operator);
+        $this->expressions[] = 'r.' . $key . ' ' . $operator . ' ' . new Type($value);
+    }
+
+    public static function set(string $key, string $operator, $value): KeyFilter
+    {
+        return new self($key, $operator, $value);
+    }
+
+    public static function setEqualTo(string $key, string $value): KeyFilter
+    {
+        return self::set($key, self::EQUAL_TO, $value);
+    }
+
+    public static function setNotEqualTo(string $key, string $value): KeyFilter
+    {
+        return self::set($key, self::NOT_EQUAL_TO, $value);
+    }
+
+    public static function setGreaterThan(string $key, int $value): KeyFilter
+    {
+        return self::set($key, self::GREATER_THAN, $value);
+    }
+
+    public static function setGreaterOrEqualTo(string $key, int $value): KeyFilter
+    {
+        return self::set($key, self::GREATER_EQUAL_TO, $value);
+    }
+
+    public static function setLessThan(string $key, int $value): KeyFilter
+    {
+        return self::set($key, self::LESS_THAN, $value);
+    }
+
+    public static function setLessOrEqualTo(string $key, int $value): KeyFilter
+    {
+        return self::set($key, self::LESS_EQUAL_TO, $value);
+    }
+
+    public static function setEqualToRegex(string $key, string $value): KeyFilter
+    {
+        return self::set($key, self::EQUAL_TO_REGEX, $value);
+    }
+
+    public static function setNotEqualToRegex(string $key, string $value): KeyFilter
+    {
+        return self::set($key, self::NOT_EQUAL_TO_REGEX, $value);
+    }
+
+    public function and(string $key, string $operator, $value): KeyFilter
+    {
+        $this->checkOperator($operator);
+        $this->expressions[] = 'and r.' . $key . ' ' . $operator . ' ' . new Type($value);
+        return $this;
+    }
+
+    public function andEqualTo(string $key, string $value): KeyFilter
+    {
+        $this->and($key, self::EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function andNotEqualTo(string $key, string $value): KeyFilter
+    {
+        $this->and($key, self::NOT_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function andGreaterThan(string $key, int $value): KeyFilter
+    {
+        $this->and($key, self::GREATER_THAN, $value);
+        return $this;
+    }
+
+    public function andGreaterOrEqualTo(string $key, int $value): KeyFilter
+    {
+        $this->and($key, self::GREATER_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function andLessThan(string $key, int $value): KeyFilter
+    {
+        $this->and($key, self::LESS_THAN, $value);
+        return $this;
+    }
+
+    public function andLessOrEqualTo(string $key, int $value): KeyFilter
+    {
+        $this->and($key, self::LESS_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function andEqualToRegex(string $key, string $value): KeyFilter
+    {
+        $this->and($key, self::EQUAL_TO_REGEX, $value);
+        return $this;
+    }
+
+    public function andNotEqualToRegex(string $key, string $value): KeyFilter
+    {
+        $this->and($key, self::NOT_EQUAL_TO_REGEX, $value);
+        return $this;
+    }
+
+    public function or(string $key, string $operator, $value): KeyFilter
+    {
+        $this->checkOperator($operator);
+        $this->expressions[] = 'or r.' . $key . ' ' . $operator . ' ' . new Type($value);
+        return $this;
+    }
+
+    public function orEqualTo(string $key, string $value): KeyFilter
+    {
+        $this->or($key, self::EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function orNotEqualTo(string $key, string $value): KeyFilter
+    {
+        $this->or($key, self::NOT_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function orGreaterThan(string $key, int $value): KeyFilter
+    {
+        $this->or($key, self::GREATER_THAN, $value);
+        return $this;
+    }
+
+    public function orGreaterOrEqualTo(string $key, int $value): KeyFilter
+    {
+        $this->or($key, self::GREATER_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function orLessThan(string $key, int $value): KeyFilter
+    {
+        $this->or($key, self::LESS_THAN, $value);
+        return $this;
+    }
+
+    public function orLessOrEqualTo(string $key, int $value): KeyFilter
+    {
+        $this->or($key, self::LESS_EQUAL_TO, $value);
+        return $this;
+    }
+
+    public function orEqualToRegex(string $key, string $value): KeyFilter
+    {
+        $this->or($key, self::EQUAL_TO_REGEX, $value);
+        return $this;
+    }
+
+    public function orNotEqualToRegex(string $key, string $value): KeyFilter
+    {
+        $this->or($key, self::NOT_EQUAL_TO_REGEX, $value);
+        return $this;
+    }
+
+    public function __toString()
+    {
+        return implode(' ', $this->expressions);
+    }
+
+    protected function checkOperator(string $operator)
+    {
+        if (!in_array($operator, self::COMPARISON_OPERATORS)) {
+            throw new Exception('Operator "' . $operator . '" is not supported!');
+        }
+    }
+}

src/Expression/KeyValue.php

@@ -5,6 +5,9 @@ namespace Arendsen\FluxQueryBuilder\Expression;
 use Arendsen\FluxQueryBuilder\Type;
 use Exception;
 
+/**
+ * @deprecated
+ */
 class KeyValue extends Base
 {
     public const EQUAL_TO = '==';
@@ -204,4 +207,4 @@ class KeyValue extends Base
             throw new Exception('Operator "' . $operator . '" is not supported!');
         }
     }
-}
+}

src/Functions/Filter.php

@@ -4,6 +4,7 @@ namespace Arendsen\FluxQueryBuilder\Functions;
 
 use Arendsen\FluxQueryBuilder\Exception\FunctionInvalidInputException;
 use Arendsen\FluxQueryBuilder\Expression\KeyValue;
+use Arendsen\FluxQueryBuilder\Expression\KeyFilter;
 
 class Filter extends Base
 {
@@ -27,7 +28,7 @@ class Filter extends Base
      */
     protected function format(): string
     {
-        if ($this->filter instanceof KeyValue) {
+        if ($this->filter instanceof KeyValue || $this->filter instanceof KeyFilter) {
             return $this->filter->__toString();
         } elseif (is_array($this->filter)) {
             $filterCounter = 0;

src/QueryBuilder.php

@@ -5,6 +5,7 @@ namespace Arendsen\FluxQueryBuilder;
 use DateTime;
 use Exception;
 use Arendsen\FluxQueryBuilder\Expression\KeyValue;
+use Arendsen\FluxQueryBuilder\Expression\KeyFilter;
 use Arendsen\FluxQueryBuilder\Functions\AggregateWindow;
 use Arendsen\FluxQueryBuilder\Functions\Duplicate;
 use Arendsen\FluxQueryBuilder\Functions\Filter;
@@ -80,10 +81,16 @@ class QueryBuilder
     public function fromMeasurement(string $measurement): QueryBuilder
     {
         $this->addRequiredData(self::REQUIRED_INPUT_MEASUREMENT, $measurement);
-        $this->addFilter(KeyValue::setEqualTo('_measurement', $measurement));
+        $this->addKeyFilter(KeyFilter::setEqualTo('_measurement', $measurement));
         return $this;
     }
 
+    /**
+     * @deprecated
+     *
+     * @param KeyValue $keyValue
+     * @return QueryBuilder
+     */
     public function addFilter(KeyValue $keyValue): QueryBuilder
     {
         $this->addToQuery(
@@ -93,6 +100,15 @@ class QueryBuilder
         return $this;
     }
 
+    public function addKeyFilter(KeyFilter $keyFilter): QueryBuilder
+    {
+        $this->addToQuery(
+            self::FLUX_PART_FILTERS,
+            new Filter($keyFilter)
+        );
+        return $this;
+    }
+
     public function addFieldFilter(array $fields): QueryBuilder
     {
         $this->addToQuery(

tests/QueryBuilderTest.php

@@ -2,10 +2,11 @@
 
 declare(strict_types=1);
 
-namespace Tests\Generic;
+namespace Tests;
 
 use DateTime;
 use Exception;
+use Arendsen\FluxQueryBuilder\Expression\KeyFilter;
 use Arendsen\FluxQueryBuilder\Expression\KeyValue;
 use PHPUnit\Framework\TestCase;
 use Arendsen\FluxQueryBuilder\QueryBuilder;
@@ -16,15 +17,15 @@ final class QueryBuilderTest extends TestCase
     /**
      * @dataProvider simpleQueryProvider
      */
-    public function testSimpleQuery($bucket, $measurement, $range, $keyValue, $expectedQuery)
+    public function testSimpleQuery($bucket, $measurement, $range, $keyFilter, $expectedQuery)
     {
         $queryBuilder = new QueryBuilder();
         $queryBuilder->from($bucket)
             ->addRangeStart($range)
             ->fromMeasurement($measurement);
 
-        if ($keyValue) {
+        if ($keyFilter) {
-            $queryBuilder->addFilter($keyValue);
+            $queryBuilder->addKeyFilter($keyFilter);
         }
 
         $this->assertEquals($expectedQuery, $queryBuilder->build());
@@ -49,7 +50,7 @@ final class QueryBuilderTest extends TestCase
                 ],
                 'test_measurement',
                 new DateTime('2022-08-12 20:05:00'),
-                KeyValue::setEqualTo('user', 'username'),
+                KeyFilter::setEqualTo('user', 'username'),
                 'from(bucket: "example_bucket") |> range(start: time(v: 2022-08-12T20:05:00Z)) ' .
                     '|> filter(fn: (r) => r._measurement == "test_measurement") ' .
                     '|> filter(fn: (r) => r.user == "username") '
@@ -114,7 +115,7 @@ final class QueryBuilderTest extends TestCase
             ->addReduce(['count' => new MathType('accumulator.count + 1')], ['count' => 0])
             ->fromMeasurement('test_measurement')
             ->addFieldFilter(['username', 'ip'])
-            ->addFilter(KeyValue::setGreaterOrEqualTo('count', 1)->andGreaterOrEqualTo('count2', 2))
+            ->addKeyFilter(KeyFilter::setGreaterOrEqualTo('count', 1)->andGreaterOrEqualTo('count2', 2))
             ->addMap('r with name: r.user')
             ->addGroup(['_field', 'ip']);
 
@@ -137,13 +138,15 @@ final class QueryBuilderTest extends TestCase
             ->addMean()
             ->addDuplicate('tag', 'tag_dup')
             ->fromMeasurement('test_measurement')
-            ->addFilter(KeyValue::setGreaterOrEqualTo('count', 1)->andGreaterOrEqualTo('count2', 2))
+            ->addFilter(KeyValue::setGreaterOrEqualTo('count', 2)->andGreaterOrEqualTo('count2', 3))
+            ->addKeyFilter(KeyFilter::setGreaterOrEqualTo('count', 1)->andGreaterOrEqualTo('count2', 2))
             ->addUnWindow();
 
         $expectedQuery = 'from(bucket: "test_bucket") |> range(start: time(v: 2022-08-12T17:31:00Z)) ' .
             '|> reduce(fn: (r, accumulator) => ({count: accumulator.count + 1}), identity: {count: 0}) ' .
             '|> window(every: 20s) |> mean() |> duplicate(column: "tag", as: "tag_dup") ' .
             '|> filter(fn: (r) => r._measurement == "test_measurement") ' .
+            '|> filter(fn: (r) => r.count >= 2 and r.count2 >= 3) ' .
             '|> filter(fn: (r) => r.count >= 1 and r.count2 >= 2) |> window(every: inf) ';
 
         $this->assertEquals($expectedQuery, $queryBuilder->build());