Changeset 4455 for trunk/lib/Doctrine

Timestamp:

05/28/08 07:01:04 (8 months ago)

Author:

guilhermeblanco

Message:

SelectExpression? rewrite to support dctrn queryComponent. Fixes in DQL. Added more test cases

Location:

trunk/lib/Doctrine/Query

Files:

• ParserResult.php (modified) (2 diffs)
• Production.php (modified) (1 diff)
• Production/FieldIdentificationVariable.php (modified) (2 diffs)
• Production/GroupByClause.php (modified) (1 diff)
• Production/PathExpression.php (modified) (4 diffs)
• Production/SelectExpression.php (modified) (3 diffs)

trunk/lib/Doctrine/Query/ParserResult.php

@@ -87 +87 @@
      * @param string $queryField Alias declaration.
      */
-    public function setQueryField($fieldAlias, array $queryField)
+    public function setQueryField($fieldAlias, $queryField)
     {
         $this->_queryFields[$fieldAlias] = $queryField;
@@ -100 +100 @@
     public function getQueryFields()
     {
-        return $this->_queryComponents;
+        return $this->_queryFields;
     }
 

trunk/lib/Doctrine/Query/Production.php

@@ -37 +37 @@
 {
     /**
+     * @nodoc
+     */
+    const SQLALIAS_SEPARATOR = '__';
+
+
+    /**
+     * @nodoc
+     */
+    const DEFAULT_QUERYCOMPONENT = 'dctrn';
+
+
+    /**
      * Parser object
      *

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

@@ -33 +33 @@
 class Doctrine_Query_Production_FieldIdentificationVariable extends Doctrine_Query_Production
 {
-    protected $_componentAlias;
+    protected $_fieldAlias;
+
+    protected $_columnAlias;
 
 
@@ -50 +52 @@
         if ($parserResult->hasQueryField($this->_fieldAlias)) {
             // We should throw semantical error if there's already a component for this alias
-            $queryComponent = $parserResult->getQueryField($this->_fieldAlias);
-            $fieldName = $queryComponent['fieldName'];
+            $fieldName = $parserResult->getQueryField($this->_fieldAlias);
 
             $message  = "Cannot re-declare field alias '{$this->_fieldAlias}'"
-                      . "for '".$paramHolder->get('fieldName')."'. It was already declared for "
-                      . "field '{$fieldName}'.";
+                      . "for '".$paramHolder->get('fieldName')."'.";
 
             $this->_parser->semanticalError($message);
         }
+
+        // Now we map it in queryComponent
+        $componentAlias = Doctrine_Query_Production::DEFAULT_QUERYCOMPONENT;
+        $queryComponent = $parserResult->getQueryComponent($componentAlias);
+
+        $idx = count($queryComponent['scalar']);
+        $queryComponent['scalar'][$idx] = $this->_fieldAlias;
+        $parserResult->setQueryComponent($componentAlias, $queryComponent);
+
+        // And also in field aliases
+        $parserResult->setQueryField($queryComponent['scalar'][$idx], $idx);
+
+        // Build the column alias
+        $this->_columnAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias)
+                            . Doctrine_Query_Production::SQLALIAS_SEPARATOR . $idx;
     }
 }

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

@@ -53 +53 @@
     public function buildSql()
     {
-        return 'GROUP BY ' . implode(', ', $this->_mapGroupByItems()) . ')';
+        return 'GROUP BY ' . implode(', ', $this->_mapGroupByItems());
     }
 

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

@@ -38 +38 @@
     protected $_fieldName;
 
-    protected $_queryComponent;
+    protected $_componentAlias;
 
 
@@ -74 +74 @@
             // Retrieve ClassMetadata
             $k = array_keys($queryComponents);
-            $componentAlias = $k[1];
+            $this->_componentAlias = $k[1];
 
-            $this->_queryComponent = $queryComponents[$componentAlias];
-            $classMetadata = $this->_queryComponent['metadata'];
+            $classMetadata = $queryComponents[$this->_componentAlias]['metadata'];
         } else {
-            $path = $this->_identifiers[0];
-            $this->_queryComponent = $parserResult->getQueryComponent($path);
+            $this->_componentAlias = $path = $this->_identifiers[0];
+            $queryComponent = $parserResult->getQueryComponent($path);
 
             // We should have a semantical error if the queryComponent does not exists yet
-            if ($this->_queryComponent === null) {
+            if ($queryComponent === null) {
                 $this->_parser->semanticalError("Undefined component alias for '{$path}'", $this->_parser->token);
             }
 
             // Initializing ClassMetadata
-            $classMetadata = $this->_queryComponent['metadata'];
+            $classMetadata = $queryComponent['metadata'];
 
             // Looping through relations
@@ -109 +108 @@
                 }
 
-                // Assigning new queryComponent and classMetadata
-                $this->_queryComponent = $parserResult->getQueryComponent($path);
+                // Assigning new componentAlias, queryComponent and classMetadata
+                $this->_componentAlias = $path;
 
-                $classMetadata = $this->_queryComponent['metadata'];
+                $queryComponent = $parserResult->getQueryComponent($path);
+                $classMetadata = $queryComponent['metadata'];
             }
         }
@@ -134 +134 @@
         $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];
-        }
+        // Looking for queryComponent to fetch
+        $queryComponent = $parserResult->getQueryComponent($this->_componentAlias);
 
         // Generating the SQL piece
-        $str = $parserResult->getTableAliasFromComponentAlias($componentAlias) . '.'
-             . $this->_queryComponent['metadata']->getColumnName($this->_fieldName);
+        $str = $parserResult->getTableAliasFromComponentAlias($this->_componentAlias) . '.'
+             . $queryComponent['metadata']->getColumnName($this->_fieldName);
 
         return $conn->quoteIdentifier($str);

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

@@ -87 +87 @@
         $parserResult = $this->_parser->getParserResult();
 
-        // Here we inspect for duplicate IdentificationVariable, and if the
-        // left expression needs the identification variable. If yes, check
-        // its existance.
+        // We cannot have aliases for foo.*
         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)."
+                "Cannot assign an identification variable to a path expression ending with asterisk (ie. foo.bar.* AS foobaz)."
             );
         }
 
+        // Also, we cannot have aliases for path expressions: foo.bar
+        if ($this->_leftExpression instanceof Doctrine_Query_Production_PathExpressionEndingWithAsterisk && $this->_fieldIdentificationVariable !== null) {
+            $this->_parser->semanticalError(
+                "Cannot assign an identification variable to a path expression (ie. foo.bar AS foobaz)."
+            );
+        }
+
+        // Make semantical checks
         $this->_leftExpression->semantical($paramHolder);
 
@@ -128 +134 @@
         $parserResult = $this->_parser->getParserResult();
 
+        // Retrieving connection
+        $manager = Doctrine_EntityManager::getManager(); 
+        $conn = $manager->getConnection();
+
         switch (get_class($this->_leftExpression)) {
             case 'Doctrine_Query_Production_PathExpressionEndingWithAsterisk':
@@ -135 +145 @@
             case 'Doctrine_Query_Production_PathExpression':
                 // We bring the queryComponent from the class instance
-                $queryComponent = $this->_leftExpression->getQueryComponent();
+                $componentAlias = $this->_leftExpression->getComponentAlias();
+                $queryComponent = $parserResult->getQueryComponent($componentAlias);
+                $fieldName = $this->_leftExpression->getFieldName();
+
+                // Build the column alias now
+                $columnAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias)
+                             . Doctrine_Query_Production::SQLALIAS_SEPARATOR
+                             . $queryComponent['metadata']->getColumnName($fieldName);
             break;
 
             default:
                 // We bring the default queryComponent
-                $queryComponent = $parserResult->getQueryComponent('dctrn');
+                $componentAlias = Doctrine_Query_Production::DEFAULT_QUERYCOMPONENT;
+                $queryComponent = $parserResult->getQueryComponent($componentAlias);
+
+                // If we have FieldIdentificationVariable, we have to use the scalar map of it
+                if ($this->_fieldIdentificationVariable !== null) {
+                    $columnAlias = $this->_fieldIdentificationVariable->getColumnAlias();
+                } else {
+                    // We have to include the map now, since we don't have the scalar mapped
+                    $queryFields = $parserResult->getQueryFields();
+                    $itemIndex = 'item' . count(array_filter($queryFields, array($this, "_nonIdentifiedVariable")));
+                    $idx = count($queryFields);
+
+                    $queryComponent['scalar'][$idx] = $itemIndex;
+                    $parserResult->setQueryComponent($componentAlias, $queryComponent);
+
+                    // And also in field aliases
+                    $parserResult->setQueryField($itemIndex, $idx);
+
+                    // Build the column alias
+                    $columnAlias = $parserResult->getTableAliasFromComponentAlias($componentAlias)
+                                 . Doctrine_Query_Production::SQLALIAS_SEPARATOR . $idx;
+                }
             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);
     }
+
+
+    protected function _nonIdentifiedVariable($value)
+    {
+        return ! is_string($value);
+    }
 }