Ticket #6235: ingres-trac-0.11.3.diff

setup.py

@@ -76 +76 @@
         trac.db.mysql = trac.db.mysql_backend
         trac.db.postgres = trac.db.postgres_backend
         trac.db.sqlite = trac.db.sqlite_backend
+        trac.db.ingres = trac.db.ingres_backend
         trac.mimeview.enscript = trac.mimeview.enscript
         trac.mimeview.patch = trac.mimeview.patch
         trac.mimeview.php = trac.mimeview.php

trac/db/ingres_backend.py

@@ +1 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007 Edgewall Software
+# Copyright (C) 2007 Alexander Trofast <alex.trofast@ingres.com>
+# All rights reserved.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://trac.edgewall.org/wiki/TracLicense.
+#
+# This software consists of voluntary contributions made by many
+# individuals. For the exact contribution history, see the revision
+# history and logs, available at http://trac.edgewall.org/log/.
+#
+# Author: Alexander Trofast <alex.trofast@ingres.com>
+
+
+
+import re
+
+from trac.core import *
+from trac.db.api import IDatabaseConnector
+from trac.db.util import ConnectionWrapper, IterableCursor
+from types import *
+
+import ingresdbi
+
+_like_escape_re = re.compile(r'([/_%])')
+
+
+class IngresCursor(IterableCursor):
+
+        
+        #Changes LIMIT to FIRST and moves it
+        def _convert_limit(self, query):
+                reglim = re.compile(r"SELECT(.+)LIMIT\s+(\d+)", re.I | re.M | re.S)
+                query = reglim.sub(r"SELECT FIRST \2 \1", query)
+                return query
+
+        # Hide away reserved word session within quotes for transportability
+        def _replace_session(self, query):
+                regses = re.compile(r"(.+)\s+SESSION\s+(.*)", re.I)
+                query = regses.sub(r'\1 t_session \2', query)
+                return query
+
+        #method to fix unicode issues and convert longer strings to binary objects
+        def _encode_args(self, args):
+                if(isinstance(args, list) or isinstance(args,tuple)):
+                        for arg in args:
+                                if(isinstance(arg, list) or isinstance(arg, tuple)):
+                                        yield list(self._encode_args(arg))
+                                elif(isinstance(arg,unicode)):
+                                        yield self._check_length(arg.encode('utf-8'))
+                                else:
+                                        yield self._check_length(arg)
+                elif(isinstance(args, unicode)):
+                        yield self._check_length(args.encode('utf-8'))
+                else:
+                        yield self._check_length(args)
+        
+        def _check_length(self, arg):
+                if(isinstance(arg, str) == False and isinstance(arg, unicode) == False):
+                        return arg
+                if len(arg) > 31999:
+                        return ingresdbi.Binary(arg)
+                else:
+                        return arg
+                
+        def _check_subselect(self, arg):
+                reg = re.compile(r"""(^\s*SELECT.+\(\s*SELECT.+)(ORDER BY.*)(\)\s*AS.*)""", re.I | re.M | re.S)
+                if re.search(reg, arg):
+                        return reg.sub(r'\1\3', arg)
+                else:
+                        return arg
+                
+        def execute(self, sql, args = None):
+                sql = self._convert_limit(sql)
+                sql = self._replace_session(sql)
+                sql = self._check_subselect(sql)
+                if args:
+                        sql = sql.replace('%s', '?')
+                        args = list(self._encode_args(args))
+                        return self.cursor.execute(sql, args)
+                return self.cursor.execute(sql)
+
+        def executemany(self, sql, args = None):
+                if args:
+                        sql = sql.replace('%s', '?')
+                        sql = self._convert_limit(sql)
+                        sql = self._replace_session(sql)
+                        sql = self._check_subselect(sql)
+                        args = list(self._encode_args(args))
+                        return self.cursor.executemany(sql, args)
+                return self.cursor.execute(sql)
+
+        def _convert_row(self, row):
+                new_row = []
+                for r in row:
+                        if isinstance(r, str):
+                                new_row.append(r.decode('utf-8'))
+                        else:
+                                new_row.append(r)
+                return new_row  
+
+        def fetchone(self):
+                row = self.cursor.fetchone()
+                return row and self._convert_row(row) or None
+
+        def fetchall(self):
+                rows = self.cursor.fetchall()
+                return rows != None and [self._convert_row(row) for row in rows] or []
+
+        def fetchmany(self, num):
+                rows = self.cursor.fetchmany(num)
+                return rows != None and [self._convert_row(row) for row in rows] or []
+
+
+class IngresConnector(Component):
+        """Ingres backend database support
+        usage: ingres://user:password@vnode/database
+        """
+        
+        implements(IDatabaseConnector)
+
+        def _init_(self):
+                self._version = None
+                
+        #check for whether a field is an index, and convert it to an appropriate data type
+        def _is_index(self, name, indices):
+                for ind in indices:
+                        if name in ind.columns:
+                                return True
+                        else:
+                                return False
+        
+        def get_supported_schemes(self):
+                return [('ingres', 1)]
+
+        def get_connection(self, path, user=None, password=None, host=None, port=None, params={}):
+                return IngresConnection(path, user, password, host, port, params)
+
+        def init_db(self, path, user=None, password=None, host=None, port=None, params={}):
+                cnx = self.get_connection(path, user, password, host, port, params)
+                cursor = cnx.cursor()
+                from trac.db_default import schema
+                for table in schema:
+                        for stmt in self.to_sql(table):
+                                #print stmt
+                                cursor.execute(stmt)
+                cnx.commit()
+
+        def to_sql(self, table):
+                sql = ['CREATE TABLE %s (' % table.name]
+                if table.name == 'session':
+                        sql = ['CREATE TABLE t_session (']
+                coldefs = []
+                moddefs = []
+                #find number of text keys
+                keys = 0
+                for clm in table.columns:
+                        if (clm.name in table.key or self._is_index(clm.name, table.indices)) and clm.auto_increment == False:
+                                keys += 1
+                key_length = 1
+                if keys:
+                        key_length = 1950 / keys
+
+                #variable used to determine if there is a procedure to create
+                auto_inc = False
+                proc = []
+                rule = []
+
+                for column in table.columns:
+                        ctype = column.type
+                        if column.auto_increment:
+                                ctype = 'int' #can't use a sequence on text
+                                yield "CREATE SEQUENCE %s_%s_seq START WITH 1 INCREMENT BY 1;" % (table.name, column.name)
+                                proc.append("CREATE PROCEDURE %s_%s_proc AS BEGIN UPDATE %s SET %s = %s_%s_seq.nextval WHERE %s = 0 END;" % (table.name, column.name, table.name, column.name, table.name, column.name, column.name))
+                                rule.append("CREATE RULE %s_%s_rule AFTER INSERT ON %s EXECUTE PROCEDURE %s_%s_proc;" % (table.name, column.name, table.name, table.name, column.name))
+
+                                auto_inc = True
+                        if ctype == 'text':
+                                if column.name in table.key or self._is_index(column.name, table.indices):
+                                        ctype = 'varchar(%s)' % key_length
+                                        #path can be really long, make sure it has more room
+                                        if table.name == 'node_change':
+                                                if column.name == 'path':
+                                                        ctype = 'varchar(1700)'
+                                                elif column.name == 'rev':
+                                                        ctype = 'varchar(256)'
+                                                elif column.name == 'change_type':
+                                                        ctype = 'varchar(5)'
+                                else:
+                                        ctype = 'varchar(1024)'
+                                if column.name == 'description' and (table.name == 'ticket' or table.name =='milestone'):
+                                        ctype = 'long varchar'
+                                elif column.name == 'text' and table.name == 'wiki':
+                                        ctype = 'long varchar'
+                                if table.name == 'enum' and column.name == 'value':
+                                        ctype = 'int'
+                        if column.auto_increment:
+                                default = " WITH DEFAULT 0"
+                        else:
+                                default = " "
+                        """ appends NOT NULL for keys """
+                        if column.name in table.key:
+                                coldefs.append("  %s %s NOT NULL%s" % (column.name, ctype,default))
+                        else:
+                                coldefs.append("  %s %s%s" % (column.name, ctype, default))
+                        
+                sql.append(",\n".join(coldefs) + "\n);")
+                yield "\n".join(sql)
+
+                # modify tables to btree instead of heap and sets correct page size and uniqueness.
+                if len(table.key) > 0:
+                        moddefs.append("MODIFY %s TO BTREE UNIQUE ON %s WITH PAGE_SIZE = 65536;" % (table.name, ",".join(table.key)))
+                else:
+                        moddefs.append("MODIFY %s TO BTREE WITH PAGE_SIZE = 65536;" % table.name)
+
+                yield "\n".join(moddefs)
+
+                #create procedure and rules here, after the table has been created.
+                if auto_inc == True:
+                        for itm in proc:
+                                yield itm
+                        for itm in rule:
+                                yield itm
+
+                for index in table.indices:
+                        #Use tblname instead of table.name to hack session -> t_sessiona
+
+                        index_exists = False
+                        for col in index.columns:
+                                if col in table.key:
+                                        index_exists = True
+
+                        if index_exists:
+                                continue
+
+                        if table.name == 'session':
+                                tblname = 't_session'
+                        else:
+                                tblname = table.name
+
+                        yield "  CREATE INDEX %s_%s_idx ON %s (%s) with PAGE_SIZE = 65536, STRUCTURE = BTREE;" % (table.name, "_".join(index.columns), tblname, ",".join(index.columns))
+
+class IngresConnection(ConnectionWrapper):
+        """Ingres Connection Wrapper"""
+
+        poolable = False
+
+        def __init__(self, path, user=None, password=None, host=None, port=None, params={}):
+        
+                if path.startswith('/'):
+                        path = path[1:]
+                if host == None:
+                        host = "(local)"
+                if user == None:
+                        user = ''
+                if password == None:
+                        password = ''   
+                cnx = ingresdbi.connect(vnode=host, database=path, uid=user, dbms_pwd=password)
+
+                ConnectionWrapper.__init__(self, cnx)
+                self._is_closed = False
+
+        def cast(self, column, type):
+                return "CAST(%s AS %s)" % (column, type)
+
+        def concat(self, *args):
+                return "concat(%s)" % ",".join(args)
+
+        def like(self):
+                return "LIKE %s ESCAPE '/'"
+
+        def like_escape(self, text):
+                return _like_escape_re.sub(r'/\1', text)
+
+        def get_last_id(self, cursor, table, column='id'):
+                """Hack to get the last inserted ID, will always be max due to procedures."""
+                cursor.execute("SELECT MAX(%s) FROM %s" % (column, table))
+                return cursor.fetchone()[0]
+
+        def rollback(self):
+                self.cnx.rollback()
+
+        def close(self):
+                self.cnx.close()
+                self._is_closed = True
+
+        def cursor(self):
+                return IngresCursor(self.cnx.cursor())
+