Add filter function to QueryBuilder

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

src/QueryBuilder.php

@@ -14,44 +14,51 @@ class QueryBuilder {
     const FLUX_PART_RANGE = 'range';
     const FLUX_PART_FILTERS = 'filters';
 
+    const PARTS = [
+        self::FLUX_PART_FROM,
+        self::FLUX_PART_RANGE,
+        self::FLUX_PART_FILTERS
+    ];
+
+    const REQUIRED_INPUT_FROM = 'from';
+    const REQUIRED_INPUT_MEASUREMENT = 'measurement';
+    const REQUIRED_INPUT_RANGE = 'range';
+
+    const REQUIRED_INPUT = [
+        self::REQUIRED_INPUT_FROM,
+        self::REQUIRED_INPUT_MEASUREMENT,
+        self::REQUIRED_INPUT_RANGE,
+    ];
+
     /**
      * @var array $fluxQuery
      */
     private $fluxQueryParts = [];
 
     /**
-     * @var array $from
+     * @var array $requiredData
      */
-    private $from;
+    private $requiredData = [];
-
-    /**
-     * @var string $measurement
-     */
-    private $measurement;
-
-    /**
-     * @var array $range
-     */
-    private $range;
     
     public function from(array $from): QueryBuilder
     {
-        $this->from = $from;
+        $this->addRequiredData(self::REQUIRED_INPUT_FROM, $from);
         $this->addToQuery(
             self::FLUX_PART_FROM,
-            new From($this->from)
+            new From($from)
         );
         return $this;
     }
 
-    public function fromBucket(string $bucket): QueryBuilder {
+    public function fromBucket(string $bucket): QueryBuilder
+    {
         $this->from(['bucket' => $bucket]);
         return $this;
     }
 
     public function fromMeasurement(string $measurement): QueryBuilder
     {
-        $this->measurement = $measurement;
+        $this->addRequiredData(self::REQUIRED_INPUT_MEASUREMENT, $measurement);
         $this->addToQueryArray(
             self::FLUX_PART_FILTERS,
             new Filter(KeyValue::set('_measurement', $measurement))
@@ -59,9 +66,18 @@ class QueryBuilder {
         return $this;
     }
 
+    public function addFilter(KeyValue $keyValue): QueryBuilder
+    {
+        $this->addToQueryArray(
+            self::FLUX_PART_FILTERS,
+            new Filter($keyValue)
+        );
+        return $this;
+    }
+
     public function addRange(array $range): QueryBuilder
     {
-        $this->range = $range;
+        $this->addRequiredData(self::REQUIRED_INPUT_RANGE, $range);
         $this->addToQuery(
             self::FLUX_PART_RANGE,
             new Range($range)
@@ -91,41 +107,37 @@ class QueryBuilder {
 
         $query = '';
 
-        if(isset($this->fluxQueryParts[self::FLUX_PART_FROM])) {
+        foreach(self::PARTS as $part)
-            $query .= $this->fluxQueryParts[self::FLUX_PART_FROM];
+        {
-        }
+            if(isset($this->fluxQueryParts[$part]))
-
+            {
-        if(isset($this->fluxQueryParts[self::FLUX_PART_RANGE])) {
+                if(is_array($this->fluxQueryParts[$part]))
-            $query .= $this->fluxQueryParts[self::FLUX_PART_RANGE];
+                {
-        }
+                    foreach($this->fluxQueryParts[$part] as $filter) {
-
-        if(isset($this->fluxQueryParts[self::FLUX_PART_FILTERS])) {
-            foreach($this->fluxQueryParts[self::FLUX_PART_FILTERS] as $filter) {
                         $query .= $filter;
                     }
                 }
+                else
+                {
+                    $query .= $this->fluxQueryParts[$part];
+                }
+            }
+        }
 
         return $query;
+    }
 
-        //TODO: build the query dynamically here
+    protected function addRequiredData(string $key, $value) {
-        return 'from(bucket: "test_bucket") |> ';
+        $this->requiredData[$key] = $value;
     }
 
     protected function checkRequired()
     {
-        if(!$this->from)
+        foreach(self::REQUIRED_INPUT as $input) {
+            if(!isset($this->requiredData[$input]))
             {
-            throw new Exception('You need to define the from part of the query!');
+                throw new Exception('You need to define the "' . $input . '" part of the query!');
             }
-
-        if(!$this->measurement)
-        {
-            throw new Exception('You need to define the measurement of the query!');
-        }
-
-        if(!$this->range)
-        {
-            throw new Exception('You need to define the range part of the query!');
         }
     }
 

tests/QueryBuilderTest.php

@@ -1,6 +1,7 @@
 <?php
 declare(strict_types=1);
 
+use Arendsen\FluxQueryBuilder\Expression\KeyValue;
 use PHPUnit\Framework\TestCase;
 use Arendsen\FluxQueryBuilder\QueryBuilder;
 
@@ -9,27 +10,43 @@ final class QueryBuilderTest extends TestCase {
     /**
      * @dataProvider simpleQueryProvider
      */
-    public function testSimpleQuery($bucket, $measurement, $range, $expectedQuery)
+    public function testSimpleQuery($bucket, $measurement, $range, $keyValue, $expectedQuery)
     {
         $queryBuilder = new QueryBuilder();
         $queryBuilder->from($bucket)
             ->fromMeasurement($measurement)
 			->addRangeStart($range);
 
+        if($keyValue)
+        {
+            $queryBuilder->addFilter($keyValue);
+        }
+
         $this->assertEquals($expectedQuery, $queryBuilder->build());
     }
 
     public function simpleQueryProvider(): array
     {
         return [
-            'case 1' => [
+            'basic query' => [
                 [
                     'bucket' => 'example_bucket',
                 ],
                 'test_measurement',
                 '-360h',
+                null,
                 'from(bucket: "example_bucket") |> range(start: "-360h") |> filter(fn: (r) => r._measurement == "test_measurement") '
             ],
+            'query with filter' => [
+                [
+                    'bucket' => 'example_bucket',
+                ],
+                'test_measurement',
+                '-360h',
+                new KeyValue('user', 'username'),
+                'from(bucket: "example_bucket") |> range(start: "-360h") |> filter(fn: (r) => r._measurement == "test_measurement") ' . 
+                    '|> filter(fn: (r) => r.user == "username") '
+            ],
         ];
     }