Fix bug: using both property walking and a mapping that referenced th…

…e same association property caused duplicate aliases to be created.

features/subquery.feature

@@ -164,4 +164,64 @@ Feature: Sub-queries
         )
       }.all()
       """
+
+  Scenario: Using both property('../propName') walking and mapping for the same association property at the same time (bug: query exception due to duplicate alias being created had been created by new property walking code)
+    Given I have created the following "Book" instances:
+      | title                       | authorName |
+      | Lord of the Rings           | Tolkien    |
+      | 20000 Leagues Under the Sea | Verne      |
+    And I have created the following "Author" instances:
+      | name      |
+      | Tolkien   |
+      | Verne     |
+      | Bernstein |
+    When I execute the following code:
+      """
+      Book.where {
+        id mapTo: 'book_id'
+        author is: notNull
+        author where: {
+          name mapTo: 'author_name'
+        }
+        exists(
+          Book.where {
+            id equals: mapping('book_id')
+            property('../author.name') ne: 'Bernstein'
+            author where: {
+              name equals: mapping('author_name')
+            }
+          }
+        )
+      }.all()
+      """
+    Then I should get the following results:
+      | name     |
+    When I execute the following code:
+      """
+      def book = Book.findByTitle('Lord of the Rings')
+      book.author = Author.findByName('Tolkien')
+      book.save()
+      """
+    And I execute the following code:
+      """
+      Book.where {
+        id mapTo: 'book_id'
+        author is: notNull
+        author where: {
+          name mapTo: 'author_name'
+        }
+        exists(
+          Book.where {
+            id equals: mapping('book_id')
+            property('../author.name') ne: 'Bernstein'
+            author where: {
+              name equals: mapping('author_name')
+            }
+          }
+        )
+      }.all()
+      """
+    Then I should get the following results:
+      | title             |
+      | Lord of the Rings |
 

src/groovy/com/radiadesign/relationalscope/RelationalScope.groovy

@@ -355,16 +355,25 @@ class RelationalScope {
 
   static createAssociationAliasIfNecessary(options, associationPath, associationDescriptor=null) {
     def discriminator = RelationalScope.aliasDiscriminatorFor(options, associationDescriptor)
-    def aliasMap = options.associationAliases[discriminator]
+    def optionsOrAssociationDescriptor = (associationDescriptor ?: options)
+    def aliasMap = optionsOrAssociationDescriptor.associationAliases[discriminator]
     if (!aliasMap) {
-      aliasMap = options.associationAliases[discriminator] = [:]
+      aliasMap = optionsOrAssociationDescriptor.associationAliases[discriminator] = [:]
     }
     if (!aliasMap[associationPath]) {
       def alias = "${discriminator}_${associationPath.replace('.', '_')}"
-      (associationDescriptor ?: options).criteria
-                                        .createAlias( associationPath,
-                                                      alias,
-                                                      CriteriaSpecification.LEFT_JOIN )
+      println "\n\n\ncreating alias: '${alias}' with discriminator '${discriminator}'\n"
+      println "already had aliases:\n${options.associationAliases.inspect()}\n\n"
+      /*try {
+        throw new Exception()
+      } catch (e) {
+        e.printStackTrace()
+      }*/
+
+      optionsOrAssociationDescriptor.criteria
+                                    .createAlias( associationPath,
+                                                  alias,
+                                                  CriteriaSpecification.LEFT_JOIN )
       aliasMap[associationPath] = alias
     }
   }
@@ -427,7 +436,7 @@ class RelationalScope {
       }
 
       def discriminator = RelationalScope.aliasDiscriminatorFor(options, associationDescriptor)
-      def discriminatedAliases = options.associationAliases[discriminator]
+      def discriminatedAliases = (associationDescriptor ?: options).associationAliases[discriminator]
       assert discriminatedAliases : "An association was used for which no alias has been created"
       alias = discriminatedAliases[associationPath]
       assert alias : "An association was used for which no alias has been created"
@@ -443,6 +452,7 @@ class RelationalScope {
       associationDomainProperty: associationDomainProperty,
       isDetachedCriteria: options.isDetachedCriteria,
       detachedCriteriaCount: options.getDetachedCriteriaCount(),
+      associationAliases: options.associationAliases,
       criteria: options.criteria
     )
   }