Resolve Unicode issue with latest python3.13 (#155)

ibm_db_sa/base.py

@@ -371,7 +371,7 @@ def visit_select(self, select, **kwargs):
         sql_ori = compiler.SQLCompiler.visit_select(self, select, **kwargs)
         if offset is not None:
             __rownum = 'Z.__ROWNUM'
-            sql_split = re.split("[\s+]FROM ", sql_ori, 1)
+            sql_split = re.split(r"[\s+]FROM ", sql_ori, 1)
             sql_sec = ""
             sql_sec = " \nFROM %s " % (sql_split[1])
 
@@ -454,8 +454,9 @@ def visit_cast(self, cast, **kw):
         # other types, I was able to CAST against VARCHAR
         # for example
         if isinstance(type_, (
-                sa_types.DateTime, sa_types.Date, sa_types.Time,
-                sa_types.DECIMAL, sa_types.String)):
+                sa_types.DateTime, sa_types.Date, sa_types.Time, sa_types.DOUBLE, sa_types.Double, sa_types.Integer, sa_types.INTEGER,
+                sa_types.Boolean, sa_types.BOOLEAN, sa_types.BIGINT, sa_types.BigInteger, sa_types.BINARY, sa_types.NUMERIC, sa_types.SmallInteger,
+                sa_types.DECIMAL, sa_types.String, sa_types.Float, sa_types.FLOAT, sa_types.Numeric)):
             return super(DB2Compiler, self).visit_cast(cast, **kw)
         else:
             return self.process(cast.clause)

ibm_db_sa/reflection.py

@@ -307,7 +307,7 @@ def get_pk_constraint(self, connection, table_name, schema=None, **kw):
         current_schema = self.denormalize_name(schema or self.default_schema_name)
         table_name = self.denormalize_name(table_name)
         sysindexes = self.sys_indexes
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         query = sql.select(sysindexes.c.colnames, sysindexes.c.indname).\
             where(and_(sysindexes.c.tabschema == current_schema,
                        sysindexes.c.tabname == table_name,
@@ -329,7 +329,7 @@ def get_primary_keys(self, connection, table_name, schema=None, **kw):
         current_schema = self.denormalize_name(schema or self.default_schema_name)
         table_name = self.denormalize_name(table_name)
         syscols = self.sys_columns
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         query = sql.select(syscols.c.colname).\
             where(and_(
                   syscols.c.tabschema == current_schema,
@@ -441,7 +441,7 @@ def get_indexes(self, connection, table_name, schema=None, **kw):
             where(and_(sysidx.c.tabschema == current_schema,sysidx.c.tabname == table_name)).\
             order_by(sysidx.c.tabname)
         indexes = []
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         for r in connection.execute(query):
             if r[2] != 'P':
                 if r[2] == 'U' and r[3] != 0:
@@ -462,24 +462,41 @@ def get_unique_constraints(self, connection, table_name, schema=None, **kw):
         table_name = self.denormalize_name(table_name)
         syskeycol = self.sys_keycoluse
         sysconst = self.sys_tabconst
-        query = sql.select(syskeycol.c.constname, syskeycol.c.colname).\
-            where(and_(
-              syskeycol.c.constname == sysconst.c.constname,
-              sysconst.c.tabname == table_name,
-              sysconst.c.tabschema == current_schema,
-              sysconst.c.type == 'U')).\
-            order_by(syskeycol.c.constname)
+        query = (
+            sql.select(syskeycol.c.constname, syskeycol.c.colname)
+            .select_from(
+                join(
+                    syskeycol,
+                    sysconst,
+                    and_(
+                        syskeycol.c.constname == sysconst.c.constname,
+                        syskeycol.c.tabschema == sysconst.c.tabschema,
+                        syskeycol.c.tabname == sysconst.c.tabname,
+                    ),
+                )
+            )
+            .where(
+                and_(
+                    sysconst.c.tabname == table_name,
+                    sysconst.c.tabschema == current_schema,
+                    sysconst.c.type == "U",
+                )
+            )
+            .order_by(syskeycol.c.constname)
+        )
         uniqueConsts = []
         currConst = None
         for r in connection.execute(query):
             if currConst == r[0]:
-                uniqueConsts[-1]['column_names'].append(self.normalize_name(r[1]))
+                uniqueConsts[-1]["column_names"].append(self.normalize_name(r[1]))
             else:
                 currConst = r[0]
-                uniqueConsts.append({
-                        'name': self.normalize_name(currConst),
-                        'column_names': [self.normalize_name(r[1])],
-                    })
+                uniqueConsts.append(
+                    {
+                        "name": self.normalize_name(currConst),
+                        "column_names": [self.normalize_name(r[1])],
+                    }
+                )
         return uniqueConsts
 
 
@@ -613,21 +630,33 @@ def get_sequence_names(self, connection, schema=None, **kw):
     @reflection.cache
     def get_schema_names(self, connection, **kw):
         sysschema = self.sys_schemas
-        query = sql.select(sysschema.c.schemaname).\
-            where(~sysschema.c.schemaname.like(unicode('Q%'))).\
-            where(~sysschema.c.schemaname.like(unicode('SYS%'))).\
-            order_by(sysschema.c.schemaname)
+        if version_info[0] < 3:
+            query = sql.select(sysschema.c.schemaname). \
+                where(~sysschema.c.schemaname.like(unicode('Q%'))). \
+                where(~sysschema.c.schemaname.like(unicode('SYS%'))). \
+                order_by(sysschema.c.schemaname)
+        else:
+            query = sql.select(sysschema.c.schemaname). \
+                where(~sysschema.c.schemaname.like(str('Q%'))). \
+                where(~sysschema.c.schemaname.like(str('SYS%'))). \
+                order_by(sysschema.c.schemaname)
         return [self.normalize_name(r[0]) for r in connection.execute(query)]
 
     # Retrieves a list of table names for a given schema
     @reflection.cache
     def get_table_names(self, connection, schema=None, **kw):
         current_schema = self.denormalize_name(schema or self.default_schema_name)
         systbl = self.sys_tables
-        query = not sql.select(systbl.c.tabname).\
-            where(systbl.c.tabtype == unicode('T')).\
-            where(systbl.c.tabschema == current_schema).\
-            order_by(systbl.c.tabname)
+        if version_info[0] < 3:
+            query = not sql.select(systbl.c.tabname). \
+                where(systbl.c.tabtype == unicode('T')). \
+                where(systbl.c.tabschema == current_schema). \
+                order_by(systbl.c.tabname)
+        else:
+            query = not sql.select(systbl.c.tabname). \
+                where(systbl.c.tabtype == str('T')). \
+                where(systbl.c.tabschema == current_schema). \
+                order_by(systbl.c.tabname)
         return [self.normalize_name(r[0]) for r in connection.execute(query)]
 
     @reflection.cache
@@ -682,14 +711,24 @@ def get_columns(self, connection, table_name, schema=None, **kw):
                                     (coltype, r[0]))
                     coltype = coltype = sa_types.NULLTYPE
 
-            sa_columns.append({
+            if version_info[0] < 3:
+                sa_columns.append({
                     'name': self.normalize_name(r[0]),
                     'type': coltype,
                     'nullable': r[3] == unicode('Y'),
                     'default': r[2],
                     'autoincrement': (r[6] == unicode('YES')) and (r[7] != None),
                     'comment': r[8] or None,
                 })
+            else:
+                sa_columns.append({
+                    'name': self.normalize_name(r[0]),
+                    'type': coltype,
+                    'nullable': r[3] == str('Y'),
+                    'default': r[2],
+                    'autoincrement': (r[6] == str('YES')) and (r[7] != None),
+                    'comment': r[8] or None,
+                })
         return sa_columns
 
     @reflection.cache
@@ -725,14 +764,24 @@ def get_primary_keys(self, connection, table_name, schema=None, **kw):
         sysconst = self.sys_table_constraints
         syskeyconst = self.sys_key_constraints
 
-        query = sql.select(syskeyconst.c.colname, sysconst.c.tabname).\
-            where(and_(
+        if version_info[0] < 3:
+            query = sql.select(syskeyconst.c.colname, sysconst.c.tabname). \
+                where(and_(
                 syskeyconst.c.conschema == sysconst.c.conschema,
                 syskeyconst.c.conname == sysconst.c.conname,
                 sysconst.c.tabschema == current_schema,
                 sysconst.c.tabname == table_name,
-                sysconst.c.contype == unicode('PRIMARY KEY'))).\
-            order_by(syskeyconst.c.colno)
+                sysconst.c.contype == unicode('PRIMARY KEY'))). \
+                order_by(syskeyconst.c.colno)
+        else:
+            query = sql.select(syskeyconst.c.colname, sysconst.c.tabname). \
+                where(and_(
+                syskeyconst.c.conschema == sysconst.c.conschema,
+                syskeyconst.c.conname == sysconst.c.conname,
+                sysconst.c.tabschema == current_schema,
+                sysconst.c.tabname == table_name,
+                sysconst.c.contype == str('PRIMARY KEY'))). \
+                order_by(syskeyconst.c.colno)
 
         return [self.normalize_name(key[0])
                     for key in connection.execute(query)]
@@ -779,7 +828,7 @@ def get_indexes(self, connection, table_name, schema=None, **kw):
         current_schema = self.denormalize_name(
                                     schema or self.default_schema_name)
         table_name = self.denormalize_name(table_name)
-        
+
         sysidx = self.sys_indexes
         syskey = self.sys_keys
 
@@ -797,11 +846,18 @@ def get_indexes(self, connection, table_name, schema=None, **kw):
             if key in indexes:
                 indexes[key]['column_names'].append(self.normalize_name(r[2]))
             else:
-                indexes[key] = {
-                                'name': self.normalize_name(r[0]),
-                                'column_names': [self.normalize_name(r[2])],
-                                'unique': r[1] == unicode('Y')
-                        }
+                if version_info[0] < 3:
+                    indexes[key] = {
+                        'name': self.normalize_name(r[0]),
+                        'column_names': [self.normalize_name(r[2])],
+                        'unique': r[1] == unicode('Y')
+                    }
+                else:
+                    indexes[key] = {
+                        'name': self.normalize_name(r[0]),
+                        'column_names': [self.normalize_name(r[2])],
+                        'unique': r[1] == str('Y')
+                    }
         return [value for key, value in indexes.items()]
 
     @reflection.cache
@@ -1015,7 +1071,7 @@ def get_pk_constraint(self, connection, table_name, schema=None, **kw):
         current_schema = self.denormalize_name(schema or self.default_schema_name)
         table_name = self.denormalize_name(table_name)
         sysindexes = self.sys_columns
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         query = sql.select(sysindexes.c.colname).\
             where(and_(
                 sysindexes.c.tabschema == current_schema,
@@ -1033,7 +1089,7 @@ def get_primary_keys(self, connection, table_name, schema=None, **kw):
         current_schema = self.denormalize_name(schema or self.default_schema_name)
         table_name = self.denormalize_name(table_name)
         sysindexes = self.sys_columns
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         query = sql.select(sysindexes.c.colname).\
             where(and_(
                 sysindexes.c.tabschema == current_schema,
@@ -1151,7 +1207,7 @@ def get_indexes(self, connection, table_name, schema=None, **kw):
                 syscolpk.c.keyseq > 0)).\
             order_by(sysidx.c.tabname)
         indexes = []
-        col_finder = re.compile("(\w+)")
+        col_finder = re.compile(r"(\w+)")
         for r in connection.execute(query):
             if r[2] != 'P':
                 if r[2] == 'U' and r[3] != 0:
@@ -1170,22 +1226,39 @@ def get_unique_constraints(self, connection, table_name, schema=None, **kw):
         table_name = self.denormalize_name(table_name)
         syskeycol = self.sys_keycoluse
         sysconst = self.sys_tabconst
-        query = sql.select(syskeycol.c.constname, syskeycol.c.colname).\
-            where(and_(
-                syskeycol.c.constname == sysconst.c.constname,
-                sysconst.c.tabname == table_name,
-                sysconst.c.tabschema == current_schema,
-                sysconst.c.type == 'U')).\
-            order_by(syskeycol.c.constname)
+        query = (
+            sql.select(syskeycol.c.constname, syskeycol.c.colname)
+            .select_from(
+                join(
+                    syskeycol,
+                    sysconst,
+                    and_(
+                        syskeycol.c.constname == sysconst.c.constname,
+                        syskeycol.c.tabschema == sysconst.c.tabschema,
+                        syskeycol.c.tabname == sysconst.c.tabname,
+                    ),
+                )
+            )
+            .where(
+                and_(
+                    sysconst.c.tabname == table_name,
+                    sysconst.c.tabschema == current_schema,
+                    sysconst.c.type == "U",
+                )
+            )
+            .order_by(syskeycol.c.constname)
+        )
         uniqueConsts = []
         currConst = None
         for r in connection.execute(query):
             if currConst == r[0]:
-                uniqueConsts[-1]['column_names'].append(self.normalize_name(r[1]))
+                uniqueConsts[-1]["column_names"].append(self.normalize_name(r[1]))
             else:
                 currConst = r[0]
-                uniqueConsts.append({
-                        'name': self.normalize_name(currConst),
-                        'column_names': [self.normalize_name(r[1])],
-                    })
+                uniqueConsts.append(
+                    {
+                        "name": self.normalize_name(currConst),
+                        "column_names": [self.normalize_name(r[1])],
+                    }
+                )
         return uniqueConsts

polaris.yml

@@ -0,0 +1,49 @@
+version: "1"
+project:
+  name: ${scm.git.repo}
+  branch: ${scm.git.branch}
+  revision:
+    name: ${scm.git.commit}
+    date: ${scm.git.commit.date}
+capture:
+  build:
+    buildCommands:
+    - shell: [python, -m, build]
+  fileSystem:
+    ears:
+      extensions: [ear]
+      files:
+      - directory: ${project.projectDir}
+    java:
+      files:
+      - directory: ${project.projectDir}
+    javascript:
+      files:
+      - directory: ${project.projectDir}
+      - excludeRegex: node_modules|bower_components|vendor
+    php:
+      files:
+      - directory: ${project.projectDir}
+    python:
+      files:
+      - directory: ${project.projectDir}
+    ruby:
+      files:
+      - directory: ${project.projectDir}
+    typescript:
+      files:
+      - directory: ${project.projectDir}
+    wars:
+      extensions: [war]
+      files:
+      - directory: ${project.projectDir}
+    dlls:
+      extensions: [c, C, cpp, CPP, h, hpp]
+      files:
+      - directory: ${project.projectDir}
+analyze:
+  mode: central
+install:
+  coverity:
+    version: default
+serverUrl: https://rocketsoftware.cop.blackduck.com