Add ability to specify dependencies without foreign keys

demo.yml

@@ -51,9 +51,34 @@ tables:
                             if_false_converters:
                                 - 'employee'
 
-        filters:
+        filters: # filters are applied with AND operator
             - [in, 'id', [1, 2, 3]] # only select rows which id is 1, 2 or 3
             - [like, 'name', 'Markus %'] # only select rows which column "name" starts with Markus
+            - [isNotNull, 'street']
+            - [or, [gte, id, 1], [lte, id, 3] ] # ( id >= 1 ) OR  ( id <= 3)
+
+        dependencies: # Used to declare dependencies not constrained by a foreign keys.
+            - column: "reference_id"
+              referenced_table: "referenceTable"
+              referenced_column: "id"
+
+    bar:
+        dependencies: # This will apply the dependency based on the logical condition
+            - column: "reference_id"
+              referenced_table: "referenceTableA"
+              referenced_column: "id"
+              condition: [eq, 'reference_table',  'referenceTableA']
+            - column: "reference_id"
+              referenced_table: "referenceTableB"
+              referenced_column: "id"
+              condition: [eq, 'reference_table',  'referenceTableB']
+
+    beer:
+        dependencies: # This will apply all the dependencies dynamically for tables using a column to refer to the dependency
+            - column: "reference_id"
+              column_as_referenced_table: "reference_table"
+              referenced_column: "id"
+
     foo_custom:
         query: >
             SELECT *, bar.value1 AS xyz

src/Command/DumpCommand.php

@@ -52,8 +52,8 @@ protected function execute(InputInterface $input, OutputInterface $output)
 
         /** @var DumperInterface $dumper */
         $class = $config->getFullQualifiedDumperClassName();
-        $dumper = new $class();
-        $dumper->dump($context);
+        $dumper = new $class($context);
+        $dumper->dump();
     }
 
     /**

src/Configuration/DumperConfigurationInterface.php

@@ -2,6 +2,8 @@
 
 namespace Digilist\SnakeDumper\Configuration;
 
+use Digilist\SnakeDumper\Dumper\DataLoaderInterface;
+
 interface DumperConfigurationInterface
 {
 
@@ -14,4 +16,10 @@ public function getDumper();
      * @return OutputConfiguration
      */
     public function getOutputConfig();
+
+    /**
+     * @param DataLoaderInterface $dataLoader
+     * @return mixed
+     */
+    public function hydrateConfig(DataLoaderInterface $dataLoader);
 }

src/Configuration/SnakeConfigurationTree.php

@@ -73,10 +73,22 @@ public function getConfigTreeBuilder()
                         ->arrayNode('filters')
                             ->prototype('variable')->end()
                         ->end()
+                        ->arrayNode('dependencies')
+                            ->arrayPrototype()
+                                ->children()
+                                    ->scalarNode('column')->end()
+                                    ->scalarNode('column_as_referenced_table')->end()
+                                    ->scalarNode('referenced_table')->end()
+                                    ->scalarNode('referenced_column')->end()
+                                    ->arrayNode('condition')
+                                        ->prototype('variable')->end()
+                                    ->end()
+                                ->end()
+                            ->end()
+                        ->end()
                     ->end()
                 ->end()
-            ->end()
-        ;
+            ->end();
 
         return $treeBuilder;
     }

src/Configuration/SqlDumperConfiguration.php

@@ -2,8 +2,9 @@
 
 namespace Digilist\SnakeDumper\Configuration;
 
-use Digilist\SnakeDumper\Configuration\Table\Filter\DataDependentFilter;
 use Digilist\SnakeDumper\Configuration\Table\TableConfiguration;
+use Digilist\SnakeDumper\Configuration\Table\TableDependencyConstraint;
+use Digilist\SnakeDumper\Dumper\DataLoaderInterface;
 
 class SqlDumperConfiguration extends AbstractConfiguration implements DumperConfigurationInterface
 {
@@ -133,18 +134,13 @@ public function parseDependencies()
         // a table depends on another table if a dependent filter is defined
         foreach ($this->tableConfigs as $table) {
             // if the dependent table is not configured, create a configuration
+            /** @var TableDependencyConstraint $dependency */
             foreach ($table->getDependentTables() as $dependency) {
-                if (!array_key_exists($dependency, $this->tableConfigs)) {
-                    $this->tableConfigs[$dependency] = new TableConfiguration($dependency, array());
-                }
-            }
-
-            // find dependent filters and add harvest columns
-            foreach ($table->getFilters() as $filter) {
-                if ($filter instanceof DataDependentFilter) {
-                    // the dependent table needs to collect values of that column
-                    $this->tableConfigs[$filter->getReferencedTable()]->addHarvestColumn($filter->getReferencedColumn());
+                $dependentTable = $dependency->getReferencedTable();
+                if (!array_key_exists($dependentTable, $this->tableConfigs)) {
+                    $this->tableConfigs[$dependentTable] = new TableConfiguration($dependentTable, array());
                 }
+                $this->tableConfigs[$dependentTable]->addHarvestColumn($dependency->getReferencedColumn());
             }
         }
     }
@@ -165,7 +161,12 @@ protected function parseConfig(array $dumperConfig)
         foreach ($dumperConfig['tables'] as $name => $tableConfig) {
             $this->tableConfigs[$name] = new TableConfiguration($name, $tableConfig);
         }
+    }
 
+    public function hydrateConfig(DataLoaderInterface $dataLoader) {
+        foreach ($this->tableConfigs as $tableConfiguration) {
+            $tableConfiguration->hydrateConfig($dataLoader);
+        }
         $this->parseDependencies();
     }
 

src/Configuration/Table/Filter/DefaultFilter.php → src/Configuration/Table/Filter/ColumnFilter.php

@@ -2,10 +2,9 @@
 
 namespace Digilist\SnakeDumper\Configuration\Table\Filter;
 
-use Digilist\SnakeDumper\Configuration\AbstractConfiguration;
 use InvalidArgumentException;
 
-class DefaultFilter implements FilterInterface
+class ColumnFilter implements FilterColumnInterface
 {
 
     const OPERATOR_EQ = 'eq';
@@ -65,15 +64,15 @@ class DefaultFilter implements FilterInterface
     private $value;
 
     /**
-     * DefaultFilter constructor.
+     * ColumnFilter constructor.
      *
      * @param string $columnName
      * @param string $operator
      * @param string $value
      */
     public function __construct($columnName, $operator, $value = null)
     {
-        if (!in_array($operator, self::$validOperators)) {
+        if (!self::isValidOperator($operator)) {
             throw new InvalidArgumentException('Invalid filter operator: ' . $operator);
         }
 
@@ -82,6 +81,11 @@ public function __construct($columnName, $operator, $value = null)
         $this->value = $value;
     }
 
+    public static function isValidOperator($operator)
+    {
+        return in_array($operator, self::$validOperators);
+    }
+
     /**
      * @return string
      */
@@ -135,4 +139,12 @@ public function setValue($value)
     {
         return $this->value = $value;
     }
+
+    /**
+     * @return array
+     */
+    public function getFilters()
+    {
+        return [$this->columnName, $this->value];
+    }
 }

src/Configuration/Table/Filter/CompositeFilter.php

@@ -0,0 +1,69 @@
+<?php
+
+
+namespace Digilist\SnakeDumper\Configuration\Table\Filter;
+
+
+use InvalidArgumentException;
+
+class CompositeFilter implements FilterInterface
+{
+    const OPERATOR_OR = 'or';
+    const OPERATOR_AND = 'and';
+
+    private static $validOperators = [
+        self::OPERATOR_OR,
+        self::OPERATOR_AND,
+    ];
+
+    private static $dbalOperators = [
+        self::OPERATOR_OR => 'orX',
+        self::OPERATOR_AND => 'andX'
+    ];
+
+    /**
+     * @var array
+     */
+    private $filters;
+
+    /**
+     * @var string
+     */
+    private $operator;
+
+
+    public function __construct($operator, array $filters = [])
+    {
+        if (!self::isValidOperator($operator)) {
+            throw new InvalidArgumentException('Invalid filter operator: ' . $operator);
+        }
+
+        $this->operator = $operator;
+        $this->filters = $filters;
+    }
+
+    /**
+     * @param $operator
+     * @return bool
+     */
+    public static function isValidOperator($operator)
+    {
+        return in_array($operator, self::$validOperators);
+    }
+
+    /**
+     * @return string
+     */
+    public function getOperator()
+    {
+        return self::$dbalOperators[$this->operator];
+    }
+
+    /**
+     * @return array
+     */
+    public function getFilters()
+    {
+        return $this->filters;
+    }
+}

src/Configuration/Table/Filter/DataDependentFilter.php

@@ -2,7 +2,7 @@
 
 namespace Digilist\SnakeDumper\Configuration\Table\Filter;
 
-class DataDependentFilter extends DefaultFilter
+class DataDependentFilter extends ColumnFilter
 {
 
     /**

src/Configuration/Table/Filter/FilterColumnInterface.php

@@ -0,0 +1,17 @@
+<?php
+namespace Digilist\SnakeDumper\Configuration\Table\Filter;
+
+interface FilterColumnInterface extends FilterInterface
+{
+
+    /**
+     * @return string
+     */
+    public function getColumnName();
+
+
+    /**
+     * @return string
+     */
+    public function getValue();
+}

src/Configuration/Table/Filter/FilterFactory.php

@@ -0,0 +1,26 @@
+<?php
+
+
+namespace Digilist\SnakeDumper\Configuration\Table\Filter;
+
+
+use InvalidArgumentException;
+
+class FilterFactory
+{
+    public static function buildFilter(array $filter) {
+        $operator = $filter[0];
+
+        if (ColumnFilter::isValidOperator($operator)) {
+            $columnName = $filter[1];
+            $value = isset($filter[2]) ? $filter[2] : null;
+            return new ColumnFilter($columnName, $operator, $value);
+        }
+
+        if (CompositeFilter::isValidOperator($operator)) {
+            $subFilters = array_map([__CLASS__, 'buildFilter'], array_slice($filter,1));
+            return new CompositeFilter($operator, $subFilters);
+        }
+        throw new InvalidArgumentException('Invalid filter operator: ' . $operator);
+    }
+}

src/Configuration/Table/Filter/FilterInterface.php

@@ -4,18 +4,9 @@
 interface FilterInterface
 {
 
-    /**
-     * @return string
-     */
-    public function getColumnName();
-
     /**
      * @return string
      */
     public function getOperator();
 
-    /**
-     * @return string
-     */
-    public function getValue();
 }