- "not equals" comparisons of simple many-to-one relation

to an instance will not drop into an EXISTS clause
and will compare foreign key columns instead.

- removed not-really-working use cases of comparing
a collection to an iterable.  Use contains() to test
for collection membership.

- Further simplified SELECT compilation and its relationship
to result row processing.

- Direct execution of a union() construct will properly set up
result-row processing. [ticket:1194]

2 files changed, 30 insertions, 10 deletions

diff --git a/test/orm/query.py b/test/orm/query.py
index 151bada63..567ca317c 100644
--- a/test/orm/query.py
+++ b/test/orm/query.py
@@ -5,6 +5,7 @@ from sqlalchemy import exc as sa_exc, util
 from sqlalchemy.sql import compiler
 from sqlalchemy.engine import default
 from sqlalchemy.orm import *
+from sqlalchemy.orm import attributes
 
 from testlib import *
 from orm import _base
@@ -334,7 +335,16 @@ class OperatorTest(QueryTest, AssertsCompiledSQL):
                         "WHERE users.id = addresses.user_id AND addresses.id = :id_1)"
                     )
 
-        self._test(Address.user == User(id=7), ":param_1 = addresses.user_id")
+        u7 = User(id=7)
+        attributes.instance_state(u7).commit_all()
+        
+        self._test(Address.user == u7, ":param_1 = addresses.user_id")
+
+        self._test(Address.user != u7, "addresses.user_id != :user_id_1 OR addresses.user_id IS NULL")
+
+        self._test(Address.user == None, "addresses.user_id IS NULL")
+
+        self._test(Address.user != None, "addresses.user_id IS NOT NULL")
 
     def test_selfref_relation(self):
         nalias = aliased(Node)
diff --git a/test/sql/testtypes.py b/test/sql/testtypes.py
index 5d10c5750..793695919 100644
--- a/test/sql/testtypes.py
+++ b/test/sql/testtypes.py
@@ -288,7 +288,7 @@ class UnicodeTest(TestBase, AssertsExecutionResults):
     def tearDown(self):
         unicode_table.delete().execute()
 
-    def testbasic(self):
+    def test_round_trip(self):
         assert unicode_table.c.unicode_varchar.type.length == 250
         rawdata = 'Alors vous imaginez ma surprise, au lever du jour, quand une dr\xc3\xb4le de petit voix m\xe2\x80\x99a r\xc3\xa9veill\xc3\xa9. Elle disait: \xc2\xab S\xe2\x80\x99il vous pla\xc3\xaet\xe2\x80\xa6 dessine-moi un mouton! \xc2\xbb\n'
         unicodedata = rawdata.decode('utf-8')
@@ -296,10 +296,6 @@ class UnicodeTest(TestBase, AssertsExecutionResults):
                                        unicode_text=unicodedata,
                                        plain_varchar=rawdata)
         x = unicode_table.select().execute().fetchone()
-        print 0, repr(unicodedata)
-        print 1, repr(x['unicode_varchar'])
-        print 2, repr(x['unicode_text'])
-        print 3, repr(x['plain_varchar'])
         self.assert_(isinstance(x['unicode_varchar'], unicode) and x['unicode_varchar'] == unicodedata)
         self.assert_(isinstance(x['unicode_text'], unicode) and x['unicode_text'] == unicodedata)
         if isinstance(x['plain_varchar'], unicode):
@@ -310,7 +306,21 @@ class UnicodeTest(TestBase, AssertsExecutionResults):
         else:
             self.assert_(not isinstance(x['plain_varchar'], unicode) and x['plain_varchar'] == rawdata)
 
-    def testassert(self):
+    def test_union(self):
+        """ensure compiler processing works for UNIONs"""
+
+        rawdata = 'Alors vous imaginez ma surprise, au lever du jour, quand une dr\xc3\xb4le de petit voix m\xe2\x80\x99a r\xc3\xa9veill\xc3\xa9. Elle disait: \xc2\xab S\xe2\x80\x99il vous pla\xc3\xaet\xe2\x80\xa6 dessine-moi un mouton! \xc2\xbb\n'
+        unicodedata = rawdata.decode('utf-8')
+        unicode_table.insert().execute(unicode_varchar=unicodedata,
+                                       unicode_text=unicodedata,
+                                       plain_varchar=rawdata)
+                                       
+        x = union(unicode_table.select(), unicode_table.select()).execute().fetchone()
+        self.assert_(isinstance(x['unicode_varchar'], unicode) and x['unicode_varchar'] == unicodedata)
+        self.assert_(isinstance(x['unicode_text'], unicode) and x['unicode_text'] == unicodedata)
+        
+
+    def test_assertions(self):
         try:
             unicode_table.insert().execute(unicode_varchar='not unicode')
             assert False
@@ -337,11 +347,11 @@ class UnicodeTest(TestBase, AssertsExecutionResults):
             unicode_engine.dispose()
 
     @testing.fails_on('oracle')
-    def testblanks(self):
+    def test_blank_strings(self):
         unicode_table.insert().execute(unicode_varchar=u'')
         assert select([unicode_table.c.unicode_varchar]).scalar() == u''
 
-    def testengineparam(self):
+    def test_engine_parameter(self):
         """tests engine-wide unicode conversion"""
         prev_unicode = testing.db.engine.dialect.convert_unicode
         prev_assert = testing.db.engine.dialect.assert_unicode
@@ -367,7 +377,7 @@ class UnicodeTest(TestBase, AssertsExecutionResults):
 
     @testing.crashes('oracle', 'FIXME: unknown, verify not fails_on')
     @testing.fails_on('firebird') # "Data type unknown" on the parameter
-    def testlength(self):
+    def test_length_function(self):
         """checks the database correctly understands the length of a unicode string"""
         teststr = u'aaa\x1234'
         self.assert_(testing.db.func.length(teststr).scalar() == len(teststr))