roundup/backends/back_gadfly.py

   1 # $Id: back_gadfly.py,v 1.28 2002-10-03 06:56:29 richard Exp $
   2 ''' Gadlfy relational database hypderb backend.
   3
   4 About Gadfly
   5 ============
   6
   7 Gadfly  is  a  collection  of  python modules that provides relational
   8 database  functionality  entirely implemented in Python. It supports a
   9 subset  of  the intergalactic standard RDBMS Structured Query Language
  10 SQL.
  11
  12
  13 Additional Instance Requirements
  14 ================================
  15
  16 The instance configuration must specify where the database is. It does this
  17 with GADFLY_DATABASE, which is used as the arguments to the gadfly.gadfly()
  18 method:
  19
  20 Using an on-disk database directly (not a good idea):
  21   GADFLY_DATABASE = (database name, directory)
  22
  23 Using a network database (much better idea):
  24   GADFLY_DATABASE = (policy, password, address, port)
  25
  26 Because multiple accesses directly to a gadfly database aren't handled, but
  27 multiple network accesses are, it's strongly advised that the latter setup be
  28 used.
  29
  30 '''
  31
  32 # standard python modules
  33 import sys, os, time, re, errno, weakref, copy
  34
  35 # roundup modules
  36 from roundup import hyperdb, date, password, roundupdb, security
  37 from roundup.hyperdb import String, Password, Date, Interval, Link, \
  38     Multilink, DatabaseError, Boolean, Number
  39
  40 # basic RDBMS backen implementation
  41 from roundup.backends import rdbms_common
  42
  43 # the all-important gadfly :)
  44 import gadfly
  45 import gadfly.client
  46 import gadfly.database
  47
  48 class Database(rdbms_common.Database):
  49     # char to use for positional arguments
  50     arg = '?'
  51
  52     def open_connection(self):
  53         db = getattr(self.config, 'GADFLY_DATABASE', ('database', self.dir))
  54         if len(db) == 2:
  55             # ensure files are group readable and writable
  56             os.umask(0002)
  57             try:
  58                 self.conn = gadfly.gadfly(*db)
  59             except IOError, error:
  60                 if error.errno != errno.ENOENT:
  61                     raise
  62                 self.database_schema = {}
  63                 self.conn = gadfly.gadfly()
  64                 self.conn.startup(*db)
  65                 self.cursor = self.conn.cursor()
  66                 self.cursor.execute('create table schema (schema varchar)')
  67                 self.cursor.execute('create table ids (name varchar, num integer)')
  68             else:
  69                 self.cursor = self.conn.cursor()
  70                 self.cursor.execute('select schema from schema')
  71                 self.database_schema = self.cursor.fetchone()[0]
  72         else:
  73             self.conn = gadfly.client.gfclient(*db)
  74             self.database_schema = self.load_dbschema()
  75
  76     def __repr__(self):
  77         return '<roundfly 0x%x>'%id(self)
  78
  79     def sql_fetchone(self):
  80         ''' Fetch a single row. If there's nothing to fetch, return None.
  81         '''
  82         try:
  83             return self.cursor.fetchone()
  84         except gadfly.database.error, message:
  85             if message == 'no more results':
  86                 return None
  87             raise
  88
  89     def sql_fetchall(self):
  90         ''' Fetch a single row. If there's nothing to fetch, return [].
  91         '''
  92         try:
  93             return self.cursor.fetchall()
  94         except gadfly.database.error, message:
  95             if message == 'no more results':
  96                 return []
  97             raise
  98
  99     def save_dbschema(self, schema):
 100         ''' Save the schema definition that the database currently implements
 101         '''
 102         self.sql('insert into schema values (?)', (self.database_schema,))
 103
 104     def load_dbschema(self):
 105         ''' Load the schema definition that the database currently implements
 106         '''
 107         self.cursor.execute('select schema from schema')
 108         return self.cursor.fetchone()[0]
 109
 110     def save_journal(self, classname, cols, nodeid, journaldate,
 111             journaltag, action, params):
 112         ''' Save the journal entry to the database
 113         '''
 114         # nothing special to do
 115         entry = (nodeid, journaldate, journaltag, action, params)
 116
 117         # do the insert
 118         a = self.arg
 119         sql = 'insert into %s__journal (%s) values (?,?,?,?,?)'%(classname,
 120             cols)
 121         if __debug__:
 122             print >>hyperdb.DEBUG, 'addjournal', (self, sql, entry)
 123         self.cursor.execute(sql, entry)
 124
 125     def load_journal(self, classname, cols, nodeid):
 126         ''' Load the journal from the database
 127         '''
 128         # now get the journal entries
 129         sql = 'select %s from %s__journal where nodeid=%s'%(cols, classname,
 130             self.arg)
 131         if __debug__:
 132             print >>hyperdb.DEBUG, 'getjournal', (self, sql, nodeid)
 133         self.cursor.execute(sql, (nodeid,))
 134         res = []
 135         for nodeid, date_stamp, user, action, params in self.cursor.fetchall():
 136             res.append((nodeid, date.Date(date_stamp), user, action, params))
 137         return res
 138
 139 class GadflyClass:
 140     def filter(self, search_matches, filterspec, sort, group):
 141         ''' Gadfly doesn't have a LIKE predicate :(
 142         '''
 143         cn = self.classname
 144
 145         # figure the WHERE clause from the filterspec
 146         props = self.getprops()
 147         frum = ['_'+cn]
 148         where = []
 149         args = []
 150         a = self.db.arg
 151         for k, v in filterspec.items():
 152             propclass = props[k]
 153             if isinstance(propclass, Multilink):
 154                 tn = '%s_%s'%(cn, k)
 155                 frum.append(tn)
 156                 if isinstance(v, type([])):
 157                     s = ','.join([a for x in v])
 158                     where.append('id=%s.nodeid and %s.linkid in (%s)'%(tn,tn,s))
 159                     args = args + v
 160                 else:
 161                     where.append('id=%s.nodeid and %s.linkid = %s'%(tn, tn, a))
 162                     args.append(v)
 163             else:
 164                 if isinstance(v, type([])):
 165                     s = ','.join([a for x in v])
 166                     where.append('_%s in (%s)'%(k, s))
 167                     args = args + v
 168                 else:
 169                     where.append('_%s=%s'%(k, a))
 170                     args.append(v)
 171
 172         # add results of full text search
 173         if search_matches is not None:
 174             v = search_matches.keys()
 175             s = ','.join([a for x in v])
 176             where.append('id in (%s)'%s)
 177             args = args + v
 178
 179         # "grouping" is just the first-order sorting in the SQL fetch
 180         # can modify it...)
 181         orderby = []
 182         ordercols = []
 183         if group[0] is not None and group[1] is not None:
 184             if group[0] != '-':
 185                 orderby.append('_'+group[1])
 186                 ordercols.append('_'+group[1])
 187             else:
 188                 orderby.append('_'+group[1]+' desc')
 189                 ordercols.append('_'+group[1])
 190
 191         # now add in the sorting
 192         group = ''
 193         if sort[0] is not None and sort[1] is not None:
 194             direction, colname = sort
 195             if direction != '-':
 196                 if colname == 'id':
 197                     orderby.append(colname)
 198                 else:
 199                     orderby.append('_'+colname)
 200                     ordercols.append('_'+colname)
 201             else:
 202                 if colname == 'id':
 203                     orderby.append(colname+' desc')
 204                     ordercols.append(colname)
 205                 else:
 206                     orderby.append('_'+colname+' desc')
 207                     ordercols.append('_'+colname)
 208
 209         # construct the SQL
 210         frum = ','.join(frum)
 211         if where:
 212             where = ' where ' + (' and '.join(where))
 213         else:
 214             where = ''
 215         cols = ['id']
 216         if orderby:
 217             cols = cols + ordercols
 218             order = ' order by %s'%(','.join(orderby))
 219         else:
 220             order = ''
 221         cols = ','.join(cols)
 222         sql = 'select %s from %s %s%s%s'%(cols, frum, where, group, order)
 223         args = tuple(args)
 224         if __debug__:
 225             print >>hyperdb.DEBUG, 'filter', (self, sql, args)
 226         self.db.cursor.execute(sql, args)
 227         l = self.db.cursor.fetchall()
 228
 229         # return the IDs
 230         return [row[0] for row in l]
 231
 232     def find(self, **propspec):
 233         ''' Overload to filter out duplicates in the result
 234         '''
 235         d = {}
 236         for k in rdbms_common.Class.find(self, **propspec):
 237             d[k] = 1
 238         return d.keys()
 239
 240 class Class(GadflyClass, rdbms_common.Class):
 241     pass
 242 class IssueClass(GadflyClass, rdbms_common.IssueClass):
 243     pass
 244 class FileClass(GadflyClass, rdbms_common.FileClass):
 245     pass
 246