Changeset 4451 for trunk/lib/Doctrine

Timestamp:

05/27/08 04:44:08 (8 months ago)

Author:

guilhermeblanco

Message:

Finished first parts of SELECT support. Two test cases added and passing. Introduced the concept of DCTRN in queryComponent. Added concept of queryField, which validates for already defined fields in SELECT.

Location:

trunk/lib/Doctrine/Query

Files:

• AbstractResult.php (modified) (1 diff)
• Parser.php (modified) (1 diff)
• ParserResult.php (modified) (2 diffs)
• Production/FieldIdentificationVariable.php (added)
• Production/IdentificationVariable.php (modified) (1 diff)
• Production/PathExpression.php (modified) (4 diffs)
• Production/PathExpressionEndingWithAsterisk.php (modified) (5 diffs)
• Production/RangeVariableDeclaration.php (modified) (3 diffs)
• Production/SelectExpression.php (modified) (7 diffs)
• Production/VariableDeclaration.php (modified) (1 diff)

trunk/lib/Doctrine/Query/AbstractResult.php

@@ -133 +133 @@
 
     /**
+     * Get the component alias for a given query component
+     *
+     * @param array $queryComponent The query component
+     * @param string Component alias
+     */
+    public function getComponentAlias($queryComponent)
+    {
+        return array_search($queryComponent, $this->_queryComponents);;
+    }
+
+
+    /**
      * Whether or not this object has a declaration for given component alias.
      *

trunk/lib/Doctrine/Query/Parser.php

@@ -115 +115 @@
     {
         $this->_scanner = new Doctrine_Query_Scanner($dql);
-        $this->_parserResult = new Doctrine_Query_ParserResult();
         $this->_sqlBuilder = Doctrine_Query_SqlBuilder::fromConnection($connection);
         $this->_keywordTable = new Doctrine_Query_Token();
+
+        $this->_parserResult = new Doctrine_Query_ParserResult(
+            '',
+            array( // queryComponent
+                'dctrn' => array(
+                    'metadata' => null,
+                    'parent'   => null,
+                    'relation' => null,
+                    'map'      => null,
+                    'scalar'   => null,
+                ),
+            ),
+            array( // tableAliasMap
+                'dctrn' => 'dctrn',
+            )
+        );
 
         $this->free(true);

trunk/lib/Doctrine/Query/ParserResult.php

@@ -44 +44 @@
     protected $_tableAliasSeeds = array();
 
+    /**
+     * Simple array of keys representing the fields used in query.
+     *
+     * @var array $_queryFields
+     */
+    protected $_queryFields = array();
+
 
     /**
@@ -60 +67 @@
     {
         return $this->_data;
+    }
+
+
+    /**
+     * Defines the mapping fields.
+     *
+     * @param array $queryFields Query fields.
+     */
+    public function setQueryComponents(array $queryFields)
+    {
+        $this->_queryFields = $queryFields;
+    }
+
+
+    /**
+     * Sets the declaration for given field alias.
+     *
+     * @param string $fieldAlias The field alias to set the declaration to.
+     * @param string $queryField Alias declaration.
+     */
+    public function setQueryField($fieldAlias, array $queryField)
+    {
+        $this->_queryFields[$fieldAlias] = $queryField;
+    }
+
+
+    /**
+     * Gets the mapping fields.
+     *
+     * @return array Query fields.
+     */
+    public function getQueryFields()
+    {
+        return $this->_queryComponents;
+    }
+
+
+    /**
+     * Get the declaration for given field alias.
+     *
+     * @param string $fieldAlias The field alias the retrieve the declaration from.
+     * @return array Alias declaration.
+     */
+    public function getQueryField($fieldAlias)
+    {
+        if ( ! isset($this->_queryFields[$fieldAlias])) {
+            throw new Doctrine_Query_Exception('Unknown query field ' . $fieldAlias);
+        }
+
+        return $this->_queryFields[$fieldAlias];
+    }
+
+
+    /**
+     * Whether or not this object has a declaration for given field alias.
+     *
+     * @param string $fieldAlias Field alias the retrieve the declaration from.
+     * @return boolean True if this object has given alias, otherwise false.
+     */
+    public function hasQueryField($fieldAlias)
+    {
+        return isset($this->_queryFields[$fieldAlias]);
     }
 

trunk/lib/Doctrine/Query/Production/IdentificationVariable.php

@@ -25 +25 @@
  * @package     Doctrine
  * @subpackage  Query
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
  * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL

trunk/lib/Doctrine/Query/Production/PathExpression.php

@@ -38 +38 @@
     protected $_fieldName;
 
-    private $_queryComponent;
+    protected $_queryComponent;
 
 
@@ -68 +68 @@
 
             // Check if we have more than one queryComponent defined
-            if (count($queryComponents) != 1) {
+            if (count($queryComponents) != 2) {
                 $this->_parser->semanticalError("Undefined component alias for field '{$this->_fieldName}'", $this->_parser->token);
             }
@@ -74 +74 @@
             // Retrieve ClassMetadata
             $k = array_keys($queryComponents);
-            $componentAlias = $k[0];
+            $componentAlias = $k[1];
 
             $this->_queryComponent = $queryComponents[$componentAlias];
@@ -142 +142 @@
             // Retrieve ClassMetadata
             $k = array_keys($queryComponents);
-            $componentAlias = $k[0];
+            $componentAlias = $k[1];
         }
 

trunk/lib/Doctrine/Query/Production/PathExpressionEndingWithAsterisk.php

@@ -35 +35 @@
     protected $_identifiers = array();
 
+    protected $_queryComponent;
+
 
     public function syntax($paramHolder)
@@ -56 +58 @@
         if (($l = count($this->_identifiers)) > 0) {
             // We are dealing with component{.component}.*
-            $classMetadata = null;
+            $path = $this->_identifiers[0];
+            $this->_queryComponent = $parserResult->getQueryComponent($path);
 
-            for ($i = 0; $i < $l; $i++) {
+            // We should have a semantical error if the queryComponent does not exists yet
+            if ($this->_queryComponent === null) {
+                $this->_parser->semanticalError("Undefined component alias for '{$path}'", $this->_parser->token);
+            }
+
+            // Initializing ClassMetadata
+            $classMetadata = $this->_queryComponent['metadata'];
+
+            // Looping through relations
+            for ($i = 1; $i < $l; $i++) {
                 $relationName = $this->_identifiers[$i];
+                $path .= '.' . $relationName;
 
-                // We are still checking for relations
-                if ( $classMetadata !== null && ! $classMetadata->hasRelation($relationName)) {
+                if ( ! $classMetadata->hasRelation($relationName)) {
                     $className = $classMetadata->getClassName();
 
-                    $this->_parser->semanticalError("Relation '{$relationName}' does not exist in component '{$className}'");
+                    $this->_parser->semanticalError(
+                        "Relation '{$relationName}' does not exist in component '{$className}' when trying to get the path '{$path}'",
+                        $this->_parser->token
+                    );
+                }
 
-                    // Assigning new ClassMetadata
-                    $classMetadata = $classMetadata->getRelation($relationName)->getClassMetadata();
-                } elseif ( $classMetadata === null ) {
-                    $queryComponent = $parserResult->getQueryComponent($relationName);
+                // We inspect for queryComponent of relations, since we are using them
+                if ( ! $parserResult->hasQueryComponent($path)) {
+                    $this->_parser->semanticalError("Cannot use the path '{$path}' without defining it in FROM.", $this->_parser->token);
+                }
 
-                    // We should have a semantical error if the queryComponent does not exists yet
-                    if ($queryComponent === null) {
-                        $this->_parser->semanticalError("Undefined component alias for relation '{$relationName}'");
-                    }
+                // Assigning new queryComponent and classMetadata
+                $this->_queryComponent = $parserResult->getQueryComponent($path);
 
-                    // Initializing ClassMetadata
-                    $classMetadata = $queryComponent['metadata'];
-                }
+                $classMetadata = $this->_queryComponent['metadata'];
             }
         } else {
@@ -86 +98 @@
             $queryComponents = $parserResult->getQueryComponents();
 
-            if (count($queryComponents) != 1) {
+            if (count($queryComponents) != 2) {
                 $this->_parser->semanticalError(
                     "Cannot use * as selector expression for multiple components."
@@ -95 +107 @@
             // since we have it on hands now.
             $k = array_keys($queryComponents);
-            $this->_identifiers[] = $k[0];
+            $componentAlias = $k[1];
+
+            $this->_queryComponent = $queryComponents[$componentAlias];
         }
     }
@@ -102 +116 @@
     public function buildSql()
     {
-        return '';
+        // Basic handy variables
+        $parserResult = $this->_parser->getParserResult();
+
+        // Retrieving connection
+        $manager = Doctrine_EntityManager::getManager(); 
+        $conn = $manager->getConnection();
+
+        // Looking for componentAlias to fetch
+        $componentAlias = implode('.', $this->_identifiers);
+
+        if (count($this->_identifiers) == 0) {
+            $queryComponents = $parserResult->getQueryComponents();
+
+            // Retrieve ClassMetadata
+            $k = array_keys($queryComponents);
+            $componentAlias = $k[1];
+        }
+
+        // Generating the SQL piece
+        $fields = $this->_queryComponent['metadata']->getMappedColumns();
+        $tableAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias);
+        $str = '';
+
+        foreach ($fields as $fieldName => $fieldMap) {
+            $str .= ($str != '') ? ', ' : '';
+
+            // DB Field name
+            $column = $tableAlias . '.' . $this->_queryComponent['metadata']->getColumnName($fieldName);
+            $column = $conn->quoteIdentifier($column);
+
+            // DB Field alias
+            $columnAlias = $tableAlias . '__' . $this->_queryComponent['metadata']->getColumnName($fieldName);
+            $columnAlias = $conn->quoteIdentifier($columnAlias);
+
+            $str .= $column . ' AS ' . $columnAlias;
+        }
+
+        return $str;
     }
 }

trunk/lib/Doctrine/Query/Production/RangeVariableDeclaration.php

@@ -130 +130 @@
                 'relation' => null,
                 'map'      => null,
-                'agg'      => null,
+                'scalar'   => null,
             );
         } catch (Doctrine_Exception $e) {
@@ -174 +174 @@
         for ($i = 1, $l = count($this->_identifiers); $i < $l; $i++) {
             $relationName = $this->_identifiers[$i];
-            $path = '.' . $relationName;
+            $path .= '.' . $relationName;
 
             if ($parserResult->hasQueryComponent($path)) {
@@ -212 +212 @@
                         'relation' => $relation,
                         'map'      => null,
-                        'agg'      => null,
+                        'scalar'   => null,
                     );
 

trunk/lib/Doctrine/Query/Production/SelectExpression.php

@@ -39 +39 @@
     protected $_isSubselect;
 
-    protected $_identificationVariable;
+    protected $_fieldIdentificationVariable;
 
     private $__columnAliasInSql;
@@ -52 +52 @@
         if ($this->_isPathExpressionEndingWithAsterisk()) {
             $this->_leftExpression = $this->AST('PathExpressionEndingWithAsterisk', $paramHolder);
+
+            $fieldName = implode('.', $this->_leftExpression->getIdentifiers()) . '.*';
         } elseif(($this->_isSubselect = $this->_isSubselect()) === true) {
             $this->_parser->match('(');
             $this->_leftExpression = $this->AST('Subselect', $paramHolder);
             $this->_parser->match(')');
+
+            // [TODO] Any way to make it more fancy for user error?
+            $fieldName = '<Subselect>';
         } else {
             $this->_leftExpression = $this->AST('Expression', $paramHolder);
+
+            // [TODO] Any way to make it more fancy for user error?
+            $fieldName = '<Expression>';
         }
 
@@ -65 +73 @@
 
         if ($this->_isNextToken(Doctrine_Query_Token::T_IDENTIFIER)) {
-            $this->_identificationVariable = $this->AST('IdentificationVariable', $paramHolder);
+            $paramHolder->set('fieldName', $fieldName);
+
+            // Will return an identifier, with the semantical check already applied
+            $this->_fieldIdentificationVariable = $this->AST('FieldIdentificationVariable', $paramHolder);
+
+            $paramHolder->remove('fieldName');
         }
     }
@@ -72 +85 @@
     public function semantical($paramHolder)
     {
+        $parserResult = $this->_parser->getParserResult();
+
         // Here we inspect for duplicate IdentificationVariable, and if the
         // left expression needs the identification variable. If yes, check
         // its existance.
-        if ($this->_leftExpression instanceof Doctrine_Query_Production_PathExpressionEndingWithAsterisk && $this->_identificationVariable !== null) {
+        if ($this->_leftExpression instanceof Doctrine_Query_Production_PathExpressionEndingWithAsterisk && $this->_fieldIdentificationVariable !== null) {
             $this->_parser->semanticalError(
                 "Cannot assign an identification variable to a path expression with asterisk (ie. foo.bar.* AS foobaz)."
@@ -83 +98 @@
         $this->_leftExpression->semantical($paramHolder);
 
-        /*if ($this->_identificationVariable !== null) {
-            if ($this->_leftExpression instanceof Doctrine_Query_Production_PathExpression) {
-                // We bring the queryComponent from the class instance
-                // $queryComponent = $this->_leftExpression->getQueryComponent();
-            } else {
-                // We bring the default queryComponent
-                // $queryComponent = $parserResult->getQueryComponent(null);
-            }
-
-            $idx = count($queryComponent['scalar']);
-            $this->__columnAliasInSql .= '__' . $idx;
-
-            $queryComponent['scalar'][$idx] = $this->_identificationVariable;
-
-            //$parserResult->setQueryComponent($componentAlias, $queryComponent);
-        }*/
-
-        // We need to add scalar in queryComponent the item alias if identificationvariable is set.
-        //echo "SelectExpression:\n";
-        //echo get_class($this->_leftExpression) . "\n";
-
-        // The check for duplicate IdentificationVariable was already done
+        if($this->_fieldIdentificationVariable !== null) {
+            $this->_fieldIdentificationVariable->semantical($paramHolder);
+        }
     }
 
@@ -110 +106 @@
     public function buildSql()
     {
-        return $this->_leftExpression->buildSql();// . ' AS ' . (($this->_identificationVariable !== null) ? $this->_identificationVariable : '');
+        return $this->_leftExpression->buildSql() . $this->_buildColumnAliasInSql();
     }
 
@@ -125 +121 @@
         return $token['value'] === '*';
     }
+
+
+    protected function _buildColumnAliasInSql()
+    {
+        // Retrieving parser result
+        $parserResult = $this->_parser->getParserResult();
+
+        switch (get_class($this->_leftExpression)) {
+            case 'Doctrine_Query_Production_PathExpressionEndingWithAsterisk':
+                return '';
+            break;
+
+            case 'Doctrine_Query_Production_PathExpression':
+                // We bring the queryComponent from the class instance
+                $queryComponent = $this->_leftExpression->getQueryComponent();
+            break;
+
+            default:
+                // We bring the default queryComponent
+                $queryComponent = $parserResult->getQueryComponent('dctrn');
+            break;
+        }
+
+        // Retrieving connection
+        $manager = Doctrine_EntityManager::getManager(); 
+        $conn = $manager->getConnection();
+
+        $componentAlias = $parserResult->getComponentAlias($queryComponent);
+
+        if ($this->_fieldIdentificationVariable !== null) {
+            // We need to add scalar map in queryComponent if iidentificationvariable is set.
+            $idx = count($queryComponent['scalar']);
+            $queryComponent['scalar'][$idx] = $this->_fieldIdentificationVariable;
+            $parserResult->setQueryComponent($componentAlias, $queryComponent);
+
+            $columnAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias) . '__' . $idx;
+        } elseif ($this->_leftExpression instanceof Doctrine_Query_Production_PathExpression) {
+            // We need to build the column alias based on column name
+            $columnAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias) 
+                         . '__' . $queryComponent['metadata']->getColumnName($this->_leftExpression->getFieldName());
+        } else {
+            // The right thing should be return the index alone... but we need a better solution.
+            // Possible we can search the index for mapped values and add our item there.
+
+            // [TODO] Find another return value. We cant return 0 here.
+            $columnAlias = 'idx__' . 0;
+        }
+
+        return ' AS ' . $conn->quoteIdentifier($columnAlias);
+    }
 }

trunk/lib/Doctrine/Query/Production/VariableDeclaration.php

@@ -97 +97 @@
                     'relation' => null,
                     'map'      => null,
-                    'agg'      => null,
+                    'scalar'   => null,
                 );
             } catch (Doctrine_Exception $e) {