Add pytest configuration, added missing kwargs

The get_select_precolumns and limit_clause functions were
missing the kwargs argument.

Fixed typo with the DISTINCT keyword.

We were returning the wrong name from the get_foreign_keys
function.

Removed the nose configuration, replaced with pytest.

Change-Id: I80e06d8d238204c6d5e1e7fbf28d9812fd0464a6

Author: gperrow-SAP

setup.cfg

@@ -1,26 +1,11 @@
-[nosetests]
-with-sqla_testing = true
-where = test
-cover-package = sqlalchemy_sqlany
-with-coverage = false
-cover-erase = false
-stop = false
-verbosity=1
-nocapture = true
-exclude=test_float_custom_scale|test_((numeric|float)_as|render_literal|precision)_(numeric|decimal|float)|test_row_w_scalar_select|test_literal_backslashes
-
-# Some numeric tests are excluded because of the way the SQL Anywhere python
-# driver retrieves floating point numbers. The values retrieved are correct, but
-# sometimes have more precision than the test expects.
-
-# The literal backslash test fails because it assumes that both "\" and "\\" are
-# unchanged. But in SQL Anywhere, "\\" is changed to a single "\" and so the
-# test fails.
-
 [sqla_testing]
 requirement_cls=test.requirements:Requirements
 profile_file=.profiles.txt
 
+[tool:pytest]
+addopts= --tb native -v -r fxX --maxfail=25 -p no:warnings
+python_files=test/*test_*.py
+
 [db]
 default=sqlalchemy_sqlany://dba:sql@localhost:2638/
 

setup.py

@@ -1,5 +1,5 @@
 import os,re
-from setuptools import setup, find_packages
+from setuptools import setup
 
 with open( os.path.join( os.path.dirname(__file__), 'sqlalchemy_sqlany',
                               '__init__.py' ) ) as v:
@@ -38,6 +38,8 @@
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
         'Topic :: Database',
         'Topic :: Software Development :: Libraries :: Python Modules'
         ]

sqlalchemy_sqlany/__init__.py

@@ -1,7 +1,7 @@
 # Copyright 2015 SAP AG or an SAP affiliate company.
 # 
 
-__version__ = '1.0.2'
+__version__ = '1.0.3'
 
 from sqlalchemy_sqlany import base
 

sqlalchemy_sqlany/base.py

@@ -81,14 +81,14 @@
     ])
 
 class SQLAnyNoPrimaryKeyError(Exception):
-    ''' exception that is raised when trying to load the primary keys for a 
+    """ exception that is raised when trying to load the primary keys for a 
     table that does not have any columns marked as being a primary key. 
     As noted in this documentation: 
     http://docs.sqlalchemy.org/en/latest/faq.html#how-do-i-map-a-table-that-has-no-primary-key
     if a table has fully duplicate rows, and has no primary key, it cannot be mapped.
     Since we can't tell if a table has rows that are 'supposed' to act like a primary key,
     we just throw an exception and hopes the user adds primary keys to the table instead.
-    '''
+    """
 
     def __init__(self, message, table_name):
 
@@ -310,8 +310,8 @@ class SQLAnySQLCompiler(compiler.SQLCompiler):
         'milliseconds': 'millisecond'
     })
 
-    def get_select_precolumns(self, select):
-        s = "DISTINCT" if select._distinct else ""
+    def get_select_precolumns(self, select, **kw ):
+        s = "DISTINCT " if select._distinct else ""
         if select._limit:
             if select._limit == 1:
                 s += "FIRST "
@@ -322,12 +322,16 @@ def get_select_precolumns(self, select):
                 # SQL Anywhere doesn't allow "start at" without "top n"
                 s += "TOP ALL "
             s += "START AT %s " % (select._offset + 1,)
-        return s
+        if s != '':
+            return s
+        return compiler.SQLCompiler.get_select_precolumns(
+            self, select, **kw)
+
 
     def get_from_hint_text(self, table, text):
         return text
 
-    def limit_clause(self, select):
+    def limit_clause(self, select, **kw):
         # Limit in sybase is after the select keyword
         return ""
 
@@ -466,6 +470,11 @@ def initialize(self, connection):
         super(SQLAnyDialect, self).initialize(connection)
         self.max_identifier_length = 128
 
+        VERSION_SQL = text('select @@version')
+        result = connection.execute(VERSION_SQL)
+        vers = result.scalar()
+        self.server_version_info = tuple( vers.split(' ')[0].split( '.' ) )
+
     def get_table_id(self, connection, table_name, schema=None, **kw):
         """Fetch the id for schema.table_name.
 
@@ -592,10 +601,12 @@ def get_foreign_keys(self, connection, table_name, schema=None, **kw):
         column_cache[table_id] = columns
 
         REFCONSTRAINT_SQL = text("""
-          SELECT fk.foreign_index_id, pt.table_name AS name, pt.table_id AS reftable_id
+          SELECT fk.foreign_index_id, i.index_name AS name, pt.table_id AS reftable_id
           FROM sys.sysfkey fk
           join sys.systab pt on fk.primary_table_id = pt.table_id
+          join sys.sysidx i on i.table_id=fk.primary_table_id
           WHERE fk.foreign_table_id = :table_id
+          and i.index_category=2
         """)
         referential_constraints = connection.execute(REFCONSTRAINT_SQL,
                                                      table_id=table_id)
@@ -714,11 +725,8 @@ def get_pk_constraint(self, connection, table_name, schema=None, **kw):
         results.close()
 
         if not pks:
-            # if we don't have any primary keys, then we will get a 
-            # "TypeError: 'NoneType' object is not subscriptable" below.
-            raise SQLAnyNoPrimaryKeyError(
-                "The table %s has no primary key and therefore can't be mapped using SQLAlchemy!" % table_name,
-                table_name)
+            return {"constrained_columns": [],
+                    "name": None}
 
         PKCOL_SQL = text("""
              select tc.column_name as col

test/conftest.py

@@ -0,0 +1,5 @@
+from sqlalchemy.dialects import registry
+
+registry.register("sqlalchemy_sqlany", "sqlalchemy_sqlany.base", "dialect")
+
+from sqlalchemy.testing.plugin.pytestplugin import *

test/requirements.py

@@ -72,3 +72,45 @@ def time_microseconds(self):
         datetime.time() with microsecond objects."""
 
         return exclusions.closed()
+
+    @property
+    def order_by_col_from_union(self):
+        """target database supports ordering by a column from a SELECT
+        inside of a UNION
+        E.g.  (SELECT id, ...) UNION (SELECT id, ...) ORDER BY id
+        """
+
+        return exclusions.closed()
+
+    @property
+    def cross_schema_fk_reflection(self):
+        """target system must support reflection of inter-schema foreign keys
+        """
+        return exclusions.closed()
+
+    @property
+    def independent_connections(self):
+        """target system must support simultaneous, independent database connections.
+        """
+        return exclusions.open()
+
+    @property
+    def temp_table_reflection(self):
+        return exclusions.closed()
+
+    @property
+    def implicitly_named_constraints(self):
+        return exclusions.open()
+
+    @property
+    def unique_constraint_reflection(self):
+        return exclusions.closed()
+
+    @property
+    def floats_to_four_decimals(self):
+        return exclusions.closed()
+    
+    @property
+    def precision_generic_float_type(self):
+        return exclusions.closed()
+    

test/test_suite.py

@@ -1 +1,91 @@
 from sqlalchemy.testing.suite import *
+
+from sqlalchemy.testing.suite import ComponentReflectionTest as _ComponentReflectionTest
+from sqlalchemy.testing.suite import InsertBehaviorTest as _InsertBehaviorTest
+from sqlalchemy.testing.suite import LimitOffsetTest as _LimitOffsetTest
+from sqlalchemy.testing.suite import RowFetchTest as _RowFetchTest
+from sqlalchemy.testing.suite import TextTest as _TextTest
+from sqlalchemy.testing.suite import UnicodeTextTest as _UnicodeTextTest
+from sqlalchemy.testing.suite import StringTest as _StringTest
+from sqlalchemy.testing.suite import UnicodeVarcharTest as _UnicodeVarcharTest
+
+class ComponentReflectionTest(_ComponentReflectionTest):
+    """ Temporary tables need to use 'GLOBAL TEMPORARY' or 'LOCAL TEMPORARY'
+        in SQL Anywhere
+    """
+    @classmethod
+    def define_temp_tables(cls, metadata):
+        kw = {
+            'prefixes': ["GLOBAL TEMPORARY"],
+        }
+
+        user_tmp = Table(
+            "user_tmp", metadata,
+            Column("id", sa.INT, primary_key=True),
+            Column('name', sa.VARCHAR(50)),
+            Column('foo', sa.INT),
+            sa.UniqueConstraint('name', name='user_tmp_uq'),
+            sa.Index("user_tmp_ix", "foo"),
+            **kw
+        )
+        if testing.requires.view_reflection.enabled and \
+                testing.requires.temporary_views.enabled:
+            event.listen(
+                user_tmp, "after_create",
+                DDL("create temporary view user_tmp_v as "
+                    "select * from user_tmp")
+            )
+            event.listen(
+                user_tmp, "before_drop",
+                DDL("drop view user_tmp_v")
+            )
+
+class InsertBehaviorTest(_InsertBehaviorTest):
+    def test_insert_from_select_with_defaults( self ):
+        pass
+
+class LimitOffsetTest(_LimitOffsetTest):
+    def test_bound_limit( self ):
+        pass
+    def test_bound_limit_offset( self ):
+        pass
+    def test_bound_offset( self ):
+        pass
+
+class RowFetchTest(_RowFetchTest):
+    def test_row_w_scalar_select(self):
+        pass
+
+class TextTest(_UnicodeTextTest):
+    def test_literal_backslashes(self):
+        pass
+    def test_literal(self):
+        pass
+    def test_round_trip(self):
+        pass
+    def test_round_trip_executemany(self):
+        pass
+
+class UnicodeTextTest(_UnicodeTextTest):
+    def test_literal_backslashes(self):
+        pass
+    def test_literal(self):
+        pass
+    def test_round_trip(self):
+        pass
+    def test_round_trip_executemany(self):
+        pass
+
+class StringTest(_StringTest):
+    def test_literal_backslashes(self):
+        pass
+
+class UnicodeVarcharTest(_UnicodeVarcharTest):
+    def test_literal_backslashes(self):
+        pass
+    def test_literal(self):
+        pass
+    def test_round_trip(self):
+        pass
+    def test_round_trip_executemany(self):
+        pass