Merge branch 'release-1.2.8'

Author: Lebugg

README.md

@@ -264,7 +264,7 @@ class User extends SimpleAR\Model
 {
     ...
 
-    protected $_columns = array(
+    protected static $_columns = array(
         'last_name',
         'first_name',
         'age',
@@ -279,7 +279,7 @@ class User extends SimpleAR\Model
 {
     ...
 
-    protected $_columns = array(
+    protected static $_columns = array(
         'last_name',
         'first_name',
         // “age” will be used for “years_since_birth” column.

lib/Database/Builder.php

@@ -220,10 +220,9 @@ public function addValueToQuery($value, $component = '')
     {
         if ($component)
         {
-            if (! $value instanceof Expression)
-            {
-                $this->_values[$component][] = $value;
-            }
+            // Any check on value type (Model instance, Expression...) is made
+            // in Query::prepareValuesForExecution().
+            $this->_values[$component][] = $value;
         }
         else
         {

lib/Database/Builder/DeleteBuilder.php

@@ -21,10 +21,9 @@ public function root($root)
             $this->_components['deleteFrom'] = $root; return;
         }
 
-        // We *have to* set the alias and not the table name. Since this is the 
-        // root that we are setting, we know its place in the arborescence. 
-        // Thus, we just have to generate its alias out of the table name.
-        $tableAlias = $this->_getAliasForTableName($this->_table->name);
-        $this->_components['deleteFrom'] = $tableAlias;
+        // Using several tables is not yet possible with delete builder. Thus, 
+        // we set the table name in "deleteFrom" component. We won't bother with 
+        // any table alias.
+        $this->_components['deleteFrom'] = $this->_table->name;
     }
 }

lib/Database/Builder/SelectBuilder.php

@@ -118,18 +118,29 @@ public function offset($offset)
     /**
      * Eager load another table.
      *
-     * If if you give a deep relation to eager load, columns of every middle 
+     * If you give a deep relation to eager load, columns of every middle
      * tables will be selected. For example, if you do:
      *
      *  `$builder->with('articles/author')`
      *
      * authors' *and* articles' columns will be selected.
      *
-     * @param string $relation The model relation name relative to the root
-     * model.
+     * @param string|array $relation The model relation name relative to the root
+     * model *or* an array of relation names.
      */
     public function with($relation)
     {
+        // Handle multiple relations.
+        if (is_array($relation))
+        {
+            foreach ($relation as $rel)
+            {
+                $this->with($rel);
+            }
+
+            return $this;
+        }
+
         // We have two things to do:
         //  1) Include related table;
         //  2) Select related table columns.

lib/Database/Builder/UpdateBuilder.php

@@ -23,7 +23,7 @@ public function root($root)
             $this->_components['updateFrom'] = $root; return;
         }
 
-        $joinClause = new JoinClause($this->_table->name,  '');
+        $joinClause = new JoinClause($this->_table->name, $this->getRootAlias());
         $this->_components['updateFrom'] = array($joinClause);
 
         return $this;

lib/Database/Builder/WhereBuilder.php

@@ -1,22 +1,15 @@
 <?php namespace SimpleAR\Database\Builder;
 
 use \SimpleAR\Database\Builder;
-// use \SimpleAR\Database\Condition\Exists as ExistsCond;
-// use \SimpleAR\Database\Condition\Nested as NestedCond;
-// use \SimpleAR\Database\Condition\Simple as SimpleCond;
-// use \SimpleAR\Database\Condition\Attribute as AttrCond;
-// use \SimpleAR\Database\Condition\SubQuery as SubQueryCond;
 use \SimpleAR\Database\Expression;
 use \SimpleAR\Database\JoinClause;
 use \SimpleAR\Database\Query;
-
 use \SimpleAR\Exception\MalformedOptionException;
 use \SimpleAR\Exception;
-
 use \SimpleAR\Facades\Cfg;
 use \SimpleAR\Facades\DB;
-
 use \SimpleAR\Orm\Relation;
+use \SimpleAR\Orm\Relation\ManyMany;
 use \SimpleAR\Orm\Table;
 
 class WhereBuilder extends Builder
@@ -100,6 +93,13 @@ public function where($attribute, $op = null, $val = null, $logic = 'AND', $not
                 return;
             }
 
+            // User wants a WHERE NULL condition.
+            if ($val === null)
+            {
+                $this->whereNull($attribute, $logic, $op === '!=');
+                return;
+            }
+
             list($table, $cols) = $this->_processExtendedAttribute($attribute);
 
             $type = 'Basic';
@@ -185,6 +185,32 @@ public function whereIn($attribute, $val, $logic = 'AND', $not = false)
         $this->_addWhere($cond, $val);
     }
 
+    /**
+     * Add a WHERE NULL clause to the query.
+     *
+     * @param string $attribute The extended attribute.
+     * @param string $logic The logical operator.
+     */
+    public function whereNull($attribute, $logic = 'AND', $not = false)
+    {
+        list($table, $cols) = $this->_processExtendedAttribute($attribute);
+
+        $type = 'Null';
+        $cond = compact('type', 'table', 'cols', 'logic', 'not');
+        $this->_addWhere($cond);
+    }
+
+    /**
+     * Add a WHERE NOT NULL clause to the query.
+     *
+     * @param string $attribute The extended attribute.
+     * @param string $logic The logical operator.
+     */
+    public function whereNotNull($attribute, $logic)
+    {
+        $this->whereNull($attributes, $logic, true);
+    }
+
     /**
      * Get the separation character of relation names in options.
      *
@@ -440,7 +466,7 @@ public function addInvolvedTable($tableAlias, $joinType = JoinClause::INNER)
                 $this->setInvolvedModel($alias, $currentModel);
                 $this->setInvolvedTable($alias, $currentTable);
                 $this->_addJoinClause(
-                    $currentTable, $alias,
+                    $currentTable->name, $alias,
                     $currentRel, $previousAlias,
                     $joinType
                 );
@@ -461,6 +487,12 @@ public function getNextRelationByModel($model, $relation)
         return $model::relation($relation);
     }
 
+    /**
+     * Return the linked model class name of a relation.
+     *
+     * @param Relation $relation The relation
+     * @return string The linked model class name.
+     */
     public function getNextModelByRelation(Relation $relation)
     {
         return $relation->lm->class;
@@ -477,36 +509,67 @@ public function getNextModelByRelation(Relation $relation)
      * @param Table
      * @param string
      */
-    protected function _addJoinClause(Table $toJoin, $toJoinAlias,
-        Relation $rel = null, $previousAlias = '',
+    protected function _addJoinClause($lmTable, $lmAlias,
+        Relation $rel = null, $cmAlias = '',
         $joinType = JoinClause::INNER
     ) {
-        $jc = new JoinClause($toJoin->name, $toJoinAlias, $joinType);
+
+        // If relation cardinality is many-to-many, we must join middle table.
+        if ($rel instanceof ManyMany)
+        {
+            // _addJoinClauseManyMany returns the alias of the middle table. We 
+            // are going to use it to join the middle table with the LM table.
+            $cmAlias = $this->_addJoinClauseManyMany($rel, $cmAlias, $joinType);
+        }
+
+        $jc = new JoinClause($lmTable, $lmAlias, $joinType);
 
         // We may have to connect it to a previous JoinClause.
         if ($rel)
         {
             // $rel->cm corresponds to previous model.
             foreach ($rel->getJoinColumns() as $leftCol => $rightCol)
             {
-                $jc->on($previousAlias, $leftCol, $toJoinAlias, $rightCol);
+                $jc->on($cmAlias, $leftCol, $lmAlias, $rightCol);
             }
         }
 
-        $this->_joinClauses[$toJoinAlias] = $jc;
+        $this->_joinClauses[$lmAlias] = $jc;
+    }
+
+    protected function _addJoinClauseManyMany(ManyMany $rel, $cmAlias, $joinType)
+    {
+        // $md stands for "middle".
+        $mdTable = $rel->getMiddleTableName();
+        $mdAlias = $rel->getMiddleTableAlias();
+        $jcMiddle = new JoinClause($mdTable, $mdAlias, $joinType);
+
+        foreach ($rel->getMiddleJoinColumns() as $lCol => $rCol)
+        {
+            $jcMiddle->on($cmAlias, $lCol, $mdAlias, $rCol);
+        }
+
+        $this->_joinClauses[$mdAlias] = $jcMiddle;
+
+        return $mdAlias;
     }
 
     /**
      * Add a condition to the list of conditions.
      *
      * @param array $cond The condition array
-     * @param mixed $val  The condition's value. It will be add to query's 
-     * values list.
+     *
+     * There is no second optional argument in order to allow function caller to
+     * pass a null value.
      */
-    protected function _addWhere(array $cond, $val = null)
+    protected function _addWhere(array $cond)
     {
         $this->_components['where'][] = $cond;
-        $val && $this->addValueToQuery($val, 'where');
+
+        if (func_num_args() > 1)
+        {
+            $this->addValueToQuery(func_get_arg(1), 'where');
+        }
     }
 
     /**
@@ -621,6 +684,12 @@ protected function _processExtendedAttribute($attribute)
             return array('', (array) $attribute->val());
         }
 
+        // We don't use model? Can't do nothing for you.
+        if (! $this->_useModel)
+        {
+            return array('', (array) $attribute);
+        }
+
         // 1)
         list($relations, $attribute) = $this->separateAttributeFromRelations($attribute);
 

lib/Database/Compiler.php

@@ -1,7 +1,5 @@
 <?php namespace SimpleAR\Database;
 
-require __DIR__ . '/Compiler/InsertCompiler.php';
-
 use \SimpleAR\Database\Query;
 use \SimpleAR\Database\Expression;
 
@@ -14,13 +12,16 @@ abstract class Compiler
      * raw table name given in constructor. In this case, we would not be able to
      * use many features like process query on linked models.
      *
-     * Property's value is set when starting the compilation step. Each public 
-     * compile can decide whether to use table alias or not depending on number 
+     * Property's value is set when starting the compilation step. Each public
+     * compile can decide whether to use table alias or not depending on number
      * of used tables or things like that.
      *
+     * If $useTableAlias is null when compilation starts, the compiler will 
+     * decide himself whether to use table aliases or not.
+     *
      * @var bool
      */
-    public $useTableAlias = false;
+    public $useTableAlias = null;
 
     public $useResultAlias = false;
 
@@ -166,6 +167,17 @@ protected function _compileAlias($identifier, $alias = '')
      */
     public function parameterize($value)
     {
+        // This allows users to directly pass object or object array as
+        // a condition value.
+        //
+        // The same check is done in Compiler to correctly construct
+        // query.
+        // @see SimpleAR\Database\Compiler::parameterize()
+        if ($value instanceof \SimpleAR\Orm\Model)
+        {
+            $value = $value->id();
+        }
+
         if (is_array($value))
         {
             // This line is taken from: