roundup/backends/back_gadfly.py

   1 # $Id: back_gadfly.py,v 1.22 2002-09-18 05:07:47 richard Exp $
   2 __doc__ = '''
   3 About Gadfly
   4 ============
   5
   6 Gadfly  is  a  collection  of  python modules that provides relational
   7 database  functionality  entirely implemented in Python. It supports a
   8 subset  of  the intergalactic standard RDBMS Structured Query Language
   9 SQL.
  10
  11
  12 Basic Structure
  13 ===============
  14
  15 We map roundup classes to relational tables. Automatically detect schema
  16 changes and modify the gadfly table schemas appropriately. Multilinks
  17 (which represent a many-to-many relationship) are handled through
  18 intermediate tables.
  19
  20 Journals are stored adjunct to the per-class tables.
  21
  22 Table names and columns have "_" prepended so the names can't
  23 clash with restricted names (like "order"). Retirement is determined by the
  24 __retired__ column being true.
  25
  26 All columns are defined as VARCHAR, since it really doesn't matter what
  27 type they're defined as. We stuff all kinds of data in there ;) [as long as
  28 it's marshallable, gadfly doesn't care]
  29
  30
  31 Additional Instance Requirements
  32 ================================
  33
  34 The instance configuration must specify where the database is. It does this
  35 with GADFLY_DATABASE, which is used as the arguments to the gadfly.gadfly()
  36 method:
  37
  38 Using an on-disk database directly (not a good idea):
  39   GADFLY_DATABASE = (database name, directory)
  40
  41 Using a network database (much better idea):
  42   GADFLY_DATABASE = (policy, password, address, port)
  43
  44 Because multiple accesses directly to a gadfly database aren't handled, but
  45 multiple network accesses are, it's strongly advised that the latter setup be
  46 used.
  47
  48 '''
  49
  50 from roundup.backends.rdbms_common import *
  51
  52 # the all-important gadfly :)
  53 import gadfly
  54 import gadfly.client
  55 import gadfly.database
  56
  57 class Database(Database):
  58     # char to use for positional arguments
  59     arg = '?'
  60
  61     def open_connection(self):
  62         db = getattr(self.config, 'GADFLY_DATABASE', ('database', self.dir))
  63         if len(db) == 2:
  64             # ensure files are group readable and writable
  65             os.umask(0002)
  66             try:
  67                 self.conn = gadfly.gadfly(*db)
  68             except IOError, error:
  69                 if error.errno != errno.ENOENT:
  70                     raise
  71                 self.database_schema = {}
  72                 self.conn = gadfly.gadfly()
  73                 self.conn.startup(*db)
  74                 cursor = self.conn.cursor()
  75                 cursor.execute('create table schema (schema varchar)')
  76                 cursor.execute('create table ids (name varchar, num integer)')
  77             else:
  78                 cursor = self.conn.cursor()
  79                 cursor.execute('select schema from schema')
  80                 self.database_schema = cursor.fetchone()[0]
  81         else:
  82             self.conn = gadfly.client.gfclient(*db)
  83             self.database_schema = self.load_dbschema(cursor)
  84
  85     def __repr__(self):
  86         return '<roundfly 0x%x>'%id(self)
  87
  88     def sql_fetchone(self, cursor):
  89         ''' Fetch a single row. If there's nothing to fetch, return None.
  90         '''
  91         try:
  92             return cursor.fetchone()
  93         except gadfly.database.error, message:
  94             if message == 'no more results':
  95                 return None
  96             raise
  97
  98     def save_dbschema(self, cursor, schema):
  99         ''' Save the schema definition that the database currently implements
 100         '''
 101         self.sql(cursor, 'insert into schema values (?)',
 102             (self.database_schema,))
 103
 104     def load_dbschema(self, cursor):
 105         ''' Load the schema definition that the database currently implements
 106         '''
 107         cursor.execute('select schema from schema')
 108         return cursor.fetchone()[0]
 109
 110     def save_journal(self, cursor, 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         cursor.execute(sql, entry)
 124
 125     def load_journal(self, cursor, 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         cursor.execute(sql, (nodeid,))
 134         res = []
 135         for nodeid, date_stamp, user, action, params in cursor.fetchall():
 136             res.append((nodeid, date.Date(date_stamp), user, action, params))
 137         return res
 138