NOT BETWEEN

Author: nilportugues

README.md

@@ -768,28 +768,28 @@ SELECT user_email.* FROM user_email
 The following operators are available for filtering using WHERE conditionals:
 
 ```php
-    public function subWhere($operator = 'OR');
-    public function equals($column, $value);
-    public function compare($column, $value, $operator);
-    public function notEquals($column, $value);
-    public function greaterThan($column, $value);
-    public function greaterThanOrEqual($column, $value);
-    public function lessThan($column, $value);
-    public function lessThanOrEqual($column, $value);
-    public function like($column, $value);
-    public function notLike($column, $value);
-    public function match(array $columns, array $values);
-    public function matchBoolean(array $columns, array $values);
-    public function matchWithQueryExpansion(array $columns, array $values);
-    public function in($column, array $values);
-    public function notIn($column, array $values);
-    public function between($column, $a, $b);
-    public function isNull($column);
-    public function isNotNull($column);
-    public function exists(Select $select);
-    public function notExists(Select $select);
-    public function addBitClause($column, $value);    
-    public function asLiteral($literal);
+public function subWhere($operator = 'OR');
+public function equals($column, $value);        
+public function notEquals($column, $value);
+public function greaterThan($column, $value);
+public function greaterThanOrEqual($column, $value);
+public function lessThan($column, $value);
+public function lessThanOrEqual($column, $value);
+public function like($column, $value);
+public function notLike($column, $value);
+public function match(array $columns, array $values);
+public function matchBoolean(array $columns, array $values);
+public function matchWithQueryExpansion(array $columns, array $values);
+public function in($column, array $values);
+public function notIn($column, array $values);
+public function between($column, $a, $b);
+public function notBetween($column, $a, $b);
+public function isNull($column);
+public function isNotNull($column);
+public function exists(Select $select);
+public function notExists(Select $select);
+public function addBitClause($column, $value);    
+public function asLiteral($literal);
 ```
 
 <a name="block4.2"></a>

src/Builder/GenericBuilder.php

@@ -28,37 +28,37 @@ class GenericBuilder implements BuilderInterface
      *
      * @var \NilPortugues\Sql\QueryBuilder\Builder\Syntax\PlaceholderWriter
      */
-    private $placeholderWriter;
+    protected $placeholderWriter;
 
     /**
      * The Where writer.
      *
      * @var \NilPortugues\Sql\QueryBuilder\Builder\Syntax\WhereWriter
      */
-    private $whereWriter;
+    protected $whereWriter;
 
     /**
      * The SQL formatter.
      *
      * @var \NilPortugues\Sql\QueryFormatter\Formatter
      */
-    private $sqlFormatter;
+    protected $sqlFormatter;
 
     /**
      * Class namespace for the query pretty output formatter.
      * Required to create the instance only if required.
      *
      * @var string
      */
-    private $sqlFormatterClass = 'NilPortugues\Sql\QueryFormatter\Formatter';
+    protected $sqlFormatterClass = 'NilPortugues\Sql\QueryFormatter\Formatter';
 
     /**
      * Array holding the writers for each query part. Methods are called upon request and stored in
      * the $queryWriterInstances array.
      *
      * @var array
      */
-    private $queryWriterArray = [
+    protected $queryWriterArray = [
         'SELECT' => '\NilPortugues\Sql\QueryBuilder\Builder\Syntax\WriterFactory::createSelectWriter',
         'INSERT' => '\NilPortugues\Sql\QueryBuilder\Builder\Syntax\WriterFactory::createInsertWriter',
         'UPDATE' => '\NilPortugues\Sql\QueryBuilder\Builder\Syntax\WriterFactory::createUpdateWriter',
@@ -74,7 +74,7 @@ class GenericBuilder implements BuilderInterface
      *
      * @var array
      */
-    private $queryWriterInstances = [
+    protected $queryWriterInstances = [
         'SELECT' => null,
         'INSERT' => null,
         'UPDATE' => null,
@@ -107,7 +107,7 @@ public function select($table = null, array $columns = null)
     /**
      * @param \NilPortugues\Sql\QueryBuilder\Manipulation\AbstractBaseQuery
      *
-     *@return \NilPortugues\Sql\QueryBuilder\Manipulation\AbstractBaseQuery
+     * @return \NilPortugues\Sql\QueryBuilder\Manipulation\AbstractBaseQuery
      */
     protected function injectBuilder(AbstractBaseQuery $query)
     {

src/Builder/Syntax/ColumnWriter.php

@@ -23,12 +23,12 @@ class ColumnWriter
     /**
      * @var \NilPortugues\Sql\QueryBuilder\Builder\GenericBuilder
      */
-    private $writer;
+    protected $writer;
 
     /**
      * @var PlaceholderWriter
      */
-    private $placeholderWriter;
+    protected $placeholderWriter;
 
     /**
      * @param GenericBuilder    $writer

src/Builder/Syntax/DeleteWriter.php

@@ -21,12 +21,12 @@ class DeleteWriter
     /**
      * @var GenericBuilder
      */
-    private $writer;
+    protected $writer;
 
     /**
      * @var PlaceholderWriter
      */
-    private $placeholderWriter;
+    protected $placeholderWriter;
 
     /**
      * @param GenericBuilder    $writer

src/Builder/Syntax/InsertWriter.php

@@ -22,12 +22,12 @@ class InsertWriter
     /**
      * @var GenericBuilder
      */
-    private $writer;
+    protected $writer;
 
     /**
      * @var ColumnWriter
      */
-    private $columnWriter;
+    protected $columnWriter;
 
     /**
      * @param GenericBuilder    $writer

src/Builder/Syntax/MinusWriter.php

@@ -21,7 +21,7 @@ class MinusWriter
     /**
      * @var GenericBuilder
      */
-    private $writer;
+    protected $writer;
 
     /**
      * @param GenericBuilder $writer

src/Builder/Syntax/UpdateWriter.php

@@ -50,7 +50,7 @@ public function write(Update $update)
      *
      * @return string
      */
-    private function writeUpdateValues(Update $update)
+    protected function writeUpdateValues(Update $update)
     {
         $assigns = [];
         foreach ($update->getValues() as $column => $value) {

src/Builder/Syntax/WhereWriter.php

@@ -51,6 +51,7 @@ public function writeWhereClauses(Where $where)
         $this->writeWhereIns($where, $whereArray);
         $this->writeWhereNotIns($where, $whereArray);
         $this->writeWhereBetweens($where, $whereArray);
+        $this->writeWhereNotBetweens($where, $whereArray);
         $this->writeWhereComparisons($where, $whereArray);
         $this->writeWhereIsNulls($where, $whereArray);
         $this->writeWhereIsNotNulls($where, $whereArray);
@@ -183,6 +184,32 @@ function (&$between) {
         $whereArray = \array_merge($whereArray, $between);
     }
 
+    /**
+     * @param Where $where
+     * @param array $whereArray
+     *
+     * @return array
+     */
+    protected function writeWhereNotBetweens(Where $where, array &$whereArray)
+    {
+        $between = $where->getNotBetweens();
+        \array_walk(
+            $between,
+            function (&$between) {
+
+                $between = '('
+                    .$this->columnWriter->writeColumn($between['subject'])
+                    .' NOT BETWEEN '
+                    .$this->writer->writePlaceholderValue($between['a'])
+                    .' AND '
+                    .$this->writer->writePlaceholderValue($between['b'])
+                    .')';
+            }
+        );
+
+        $whereArray = \array_merge($whereArray, $between);
+    }
+
     /**
      * @param Where $where
      * @param array $whereArray

src/Manipulation/AbstractBaseQuery.php

@@ -31,7 +31,7 @@ abstract class AbstractBaseQuery implements QueryInterface, QueryPartInterface
     /**
      * @var \NilPortugues\Sql\QueryBuilder\Builder\BuilderInterface
      */
-    private $builder;
+    protected $builder;
 
     /**
      * @var string

src/Manipulation/Intersect.php

@@ -22,7 +22,7 @@ class Intersect implements QueryInterface, QueryPartInterface
     /**
      * @var array
      */
-    private $intersect = [];
+    protected $intersect = [];
 
     /**
      * @return string

src/Manipulation/Minus.php

@@ -22,12 +22,12 @@ class Minus implements QueryInterface, QueryPartInterface
     /**
      * @var Select
      */
-    private $first;
+    protected $first;
 
     /**
      * @var Select
      */
-    private $second;
+    protected $second;
 
     /**
      * @return string

src/Syntax/SyntaxFactory.php

@@ -74,11 +74,10 @@ public static function createColumn(array &$argument, $table = null)
      */
     public static function createTable($table)
     {
+        $tableName = $table;
         if (\is_array($table)) {
             $tableName = \current($table);
             $tableAlias = \key($table);
-        } else {
-            $tableName = $table;
         }
 
         $newTable = new Table($tableName);

src/Syntax/Where.php

@@ -38,72 +38,77 @@ class Where
     /**
      * @var array
      */
-    private $comparisons = [];
+    protected $comparisons = [];
 
     /**
      * @var array
      */
-    private $betweens = [];
+    protected $betweens = [];
 
     /**
      * @var array
      */
-    private $isNull = [];
+    protected $isNull = [];
 
     /**
      * @var array
      */
-    private $isNotNull = [];
+    protected $isNotNull = [];
 
     /**
      * @var array
      */
-    private $booleans = [];
+    protected $booleans = [];
 
     /**
      * @var array
      */
-    private $match = [];
+    protected $match = [];
 
     /**
      * @var array
      */
-    private $ins = [];
+    protected $ins = [];
 
     /**
      * @var array
      */
-    private $notIns = [];
+    protected $notIns = [];
 
     /**
      * @var array
      */
-    private $subWheres = [];
+    protected $subWheres = [];
 
     /**
      * @var string
      */
-    private $conjunction = self::CONJUNCTION_AND;
+    protected $conjunction = self::CONJUNCTION_AND;
 
     /**
      * @var QueryInterface
      */
-    private $query;
+    protected $query;
 
     /**
      * @var Table
      */
-    private $table;
+    protected $table;
 
     /**
      * @var array
      */
-    private $exists = [];
+    protected $exists = [];
 
     /**
      * @var array
      */
-    private $notExists = [];
+    protected $notExists = [];
+
+    /**
+     * @var array
+     */
+    protected $notBetweens = [];
 
     /**
      * @param QueryInterface $query
@@ -252,7 +257,7 @@ public function equals($column, $value)
      *
      * @return $this
      */
-    public function compare($column, $value, $operator)
+    protected function compare($column, $value, $operator)
     {
         $column = $this->prepareColumn($column);
 
@@ -270,7 +275,7 @@ public function compare($column, $value, $operator)
      *
      * @return Column|Select
      */
-    private function prepareColumn($column)
+    protected function prepareColumn($column)
     {
         //This condition handles the "Select as a a column" special case.
         if ($column instanceof Select) {
@@ -463,6 +468,21 @@ public function between($column, $a, $b)
         return $this;
     }
 
+    /**
+     * @param string $column
+     * @param int    $a
+     * @param int    $b
+     *
+     * @return $this
+     */
+    public function notBetween($column, $a, $b)
+    {
+        $column = $this->prepareColumn($column);
+        $this->notBetweens[] = ['subject' => $column, 'a' => $a, 'b' => $b];
+
+        return $this;
+    }
+
     /**
      * @param string $column
      *
@@ -575,6 +595,14 @@ public function getBetweens()
         return $this->betweens;
     }
 
+    /**
+     * @return array
+     */
+    public function getNotBetweens()
+    {
+        return $this->notBetweens;
+    }
+
     /**
      * @return array
      */

tests/Builder/Syntax/WhereWriterTest.php

@@ -272,6 +272,25 @@ public function itShouldBeAbleToLetWhereStatementWriteBetweenConditions()
         $this->assertEquals($expected, $this->writer->getValues());
     }
 
+    /**
+     * @test
+     */
+    public function itShouldBeAbleToLetWhereStatementWriteNotBetweenConditions()
+    {
+        $column = 'user_id';
+
+        $this->query
+            ->setTable('user')
+            ->where()
+            ->notBetween($column, 1, 2);
+
+        $expected = 'SELECT user.* FROM user WHERE (user.user_id NOT BETWEEN :v1 AND :v2)';
+        $this->assertSame($expected, $this->writer->write($this->query));
+
+        $expected = array(':v1' => 1, ':v2' => 2);
+        $this->assertEquals($expected, $this->writer->getValues());
+    }
+
     /**
      * @test
      */