roundup/backends/rdbms_common.py

   1 # $Id: rdbms_common.py,v 1.44 2003-03-16 22:24:55 kedder Exp $
   2 ''' Relational database (SQL) backend common code.
   3
   4 Basics:
   5
   6 - map roundup classes to relational tables
   7 - automatically detect schema changes and modify the table schemas
   8   appropriately (we store the "database version" of the schema in the
   9   database itself as the only row of the "schema" table)
  10 - multilinks (which represent a many-to-many relationship) are handled through
  11   intermediate tables
  12 - journals are stored adjunct to the per-class tables
  13 - table names and columns have "_" prepended so the names can't clash with
  14   restricted names (like "order")
  15 - retirement is determined by the __retired__ column being true
  16
  17 Database-specific changes may generally be pushed out to the overridable
  18 sql_* methods, since everything else should be fairly generic. There's
  19 probably a bit of work to be done if a database is used that actually
  20 honors column typing, since the initial databases don't (sqlite stores
  21 everything as a string, and gadfly stores anything that's marsallable).
  22 '''
  23
  24 # standard python modules
  25 import sys, os, time, re, errno, weakref, copy
  26
  27 # roundup modules
  28 from roundup import hyperdb, date, password, roundupdb, security
  29 from roundup.hyperdb import String, Password, Date, Interval, Link, \
  30     Multilink, DatabaseError, Boolean, Number, Node
  31 from roundup.backends import locking
  32
  33 # support
  34 from blobfiles import FileStorage
  35 from roundup.indexer import Indexer
  36 from sessions import Sessions, OneTimeKeys
  37 from roundup.date import Range
  38
  39 # number of rows to keep in memory
  40 ROW_CACHE_SIZE = 100
  41
  42 class Database(FileStorage, hyperdb.Database, roundupdb.Database):
  43     ''' Wrapper around an SQL database that presents a hyperdb interface.
  44
  45         - some functionality is specific to the actual SQL database, hence
  46           the sql_* methods that are NotImplemented
  47         - we keep a cache of the latest ROW_CACHE_SIZE row fetches.
  48     '''
  49     def __init__(self, config, journaltag=None):
  50         ''' Open the database and load the schema from it.
  51         '''
  52         self.config, self.journaltag = config, journaltag
  53         self.dir = config.DATABASE
  54         self.classes = {}
  55         self.indexer = Indexer(self.dir)
  56         self.sessions = Sessions(self.config)
  57         self.otks = OneTimeKeys(self.config)
  58         self.security = security.Security(self)
  59
  60         # additional transaction support for external files and the like
  61         self.transactions = []
  62
  63         # keep a cache of the N most recently retrieved rows of any kind
  64         # (classname, nodeid) = row
  65         self.cache = {}
  66         self.cache_lru = []
  67
  68         # database lock
  69         self.lockfile = None
  70
  71         # open a connection to the database, creating the "conn" attribute
  72         self.open_connection()
  73
  74     def clearCache(self):
  75         self.cache = {}
  76         self.cache_lru = []
  77
  78     def open_connection(self):
  79         ''' Open a connection to the database, creating it if necessary
  80         '''
  81         raise NotImplemented
  82
  83     def sql(self, sql, args=None):
  84         ''' Execute the sql with the optional args.
  85         '''
  86         if __debug__:
  87             print >>hyperdb.DEBUG, (self, sql, args)
  88         if args:
  89             self.cursor.execute(sql, args)
  90         else:
  91             self.cursor.execute(sql)
  92
  93     def sql_fetchone(self):
  94         ''' Fetch a single row. If there's nothing to fetch, return None.
  95         '''
  96         raise NotImplemented
  97
  98     def sql_stringquote(self, value):
  99         ''' Quote the string so it's safe to put in the 'sql quotes'
 100         '''
 101         return re.sub("'", "''", str(value))
 102
 103     def save_dbschema(self, schema):
 104         ''' Save the schema definition that the database currently implements
 105         '''
 106         raise NotImplemented
 107
 108     def load_dbschema(self):
 109         ''' Load the schema definition that the database currently implements
 110         '''
 111         raise NotImplemented
 112
 113     def post_init(self):
 114         ''' Called once the schema initialisation has finished.
 115
 116             We should now confirm that the schema defined by our "classes"
 117             attribute actually matches the schema in the database.
 118         '''
 119         # now detect changes in the schema
 120         save = 0
 121         for classname, spec in self.classes.items():
 122             if self.database_schema.has_key(classname):
 123                 dbspec = self.database_schema[classname]
 124                 if self.update_class(spec, dbspec):
 125                     self.database_schema[classname] = spec.schema()
 126                     save = 1
 127             else:
 128                 self.create_class(spec)
 129                 self.database_schema[classname] = spec.schema()
 130                 save = 1
 131
 132         for classname in self.database_schema.keys():
 133             if not self.classes.has_key(classname):
 134                 self.drop_class(classname)
 135
 136         # update the database version of the schema
 137         if save:
 138             self.sql('delete from schema')
 139             self.save_dbschema(self.database_schema)
 140
 141         # reindex the db if necessary
 142         if self.indexer.should_reindex():
 143             self.reindex()
 144
 145         # commit
 146         self.conn.commit()
 147
 148         # figure the "curuserid"
 149         if self.journaltag is None:
 150             self.curuserid = None
 151         elif self.journaltag == 'admin':
 152             # admin user may not exist, but always has ID 1
 153             self.curuserid = '1'
 154         else:
 155             self.curuserid = self.user.lookup(self.journaltag)
 156
 157     def reindex(self):
 158         for klass in self.classes.values():
 159             for nodeid in klass.list():
 160                 klass.index(nodeid)
 161         self.indexer.save_index()
 162
 163     def determine_columns(self, properties):
 164         ''' Figure the column names and multilink properties from the spec
 165
 166             "properties" is a list of (name, prop) where prop may be an
 167             instance of a hyperdb "type" _or_ a string repr of that type.
 168         '''
 169         cols = ['_activity', '_creator', '_creation']
 170         mls = []
 171         # add the multilinks separately
 172         for col, prop in properties:
 173             if isinstance(prop, Multilink):
 174                 mls.append(col)
 175             elif isinstance(prop, type('')) and prop.find('Multilink') != -1:
 176                 mls.append(col)
 177             else:
 178                 cols.append('_'+col)
 179         cols.sort()
 180         return cols, mls
 181
 182     def update_class(self, spec, old_spec):
 183         ''' Determine the differences between the current spec and the
 184             database version of the spec, and update where necessary
 185         '''
 186         new_spec = spec
 187         new_has = new_spec.properties.has_key
 188
 189         new_spec = new_spec.schema()
 190         new_spec[1].sort()
 191         old_spec[1].sort()
 192         if new_spec == old_spec:
 193             # no changes
 194             return 0
 195
 196         if __debug__:
 197             print >>hyperdb.DEBUG, 'update_class FIRING'
 198
 199         # key property changed?
 200         if old_spec[0] != new_spec[0]:
 201             if __debug__:
 202                 print >>hyperdb.DEBUG, 'update_class setting keyprop', `spec[0]`
 203             # XXX turn on indexing for the key property
 204
 205         # detect multilinks that have been removed, and drop their table
 206         old_has = {}
 207         for name,prop in old_spec[1]:
 208             old_has[name] = 1
 209             if not new_has(name) and isinstance(prop, Multilink):
 210                 # it's a multilink, and it's been removed - drop the old
 211                 # table
 212                 sql = 'drop table %s_%s'%(spec.classname, prop)
 213                 if __debug__:
 214                     print >>hyperdb.DEBUG, 'update_class', (self, sql)
 215                 self.cursor.execute(sql)
 216                 continue
 217         old_has = old_has.has_key
 218
 219         # now figure how we populate the new table
 220         fetch = ['_activity', '_creation', '_creator']
 221         properties = spec.getprops()
 222         for propname,x in new_spec[1]:
 223             prop = properties[propname]
 224             if isinstance(prop, Multilink):
 225                 if not old_has(propname):
 226                     # we need to create the new table
 227                     self.create_multilink_table(spec, propname)
 228             elif old_has(propname):
 229                 # we copy this col over from the old table
 230                 fetch.append('_'+propname)
 231
 232         # select the data out of the old table
 233         fetch.append('id')
 234         fetch.append('__retired__')
 235         fetchcols = ','.join(fetch)
 236         cn = spec.classname
 237         sql = 'select %s from _%s'%(fetchcols, cn)
 238         if __debug__:
 239             print >>hyperdb.DEBUG, 'update_class', (self, sql)
 240         self.cursor.execute(sql)
 241         olddata = self.cursor.fetchall()
 242
 243         # drop the old table
 244         self.cursor.execute('drop table _%s'%cn)
 245
 246         # create the new table
 247         self.create_class_table(spec)
 248
 249         if olddata:
 250             # do the insert
 251             args = ','.join([self.arg for x in fetch])
 252             sql = 'insert into _%s (%s) values (%s)'%(cn, fetchcols, args)
 253             if __debug__:
 254                 print >>hyperdb.DEBUG, 'update_class', (self, sql, olddata[0])
 255             for entry in olddata:
 256                 self.cursor.execute(sql, tuple(entry))
 257
 258         return 1
 259
 260     def create_class_table(self, spec):
 261         ''' create the class table for the given spec
 262         '''
 263         cols, mls = self.determine_columns(spec.properties.items())
 264
 265         # add on our special columns
 266         cols.append('id')
 267         cols.append('__retired__')
 268
 269         # create the base table
 270         scols = ','.join(['%s varchar'%x for x in cols])
 271         sql = 'create table _%s (%s)'%(spec.classname, scols)
 272         if __debug__:
 273             print >>hyperdb.DEBUG, 'create_class', (self, sql)
 274         self.cursor.execute(sql)
 275
 276         return cols, mls
 277
 278     def create_journal_table(self, spec):
 279         ''' create the journal table for a class given the spec and
 280             already-determined cols
 281         '''
 282         # journal table
 283         cols = ','.join(['%s varchar'%x
 284             for x in 'nodeid date tag action params'.split()])
 285         sql = 'create table %s__journal (%s)'%(spec.classname, cols)
 286         if __debug__:
 287             print >>hyperdb.DEBUG, 'create_class', (self, sql)
 288         self.cursor.execute(sql)
 289
 290     def create_multilink_table(self, spec, ml):
 291         ''' Create a multilink table for the "ml" property of the class
 292             given by the spec
 293         '''
 294         sql = 'create table %s_%s (linkid varchar, nodeid varchar)'%(
 295             spec.classname, ml)
 296         if __debug__:
 297             print >>hyperdb.DEBUG, 'create_class', (self, sql)
 298         self.cursor.execute(sql)
 299
 300     def create_class(self, spec):
 301         ''' Create a database table according to the given spec.
 302         '''
 303         cols, mls = self.create_class_table(spec)
 304         self.create_journal_table(spec)
 305
 306         # now create the multilink tables
 307         for ml in mls:
 308             self.create_multilink_table(spec, ml)
 309
 310         # ID counter
 311         sql = 'insert into ids (name, num) values (%s,%s)'%(self.arg, self.arg)
 312         vals = (spec.classname, 1)
 313         if __debug__:
 314             print >>hyperdb.DEBUG, 'create_class', (self, sql, vals)
 315         self.cursor.execute(sql, vals)
 316
 317     def drop_class(self, spec):
 318         ''' Drop the given table from the database.
 319
 320             Drop the journal and multilink tables too.
 321         '''
 322         # figure the multilinks
 323         mls = []
 324         for col, prop in spec.properties.items():
 325             if isinstance(prop, Multilink):
 326                 mls.append(col)
 327
 328         sql = 'drop table _%s'%spec.classname
 329         if __debug__:
 330             print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 331         self.cursor.execute(sql)
 332
 333         sql = 'drop table %s__journal'%spec.classname
 334         if __debug__:
 335             print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 336         self.cursor.execute(sql)
 337
 338         for ml in mls:
 339             sql = 'drop table %s_%s'%(spec.classname, ml)
 340             if __debug__:
 341                 print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 342             self.cursor.execute(sql)
 343
 344     #
 345     # Classes
 346     #
 347     def __getattr__(self, classname):
 348         ''' A convenient way of calling self.getclass(classname).
 349         '''
 350         if self.classes.has_key(classname):
 351             if __debug__:
 352                 print >>hyperdb.DEBUG, '__getattr__', (self, classname)
 353             return self.classes[classname]
 354         raise AttributeError, classname
 355
 356     def addclass(self, cl):
 357         ''' Add a Class to the hyperdatabase.
 358         '''
 359         if __debug__:
 360             print >>hyperdb.DEBUG, 'addclass', (self, cl)
 361         cn = cl.classname
 362         if self.classes.has_key(cn):
 363             raise ValueError, cn
 364         self.classes[cn] = cl
 365
 366     def getclasses(self):
 367         ''' Return a list of the names of all existing classes.
 368         '''
 369         if __debug__:
 370             print >>hyperdb.DEBUG, 'getclasses', (self,)
 371         l = self.classes.keys()
 372         l.sort()
 373         return l
 374
 375     def getclass(self, classname):
 376         '''Get the Class object representing a particular class.
 377
 378         If 'classname' is not a valid class name, a KeyError is raised.
 379         '''
 380         if __debug__:
 381             print >>hyperdb.DEBUG, 'getclass', (self, classname)
 382         try:
 383             return self.classes[classname]
 384         except KeyError:
 385             raise KeyError, 'There is no class called "%s"'%classname
 386
 387     def clear(self):
 388         ''' Delete all database contents.
 389
 390             Note: I don't commit here, which is different behaviour to the
 391             "nuke from orbit" behaviour in the *dbms.
 392         '''
 393         if __debug__:
 394             print >>hyperdb.DEBUG, 'clear', (self,)
 395         for cn in self.classes.keys():
 396             sql = 'delete from _%s'%cn
 397             if __debug__:
 398                 print >>hyperdb.DEBUG, 'clear', (self, sql)
 399             self.cursor.execute(sql)
 400
 401     #
 402     # Node IDs
 403     #
 404     def newid(self, classname):
 405         ''' Generate a new id for the given class
 406         '''
 407         # get the next ID
 408         sql = 'select num from ids where name=%s'%self.arg
 409         if __debug__:
 410             print >>hyperdb.DEBUG, 'newid', (self, sql, classname)
 411         self.cursor.execute(sql, (classname, ))
 412         newid = self.cursor.fetchone()[0]
 413
 414         # update the counter
 415         sql = 'update ids set num=%s where name=%s'%(self.arg, self.arg)
 416         vals = (int(newid)+1, classname)
 417         if __debug__:
 418             print >>hyperdb.DEBUG, 'newid', (self, sql, vals)
 419         self.cursor.execute(sql, vals)
 420
 421         # return as string
 422         return str(newid)
 423
 424     def setid(self, classname, setid):
 425         ''' Set the id counter: used during import of database
 426         '''
 427         sql = 'update ids set num=%s where name=%s'%(self.arg, self.arg)
 428         vals = (setid, classname)
 429         if __debug__:
 430             print >>hyperdb.DEBUG, 'setid', (self, sql, vals)
 431         self.cursor.execute(sql, vals)
 432
 433     #
 434     # Nodes
 435     #
 436
 437     def addnode(self, classname, nodeid, node):
 438         ''' Add the specified node to its class's db.
 439         '''
 440         if __debug__:
 441             print >>hyperdb.DEBUG, 'addnode', (self, classname, nodeid, node)
 442         # gadfly requires values for all non-multilink columns
 443         cl = self.classes[classname]
 444         cols, mls = self.determine_columns(cl.properties.items())
 445
 446         # we'll be supplied these props if we're doing an import
 447         if not node.has_key('creator'):
 448             # add in the "calculated" properties (dupe so we don't affect
 449             # calling code's node assumptions)
 450             node = node.copy()
 451             node['creation'] = node['activity'] = date.Date()
 452             node['creator'] = self.curuserid
 453
 454         # default the non-multilink columns
 455         for col, prop in cl.properties.items():
 456             if not node.has_key(col):
 457                 if isinstance(prop, Multilink):
 458                     node[col] = []
 459                 else:
 460                     node[col] = None
 461
 462         # clear this node out of the cache if it's in there
 463         key = (classname, nodeid)
 464         if self.cache.has_key(key):
 465             del self.cache[key]
 466             self.cache_lru.remove(key)
 467
 468         # make the node data safe for the DB
 469         node = self.serialise(classname, node)
 470
 471         # make sure the ordering is correct for column name -> column value
 472         vals = tuple([node[col[1:]] for col in cols]) + (nodeid, 0)
 473         s = ','.join([self.arg for x in cols]) + ',%s,%s'%(self.arg, self.arg)
 474         cols = ','.join(cols) + ',id,__retired__'
 475
 476         # perform the inserts
 477         sql = 'insert into _%s (%s) values (%s)'%(classname, cols, s)
 478         if __debug__:
 479             print >>hyperdb.DEBUG, 'addnode', (self, sql, vals)
 480         self.cursor.execute(sql, vals)
 481
 482         # insert the multilink rows
 483         for col in mls:
 484             t = '%s_%s'%(classname, col)
 485             for entry in node[col]:
 486                 sql = 'insert into %s (linkid, nodeid) values (%s,%s)'%(t,
 487                     self.arg, self.arg)
 488                 self.sql(sql, (entry, nodeid))
 489
 490         # make sure we do the commit-time extra stuff for this node
 491         self.transactions.append((self.doSaveNode, (classname, nodeid, node)))
 492
 493     def setnode(self, classname, nodeid, values, multilink_changes):
 494         ''' Change the specified node.
 495         '''
 496         if __debug__:
 497             print >>hyperdb.DEBUG, 'setnode', (self, classname, nodeid, values)
 498
 499         # clear this node out of the cache if it's in there
 500         key = (classname, nodeid)
 501         if self.cache.has_key(key):
 502             del self.cache[key]
 503             self.cache_lru.remove(key)
 504
 505         # add the special props
 506         values = values.copy()
 507         values['activity'] = date.Date()
 508
 509         # make db-friendly
 510         values = self.serialise(classname, values)
 511
 512         cl = self.classes[classname]
 513         cols = []
 514         mls = []
 515         # add the multilinks separately
 516         props = cl.getprops()
 517         for col in values.keys():
 518             prop = props[col]
 519             if isinstance(prop, Multilink):
 520                 mls.append(col)
 521             else:
 522                 cols.append('_'+col)
 523         cols.sort()
 524
 525         # if there's any updates to regular columns, do them
 526         if cols:
 527             # make sure the ordering is correct for column name -> column value
 528             sqlvals = tuple([values[col[1:]] for col in cols]) + (nodeid,)
 529             s = ','.join(['%s=%s'%(x, self.arg) for x in cols])
 530             cols = ','.join(cols)
 531
 532             # perform the update
 533             sql = 'update _%s set %s where id=%s'%(classname, s, self.arg)
 534             if __debug__:
 535                 print >>hyperdb.DEBUG, 'setnode', (self, sql, sqlvals)
 536             self.cursor.execute(sql, sqlvals)
 537
 538         # now the fun bit, updating the multilinks ;)
 539         for col, (add, remove) in multilink_changes.items():
 540             tn = '%s_%s'%(classname, col)
 541             if add:
 542                 sql = 'insert into %s (nodeid, linkid) values (%s,%s)'%(tn,
 543                     self.arg, self.arg)
 544                 for addid in add:
 545                     self.sql(sql, (nodeid, addid))
 546             if remove:
 547                 sql = 'delete from %s where nodeid=%s and linkid=%s'%(tn,
 548                     self.arg, self.arg)
 549                 for removeid in remove:
 550                     self.sql(sql, (nodeid, removeid))
 551
 552         # make sure we do the commit-time extra stuff for this node
 553         self.transactions.append((self.doSaveNode, (classname, nodeid, values)))
 554
 555     def getnode(self, classname, nodeid):
 556         ''' Get a node from the database.
 557         '''
 558         if __debug__:
 559             print >>hyperdb.DEBUG, 'getnode', (self, classname, nodeid)
 560
 561         # see if we have this node cached
 562         key = (classname, nodeid)
 563         if self.cache.has_key(key):
 564             # push us back to the top of the LRU
 565             self.cache_lru.remove(key)
 566             self.cache_lru.insert(0, key)
 567             # return the cached information
 568             return self.cache[key]
 569
 570         # figure the columns we're fetching
 571         cl = self.classes[classname]
 572         cols, mls = self.determine_columns(cl.properties.items())
 573         scols = ','.join(cols)
 574
 575         # perform the basic property fetch
 576         sql = 'select %s from _%s where id=%s'%(scols, classname, self.arg)
 577         self.sql(sql, (nodeid,))
 578
 579         values = self.sql_fetchone()
 580         if values is None:
 581             raise IndexError, 'no such %s node %s'%(classname, nodeid)
 582
 583         # make up the node
 584         node = {}
 585         for col in range(len(cols)):
 586             node[cols[col][1:]] = values[col]
 587
 588         # now the multilinks
 589         for col in mls:
 590             # get the link ids
 591             sql = 'select linkid from %s_%s where nodeid=%s'%(classname, col,
 592                 self.arg)
 593             self.cursor.execute(sql, (nodeid,))
 594             # extract the first column from the result
 595             node[col] = [x[0] for x in self.cursor.fetchall()]
 596
 597         # un-dbificate the node data
 598         node = self.unserialise(classname, node)
 599
 600         # save off in the cache
 601         key = (classname, nodeid)
 602         self.cache[key] = node
 603         # update the LRU
 604         self.cache_lru.insert(0, key)
 605         if len(self.cache_lru) > ROW_CACHE_SIZE:
 606             del self.cache[self.cache_lru.pop()]
 607
 608         return node
 609
 610     def destroynode(self, classname, nodeid):
 611         '''Remove a node from the database. Called exclusively by the
 612            destroy() method on Class.
 613         '''
 614         if __debug__:
 615             print >>hyperdb.DEBUG, 'destroynode', (self, classname, nodeid)
 616
 617         # make sure the node exists
 618         if not self.hasnode(classname, nodeid):
 619             raise IndexError, '%s has no node %s'%(classname, nodeid)
 620
 621         # see if we have this node cached
 622         if self.cache.has_key((classname, nodeid)):
 623             del self.cache[(classname, nodeid)]
 624
 625         # see if there's any obvious commit actions that we should get rid of
 626         for entry in self.transactions[:]:
 627             if entry[1][:2] == (classname, nodeid):
 628                 self.transactions.remove(entry)
 629
 630         # now do the SQL
 631         sql = 'delete from _%s where id=%s'%(classname, self.arg)
 632         self.sql(sql, (nodeid,))
 633
 634         # remove from multilnks
 635         cl = self.getclass(classname)
 636         x, mls = self.determine_columns(cl.properties.items())
 637         for col in mls:
 638             # get the link ids
 639             sql = 'delete from %s_%s where nodeid=%s'%(classname, col, self.arg)
 640             self.cursor.execute(sql, (nodeid,))
 641
 642         # remove journal entries
 643         sql = 'delete from %s__journal where nodeid=%s'%(classname, self.arg)
 644         self.sql(sql, (nodeid,))
 645
 646     def serialise(self, classname, node):
 647         '''Copy the node contents, converting non-marshallable data into
 648            marshallable data.
 649         '''
 650         if __debug__:
 651             print >>hyperdb.DEBUG, 'serialise', classname, node
 652         properties = self.getclass(classname).getprops()
 653         d = {}
 654         for k, v in node.items():
 655             # if the property doesn't exist, or is the "retired" flag then
 656             # it won't be in the properties dict
 657             if not properties.has_key(k):
 658                 d[k] = v
 659                 continue
 660
 661             # get the property spec
 662             prop = properties[k]
 663
 664             if isinstance(prop, Password) and v is not None:
 665                 d[k] = str(v)
 666             elif isinstance(prop, Date) and v is not None:
 667                 d[k] = v.serialise()
 668             elif isinstance(prop, Interval) and v is not None:
 669                 d[k] = v.serialise()
 670             else:
 671                 d[k] = v
 672         return d
 673
 674     def unserialise(self, classname, node):
 675         '''Decode the marshalled node data
 676         '''
 677         if __debug__:
 678             print >>hyperdb.DEBUG, 'unserialise', classname, node
 679         properties = self.getclass(classname).getprops()
 680         d = {}
 681         for k, v in node.items():
 682             # if the property doesn't exist, or is the "retired" flag then
 683             # it won't be in the properties dict
 684             if not properties.has_key(k):
 685                 d[k] = v
 686                 continue
 687
 688             # get the property spec
 689             prop = properties[k]
 690
 691             if isinstance(prop, Date) and v is not None:
 692                 d[k] = date.Date(v)
 693             elif isinstance(prop, Interval) and v is not None:
 694                 d[k] = date.Interval(v)
 695             elif isinstance(prop, Password) and v is not None:
 696                 p = password.Password()
 697                 p.unpack(v)
 698                 d[k] = p
 699             elif (isinstance(prop, Boolean) or isinstance(prop, Number)) and v is not None:
 700                 d[k]=float(v)
 701             else:
 702                 d[k] = v
 703         return d
 704
 705     def hasnode(self, classname, nodeid):
 706         ''' Determine if the database has a given node.
 707         '''
 708         sql = 'select count(*) from _%s where id=%s'%(classname, self.arg)
 709         if __debug__:
 710             print >>hyperdb.DEBUG, 'hasnode', (self, sql, nodeid)
 711         self.cursor.execute(sql, (nodeid,))
 712         return int(self.cursor.fetchone()[0])
 713
 714     def countnodes(self, classname):
 715         ''' Count the number of nodes that exist for a particular Class.
 716         '''
 717         sql = 'select count(*) from _%s'%classname
 718         if __debug__:
 719             print >>hyperdb.DEBUG, 'countnodes', (self, sql)
 720         self.cursor.execute(sql)
 721         return self.cursor.fetchone()[0]
 722
 723     def addjournal(self, classname, nodeid, action, params, creator=None,
 724             creation=None):
 725         ''' Journal the Action
 726         'action' may be:
 727
 728             'create' or 'set' -- 'params' is a dictionary of property values
 729             'link' or 'unlink' -- 'params' is (classname, nodeid, propname)
 730             'retire' -- 'params' is None
 731         '''
 732         # serialise the parameters now if necessary
 733         if isinstance(params, type({})):
 734             if action in ('set', 'create'):
 735                 params = self.serialise(classname, params)
 736
 737         # handle supply of the special journalling parameters (usually
 738         # supplied on importing an existing database)
 739         if creator:
 740             journaltag = creator
 741         else:
 742             journaltag = self.curuserid
 743         if creation:
 744             journaldate = creation.serialise()
 745         else:
 746             journaldate = date.Date().serialise()
 747
 748         # create the journal entry
 749         cols = ','.join('nodeid date tag action params'.split())
 750
 751         if __debug__:
 752             print >>hyperdb.DEBUG, 'addjournal', (nodeid, journaldate,
 753                 journaltag, action, params)
 754
 755         self.save_journal(classname, cols, nodeid, journaldate,
 756             journaltag, action, params)
 757
 758     def save_journal(self, classname, cols, nodeid, journaldate,
 759             journaltag, action, params):
 760         ''' Save the journal entry to the database
 761         '''
 762         raise NotImplemented
 763
 764     def getjournal(self, classname, nodeid):
 765         ''' get the journal for id
 766         '''
 767         # make sure the node exists
 768         if not self.hasnode(classname, nodeid):
 769             raise IndexError, '%s has no node %s'%(classname, nodeid)
 770
 771         cols = ','.join('nodeid date tag action params'.split())
 772         return self.load_journal(classname, cols, nodeid)
 773
 774     def load_journal(self, classname, cols, nodeid):
 775         ''' Load the journal from the database
 776         '''
 777         raise NotImplemented
 778
 779     def pack(self, pack_before):
 780         ''' Delete all journal entries except "create" before 'pack_before'.
 781         '''
 782         # get a 'yyyymmddhhmmss' version of the date
 783         date_stamp = pack_before.serialise()
 784
 785         # do the delete
 786         for classname in self.classes.keys():
 787             sql = "delete from %s__journal where date<%s and "\
 788                 "action<>'create'"%(classname, self.arg)
 789             if __debug__:
 790                 print >>hyperdb.DEBUG, 'pack', (self, sql, date_stamp)
 791             self.cursor.execute(sql, (date_stamp,))
 792
 793     def sql_commit(self):
 794         ''' Actually commit to the database.
 795         '''
 796         self.conn.commit()
 797
 798     def commit(self):
 799         ''' Commit the current transactions.
 800
 801         Save all data changed since the database was opened or since the
 802         last commit() or rollback().
 803         '''
 804         if __debug__:
 805             print >>hyperdb.DEBUG, 'commit', (self,)
 806
 807         # commit the database
 808         self.sql_commit()
 809
 810         # now, do all the other transaction stuff
 811         reindex = {}
 812         for method, args in self.transactions:
 813             reindex[method(*args)] = 1
 814
 815         # reindex the nodes that request it
 816         for classname, nodeid in filter(None, reindex.keys()):
 817             print >>hyperdb.DEBUG, 'commit.reindex', (classname, nodeid)
 818             self.getclass(classname).index(nodeid)
 819
 820         # save the indexer state
 821         self.indexer.save_index()
 822
 823         # clear out the transactions
 824         self.transactions = []
 825
 826     def rollback(self):
 827         ''' Reverse all actions from the current transaction.
 828
 829         Undo all the changes made since the database was opened or the last
 830         commit() or rollback() was performed.
 831         '''
 832         if __debug__:
 833             print >>hyperdb.DEBUG, 'rollback', (self,)
 834
 835         # roll back
 836         self.conn.rollback()
 837
 838         # roll back "other" transaction stuff
 839         for method, args in self.transactions:
 840             # delete temporary files
 841             if method == self.doStoreFile:
 842                 self.rollbackStoreFile(*args)
 843         self.transactions = []
 844
 845         # clear the cache
 846         self.clearCache()
 847
 848     def doSaveNode(self, classname, nodeid, node):
 849         ''' dummy that just generates a reindex event
 850         '''
 851         # return the classname, nodeid so we reindex this content
 852         return (classname, nodeid)
 853
 854     def close(self):
 855         ''' Close off the connection.
 856         '''
 857         self.conn.close()
 858         if self.lockfile is not None:
 859             locking.release_lock(self.lockfile)
 860         if self.lockfile is not None:
 861             self.lockfile.close()
 862             self.lockfile = None
 863
 864 #
 865 # The base Class class
 866 #
 867 class Class(hyperdb.Class):
 868     ''' The handle to a particular class of nodes in a hyperdatabase.
 869
 870         All methods except __repr__ and getnode must be implemented by a
 871         concrete backend Class.
 872     '''
 873
 874     def __init__(self, db, classname, **properties):
 875         '''Create a new class with a given name and property specification.
 876
 877         'classname' must not collide with the name of an existing class,
 878         or a ValueError is raised.  The keyword arguments in 'properties'
 879         must map names to property objects, or a TypeError is raised.
 880         '''
 881         if (properties.has_key('creation') or properties.has_key('activity')
 882                 or properties.has_key('creator')):
 883             raise ValueError, '"creation", "activity" and "creator" are '\
 884                 'reserved'
 885
 886         self.classname = classname
 887         self.properties = properties
 888         self.db = weakref.proxy(db)       # use a weak ref to avoid circularity
 889         self.key = ''
 890
 891         # should we journal changes (default yes)
 892         self.do_journal = 1
 893
 894         # do the db-related init stuff
 895         db.addclass(self)
 896
 897         self.auditors = {'create': [], 'set': [], 'retire': [], 'restore': []}
 898         self.reactors = {'create': [], 'set': [], 'retire': [], 'restore': []}
 899
 900     def schema(self):
 901         ''' A dumpable version of the schema that we can store in the
 902             database
 903         '''
 904         return (self.key, [(x, repr(y)) for x,y in self.properties.items()])
 905
 906     def enableJournalling(self):
 907         '''Turn journalling on for this class
 908         '''
 909         self.do_journal = 1
 910
 911     def disableJournalling(self):
 912         '''Turn journalling off for this class
 913         '''
 914         self.do_journal = 0
 915
 916     # Editing nodes:
 917     def create(self, **propvalues):
 918         ''' Create a new node of this class and return its id.
 919
 920         The keyword arguments in 'propvalues' map property names to values.
 921
 922         The values of arguments must be acceptable for the types of their
 923         corresponding properties or a TypeError is raised.
 924
 925         If this class has a key property, it must be present and its value
 926         must not collide with other key strings or a ValueError is raised.
 927
 928         Any other properties on this class that are missing from the
 929         'propvalues' dictionary are set to None.
 930
 931         If an id in a link or multilink property does not refer to a valid
 932         node, an IndexError is raised.
 933         '''
 934         self.fireAuditors('create', None, propvalues)
 935         newid = self.create_inner(**propvalues)
 936         self.fireReactors('create', newid, None)
 937         return newid
 938
 939     def create_inner(self, **propvalues):
 940         ''' Called by create, in-between the audit and react calls.
 941         '''
 942         if propvalues.has_key('id'):
 943             raise KeyError, '"id" is reserved'
 944
 945         if self.db.journaltag is None:
 946             raise DatabaseError, 'Database open read-only'
 947
 948         if propvalues.has_key('creation') or propvalues.has_key('activity'):
 949             raise KeyError, '"creation" and "activity" are reserved'
 950
 951         # new node's id
 952         newid = self.db.newid(self.classname)
 953
 954         # validate propvalues
 955         num_re = re.compile('^\d+$')
 956         for key, value in propvalues.items():
 957             if key == self.key:
 958                 try:
 959                     self.lookup(value)
 960                 except KeyError:
 961                     pass
 962                 else:
 963                     raise ValueError, 'node with key "%s" exists'%value
 964
 965             # try to handle this property
 966             try:
 967                 prop = self.properties[key]
 968             except KeyError:
 969                 raise KeyError, '"%s" has no property "%s"'%(self.classname,
 970                     key)
 971
 972             if value is not None and isinstance(prop, Link):
 973                 if type(value) != type(''):
 974                     raise ValueError, 'link value must be String'
 975                 link_class = self.properties[key].classname
 976                 # if it isn't a number, it's a key
 977                 if not num_re.match(value):
 978                     try:
 979                         value = self.db.classes[link_class].lookup(value)
 980                     except (TypeError, KeyError):
 981                         raise IndexError, 'new property "%s": %s not a %s'%(
 982                             key, value, link_class)
 983                 elif not self.db.getclass(link_class).hasnode(value):
 984                     raise IndexError, '%s has no node %s'%(link_class, value)
 985
 986                 # save off the value
 987                 propvalues[key] = value
 988
 989                 # register the link with the newly linked node
 990                 if self.do_journal and self.properties[key].do_journal:
 991                     self.db.addjournal(link_class, value, 'link',
 992                         (self.classname, newid, key))
 993
 994             elif isinstance(prop, Multilink):
 995                 if type(value) != type([]):
 996                     raise TypeError, 'new property "%s" not a list of ids'%key
 997
 998                 # clean up and validate the list of links
 999                 link_class = self.properties[key].classname
1000                 l = []
1001                 for entry in value:
1002                     if type(entry) != type(''):
1003                         raise ValueError, '"%s" multilink value (%r) '\
1004                             'must contain Strings'%(key, value)
1005                     # if it isn't a number, it's a key
1006                     if not num_re.match(entry):
1007                         try:
1008                             entry = self.db.classes[link_class].lookup(entry)
1009                         except (TypeError, KeyError):
1010                             raise IndexError, 'new property "%s": %s not a %s'%(
1011                                 key, entry, self.properties[key].classname)
1012                     l.append(entry)
1013                 value = l
1014                 propvalues[key] = value
1015
1016                 # handle additions
1017                 for nodeid in value:
1018                     if not self.db.getclass(link_class).hasnode(nodeid):
1019                         raise IndexError, '%s has no node %s'%(link_class,
1020                             nodeid)
1021                     # register the link with the newly linked node
1022                     if self.do_journal and self.properties[key].do_journal:
1023                         self.db.addjournal(link_class, nodeid, 'link',
1024                             (self.classname, newid, key))
1025
1026             elif isinstance(prop, String):
1027                 if type(value) != type('') and type(value) != type(u''):
1028                     raise TypeError, 'new property "%s" not a string'%key
1029
1030             elif isinstance(prop, Password):
1031                 if not isinstance(value, password.Password):
1032                     raise TypeError, 'new property "%s" not a Password'%key
1033
1034             elif isinstance(prop, Date):
1035                 if value is not None and not isinstance(value, date.Date):
1036                     raise TypeError, 'new property "%s" not a Date'%key
1037
1038             elif isinstance(prop, Interval):
1039                 if value is not None and not isinstance(value, date.Interval):
1040                     raise TypeError, 'new property "%s" not an Interval'%key
1041
1042             elif value is not None and isinstance(prop, Number):
1043                 try:
1044                     float(value)
1045                 except ValueError:
1046                     raise TypeError, 'new property "%s" not numeric'%key
1047
1048             elif value is not None and isinstance(prop, Boolean):
1049                 try:
1050                     int(value)
1051                 except ValueError:
1052                     raise TypeError, 'new property "%s" not boolean'%key
1053
1054         # make sure there's data where there needs to be
1055         for key, prop in self.properties.items():
1056             if propvalues.has_key(key):
1057                 continue
1058             if key == self.key:
1059                 raise ValueError, 'key property "%s" is required'%key
1060             if isinstance(prop, Multilink):
1061                 propvalues[key] = []
1062             else:
1063                 propvalues[key] = None
1064
1065         # done
1066         self.db.addnode(self.classname, newid, propvalues)
1067         if self.do_journal:
1068             self.db.addjournal(self.classname, newid, 'create', {})
1069
1070         return newid
1071
1072     def export_list(self, propnames, nodeid):
1073         ''' Export a node - generate a list of CSV-able data in the order
1074             specified by propnames for the given node.
1075         '''
1076         properties = self.getprops()
1077         l = []
1078         for prop in propnames:
1079             proptype = properties[prop]
1080             value = self.get(nodeid, prop)
1081             # "marshal" data where needed
1082             if value is None:
1083                 pass
1084             elif isinstance(proptype, hyperdb.Date):
1085                 value = value.get_tuple()
1086             elif isinstance(proptype, hyperdb.Interval):
1087                 value = value.get_tuple()
1088             elif isinstance(proptype, hyperdb.Password):
1089                 value = str(value)
1090             l.append(repr(value))
1091         l.append(self.is_retired(nodeid))
1092         return l
1093
1094     def import_list(self, propnames, proplist):
1095         ''' Import a node - all information including "id" is present and
1096             should not be sanity checked. Triggers are not triggered. The
1097             journal should be initialised using the "creator" and "created"
1098             information.
1099
1100             Return the nodeid of the node imported.
1101         '''
1102         if self.db.journaltag is None:
1103             raise DatabaseError, 'Database open read-only'
1104         properties = self.getprops()
1105
1106         # make the new node's property map
1107         d = {}
1108         retire = 0
1109         newid = None
1110         for i in range(len(propnames)):
1111             # Use eval to reverse the repr() used to output the CSV
1112             value = eval(proplist[i])
1113
1114             # Figure the property for this column
1115             propname = propnames[i]
1116
1117             # "unmarshal" where necessary
1118             if propname == 'id':
1119                 newid = value
1120                 continue
1121             elif propname == 'is retired':
1122                 # is the item retired?
1123                 if int(value):
1124                     retire = 1
1125                 continue
1126
1127             prop = properties[propname]
1128             if value is None:
1129                 # don't set Nones
1130                 continue
1131             elif isinstance(prop, hyperdb.Date):
1132                 value = date.Date(value)
1133             elif isinstance(prop, hyperdb.Interval):
1134                 value = date.Interval(value)
1135             elif isinstance(prop, hyperdb.Password):
1136                 pwd = password.Password()
1137                 pwd.unpack(value)
1138                 value = pwd
1139             d[propname] = value
1140
1141         # get a new id if necessary
1142         if newid is None:
1143             newid = self.db.newid(self.classname)
1144
1145         # retire?
1146         if retire:
1147             # use the arg for __retired__ to cope with any odd database type
1148             # conversion (hello, sqlite)
1149             sql = 'update _%s set __retired__=%s where id=%s'%(self.classname,
1150                 self.db.arg, self.db.arg)
1151             if __debug__:
1152                 print >>hyperdb.DEBUG, 'retire', (self, sql, newid)
1153             self.db.cursor.execute(sql, (1, newid))
1154
1155         # add the node and journal
1156         self.db.addnode(self.classname, newid, d)
1157
1158         # extract the extraneous journalling gumpf and nuke it
1159         if d.has_key('creator'):
1160             creator = d['creator']
1161             del d['creator']
1162         else:
1163             creator = None
1164         if d.has_key('creation'):
1165             creation = d['creation']
1166             del d['creation']
1167         else:
1168             creation = None
1169         if d.has_key('activity'):
1170             del d['activity']
1171         self.db.addjournal(self.classname, newid, 'create', {}, creator,
1172             creation)
1173         return newid
1174
1175     _marker = []
1176     def get(self, nodeid, propname, default=_marker, cache=1):
1177         '''Get the value of a property on an existing node of this class.
1178
1179         'nodeid' must be the id of an existing node of this class or an
1180         IndexError is raised.  'propname' must be the name of a property
1181         of this class or a KeyError is raised.
1182
1183         'cache' indicates whether the transaction cache should be queried
1184         for the node. If the node has been modified and you need to
1185         determine what its values prior to modification are, you need to
1186         set cache=0.
1187         '''
1188         if propname == 'id':
1189             return nodeid
1190
1191         # get the node's dict
1192         d = self.db.getnode(self.classname, nodeid)
1193
1194         if propname == 'creation':
1195             if d.has_key('creation'):
1196                 return d['creation']
1197             else:
1198                 return date.Date()
1199         if propname == 'activity':
1200             if d.has_key('activity'):
1201                 return d['activity']
1202             else:
1203                 return date.Date()
1204         if propname == 'creator':
1205             if d.has_key('creator'):
1206                 return d['creator']
1207             else:
1208                 return self.db.curuserid
1209
1210         # get the property (raises KeyErorr if invalid)
1211         prop = self.properties[propname]
1212
1213         if not d.has_key(propname):
1214             if default is self._marker:
1215                 if isinstance(prop, Multilink):
1216                     return []
1217                 else:
1218                     return None
1219             else:
1220                 return default
1221
1222         # don't pass our list to other code
1223         if isinstance(prop, Multilink):
1224             return d[propname][:]
1225
1226         return d[propname]
1227
1228     def getnode(self, nodeid, cache=1):
1229         ''' Return a convenience wrapper for the node.
1230
1231         'nodeid' must be the id of an existing node of this class or an
1232         IndexError is raised.
1233
1234         'cache' indicates whether the transaction cache should be queried
1235         for the node. If the node has been modified and you need to
1236         determine what its values prior to modification are, you need to
1237         set cache=0.
1238         '''
1239         return Node(self, nodeid, cache=cache)
1240
1241     def set(self, nodeid, **propvalues):
1242         '''Modify a property on an existing node of this class.
1243
1244         'nodeid' must be the id of an existing node of this class or an
1245         IndexError is raised.
1246
1247         Each key in 'propvalues' must be the name of a property of this
1248         class or a KeyError is raised.
1249
1250         All values in 'propvalues' must be acceptable types for their
1251         corresponding properties or a TypeError is raised.
1252
1253         If the value of the key property is set, it must not collide with
1254         other key strings or a ValueError is raised.
1255
1256         If the value of a Link or Multilink property contains an invalid
1257         node id, a ValueError is raised.
1258         '''
1259         if not propvalues:
1260             return propvalues
1261
1262         if propvalues.has_key('creation') or propvalues.has_key('activity'):
1263             raise KeyError, '"creation" and "activity" are reserved'
1264
1265         if propvalues.has_key('id'):
1266             raise KeyError, '"id" is reserved'
1267
1268         if self.db.journaltag is None:
1269             raise DatabaseError, 'Database open read-only'
1270
1271         self.fireAuditors('set', nodeid, propvalues)
1272         # Take a copy of the node dict so that the subsequent set
1273         # operation doesn't modify the oldvalues structure.
1274         # XXX used to try the cache here first
1275         oldvalues = copy.deepcopy(self.db.getnode(self.classname, nodeid))
1276
1277         node = self.db.getnode(self.classname, nodeid)
1278         if self.is_retired(nodeid):
1279             raise IndexError, 'Requested item is retired'
1280         num_re = re.compile('^\d+$')
1281
1282         # if the journal value is to be different, store it in here
1283         journalvalues = {}
1284
1285         # remember the add/remove stuff for multilinks, making it easier
1286         # for the Database layer to do its stuff
1287         multilink_changes = {}
1288
1289         for propname, value in propvalues.items():
1290             # check to make sure we're not duplicating an existing key
1291             if propname == self.key and node[propname] != value:
1292                 try:
1293                     self.lookup(value)
1294                 except KeyError:
1295                     pass
1296                 else:
1297                     raise ValueError, 'node with key "%s" exists'%value
1298
1299             # this will raise the KeyError if the property isn't valid
1300             # ... we don't use getprops() here because we only care about
1301             # the writeable properties.
1302             try:
1303                 prop = self.properties[propname]
1304             except KeyError:
1305                 raise KeyError, '"%s" has no property named "%s"'%(
1306                     self.classname, propname)
1307
1308             # if the value's the same as the existing value, no sense in
1309             # doing anything
1310             current = node.get(propname, None)
1311             if value == current:
1312                 del propvalues[propname]
1313                 continue
1314             journalvalues[propname] = current
1315
1316             # do stuff based on the prop type
1317             if isinstance(prop, Link):
1318                 link_class = prop.classname
1319                 # if it isn't a number, it's a key
1320                 if value is not None and not isinstance(value, type('')):
1321                     raise ValueError, 'property "%s" link value be a string'%(
1322                         propname)
1323                 if isinstance(value, type('')) and not num_re.match(value):
1324                     try:
1325                         value = self.db.classes[link_class].lookup(value)
1326                     except (TypeError, KeyError):
1327                         raise IndexError, 'new property "%s": %s not a %s'%(
1328                             propname, value, prop.classname)
1329
1330                 if (value is not None and
1331                         not self.db.getclass(link_class).hasnode(value)):
1332                     raise IndexError, '%s has no node %s'%(link_class, value)
1333
1334                 if self.do_journal and prop.do_journal:
1335                     # register the unlink with the old linked node
1336                     if node[propname] is not None:
1337                         self.db.addjournal(link_class, node[propname], 'unlink',
1338                             (self.classname, nodeid, propname))
1339
1340                     # register the link with the newly linked node
1341                     if value is not None:
1342                         self.db.addjournal(link_class, value, 'link',
1343                             (self.classname, nodeid, propname))
1344
1345             elif isinstance(prop, Multilink):
1346                 if type(value) != type([]):
1347                     raise TypeError, 'new property "%s" not a list of'\
1348                         ' ids'%propname
1349                 link_class = self.properties[propname].classname
1350                 l = []
1351                 for entry in value:
1352                     # if it isn't a number, it's a key
1353                     if type(entry) != type(''):
1354                         raise ValueError, 'new property "%s" link value ' \
1355                             'must be a string'%propname
1356                     if not num_re.match(entry):
1357                         try:
1358                             entry = self.db.classes[link_class].lookup(entry)
1359                         except (TypeError, KeyError):
1360                             raise IndexError, 'new property "%s": %s not a %s'%(
1361                                 propname, entry,
1362                                 self.properties[propname].classname)
1363                     l.append(entry)
1364                 value = l
1365                 propvalues[propname] = value
1366
1367                 # figure the journal entry for this property
1368                 add = []
1369                 remove = []
1370
1371                 # handle removals
1372                 if node.has_key(propname):
1373                     l = node[propname]
1374                 else:
1375                     l = []
1376                 for id in l[:]:
1377                     if id in value:
1378                         continue
1379                     # register the unlink with the old linked node
1380                     if self.do_journal and self.properties[propname].do_journal:
1381                         self.db.addjournal(link_class, id, 'unlink',
1382                             (self.classname, nodeid, propname))
1383                     l.remove(id)
1384                     remove.append(id)
1385
1386                 # handle additions
1387                 for id in value:
1388                     if not self.db.getclass(link_class).hasnode(id):
1389                         raise IndexError, '%s has no node %s'%(link_class, id)
1390                     if id in l:
1391                         continue
1392                     # register the link with the newly linked node
1393                     if self.do_journal and self.properties[propname].do_journal:
1394                         self.db.addjournal(link_class, id, 'link',
1395                             (self.classname, nodeid, propname))
1396                     l.append(id)
1397                     add.append(id)
1398
1399                 # figure the journal entry
1400                 l = []
1401                 if add:
1402                     l.append(('+', add))
1403                 if remove:
1404                     l.append(('-', remove))
1405                 multilink_changes[propname] = (add, remove)
1406                 if l:
1407                     journalvalues[propname] = tuple(l)
1408
1409             elif isinstance(prop, String):
1410                 if value is not None and type(value) != type('') and type(value) != type(u''):
1411                     raise TypeError, 'new property "%s" not a string'%propname
1412
1413             elif isinstance(prop, Password):
1414                 if not isinstance(value, password.Password):
1415                     raise TypeError, 'new property "%s" not a Password'%propname
1416                 propvalues[propname] = value
1417
1418             elif value is not None and isinstance(prop, Date):
1419                 if not isinstance(value, date.Date):
1420                     raise TypeError, 'new property "%s" not a Date'% propname
1421                 propvalues[propname] = value
1422
1423             elif value is not None and isinstance(prop, Interval):
1424                 if not isinstance(value, date.Interval):
1425                     raise TypeError, 'new property "%s" not an '\
1426                         'Interval'%propname
1427                 propvalues[propname] = value
1428
1429             elif value is not None and isinstance(prop, Number):
1430                 try:
1431                     float(value)
1432                 except ValueError:
1433                     raise TypeError, 'new property "%s" not numeric'%propname
1434
1435             elif value is not None and isinstance(prop, Boolean):
1436                 try:
1437                     int(value)
1438                 except ValueError:
1439                     raise TypeError, 'new property "%s" not boolean'%propname
1440
1441         # nothing to do?
1442         if not propvalues:
1443             return propvalues
1444
1445         # do the set, and journal it
1446         self.db.setnode(self.classname, nodeid, propvalues, multilink_changes)
1447
1448         if self.do_journal:
1449             self.db.addjournal(self.classname, nodeid, 'set', journalvalues)
1450
1451         self.fireReactors('set', nodeid, oldvalues)
1452
1453         return propvalues
1454
1455     def retire(self, nodeid):
1456         '''Retire a node.
1457
1458         The properties on the node remain available from the get() method,
1459         and the node's id is never reused.
1460
1461         Retired nodes are not returned by the find(), list(), or lookup()
1462         methods, and other nodes may reuse the values of their key properties.
1463         '''
1464         if self.db.journaltag is None:
1465             raise DatabaseError, 'Database open read-only'
1466
1467         self.fireAuditors('retire', nodeid, None)
1468
1469         # use the arg for __retired__ to cope with any odd database type
1470         # conversion (hello, sqlite)
1471         sql = 'update _%s set __retired__=%s where id=%s'%(self.classname,
1472             self.db.arg, self.db.arg)
1473         if __debug__:
1474             print >>hyperdb.DEBUG, 'retire', (self, sql, nodeid)
1475         self.db.cursor.execute(sql, (1, nodeid))
1476         if self.do_journal:
1477             self.db.addjournal(self.classname, nodeid, 'retired', None)
1478
1479         self.fireReactors('retire', nodeid, None)
1480
1481     def restore(self, nodeid):
1482         '''Restpre a retired node.
1483
1484         Make node available for all operations like it was before retirement.
1485         '''
1486         if self.db.journaltag is None:
1487             raise DatabaseError, 'Database open read-only'
1488
1489         self.fireAuditors('restore', nodeid, None)
1490
1491         # use the arg for __retired__ to cope with any odd database type
1492         # conversion (hello, sqlite)
1493         sql = 'update _%s set __retired__=%s where id=%s'%(self.classname,
1494             self.db.arg, self.db.arg)
1495         if __debug__:
1496             print >>hyperdb.DEBUG, 'restore', (self, sql, nodeid)
1497         self.db.cursor.execute(sql, (0, nodeid))
1498         if self.do_journal:
1499             self.db.addjournal(self.classname, nodeid, 'restored', None)
1500
1501         self.fireReactors('restore', nodeid, None)
1502
1503     def is_retired(self, nodeid):
1504         '''Return true if the node is rerired
1505         '''
1506         sql = 'select __retired__ from _%s where id=%s'%(self.classname,
1507             self.db.arg)
1508         if __debug__:
1509             print >>hyperdb.DEBUG, 'is_retired', (self, sql, nodeid)
1510         self.db.cursor.execute(sql, (nodeid,))
1511         return int(self.db.sql_fetchone()[0])
1512
1513     def destroy(self, nodeid):
1514         '''Destroy a node.
1515
1516         WARNING: this method should never be used except in extremely rare
1517                  situations where there could never be links to the node being
1518                  deleted
1519         WARNING: use retire() instead
1520         WARNING: the properties of this node will not be available ever again
1521         WARNING: really, use retire() instead
1522
1523         Well, I think that's enough warnings. This method exists mostly to
1524         support the session storage of the cgi interface.
1525
1526         The node is completely removed from the hyperdb, including all journal
1527         entries. It will no longer be available, and will generally break code
1528         if there are any references to the node.
1529         '''
1530         if self.db.journaltag is None:
1531             raise DatabaseError, 'Database open read-only'
1532         self.db.destroynode(self.classname, nodeid)
1533
1534     def history(self, nodeid):
1535         '''Retrieve the journal of edits on a particular node.
1536
1537         'nodeid' must be the id of an existing node of this class or an
1538         IndexError is raised.
1539
1540         The returned list contains tuples of the form
1541
1542             (nodeid, date, tag, action, params)
1543
1544         'date' is a Timestamp object specifying the time of the change and
1545         'tag' is the journaltag specified when the database was opened.
1546         '''
1547         if not self.do_journal:
1548             raise ValueError, 'Journalling is disabled for this class'
1549         return self.db.getjournal(self.classname, nodeid)
1550
1551     # Locating nodes:
1552     def hasnode(self, nodeid):
1553         '''Determine if the given nodeid actually exists
1554         '''
1555         return self.db.hasnode(self.classname, nodeid)
1556
1557     def setkey(self, propname):
1558         '''Select a String property of this class to be the key property.
1559
1560         'propname' must be the name of a String property of this class or
1561         None, or a TypeError is raised.  The values of the key property on
1562         all existing nodes must be unique or a ValueError is raised.
1563         '''
1564         # XXX create an index on the key prop column
1565         prop = self.getprops()[propname]
1566         if not isinstance(prop, String):
1567             raise TypeError, 'key properties must be String'
1568         self.key = propname
1569
1570     def getkey(self):
1571         '''Return the name of the key property for this class or None.'''
1572         return self.key
1573
1574     def labelprop(self, default_to_id=0):
1575         ''' Return the property name for a label for the given node.
1576
1577         This method attempts to generate a consistent label for the node.
1578         It tries the following in order:
1579             1. key property
1580             2. "name" property
1581             3. "title" property
1582             4. first property from the sorted property name list
1583         '''
1584         k = self.getkey()
1585         if  k:
1586             return k
1587         props = self.getprops()
1588         if props.has_key('name'):
1589             return 'name'
1590         elif props.has_key('title'):
1591             return 'title'
1592         if default_to_id:
1593             return 'id'
1594         props = props.keys()
1595         props.sort()
1596         return props[0]
1597
1598     def lookup(self, keyvalue):
1599         '''Locate a particular node by its key property and return its id.
1600
1601         If this class has no key property, a TypeError is raised.  If the
1602         'keyvalue' matches one of the values for the key property among
1603         the nodes in this class, the matching node's id is returned;
1604         otherwise a KeyError is raised.
1605         '''
1606         if not self.key:
1607             raise TypeError, 'No key property set for class %s'%self.classname
1608
1609         # use the arg to handle any odd database type conversion (hello,
1610         # sqlite)
1611         sql = "select id from _%s where _%s=%s and __retired__ <> %s"%(
1612             self.classname, self.key, self.db.arg, self.db.arg)
1613         self.db.sql(sql, (keyvalue, 1))
1614
1615         # see if there was a result that's not retired
1616         row = self.db.sql_fetchone()
1617         if not row:
1618             raise KeyError, 'No key (%s) value "%s" for "%s"'%(self.key,
1619                 keyvalue, self.classname)
1620
1621         # return the id
1622         return row[0]
1623
1624     def find(self, **propspec):
1625         '''Get the ids of nodes in this class which link to the given nodes.
1626
1627         'propspec' consists of keyword args propname=nodeid or
1628                    propname={nodeid:1, }
1629         'propname' must be the name of a property in this class, or a
1630         KeyError is raised.  That property must be a Link or Multilink
1631         property, or a TypeError is raised.
1632
1633         Any node in this class whose 'propname' property links to any of the
1634         nodeids will be returned. Used by the full text indexing, which knows
1635         that "foo" occurs in msg1, msg3 and file7, so we have hits on these
1636         issues:
1637
1638             db.issue.find(messages={'1':1,'3':1}, files={'7':1})
1639         '''
1640         if __debug__:
1641             print >>hyperdb.DEBUG, 'find', (self, propspec)
1642
1643         # shortcut
1644         if not propspec:
1645             return []
1646
1647         # validate the args
1648         props = self.getprops()
1649         propspec = propspec.items()
1650         for propname, nodeids in propspec:
1651             # check the prop is OK
1652             prop = props[propname]
1653             if not isinstance(prop, Link) and not isinstance(prop, Multilink):
1654                 raise TypeError, "'%s' not a Link/Multilink property"%propname
1655
1656         # first, links
1657         where = []
1658         allvalues = ()
1659         a = self.db.arg
1660         for prop, values in propspec:
1661             if not isinstance(props[prop], hyperdb.Link):
1662                 continue
1663             if type(values) is type(''):
1664                 allvalues += (values,)
1665                 where.append('_%s = %s'%(prop, a))
1666             else:
1667                 allvalues += tuple(values.keys())
1668                 where.append('_%s in (%s)'%(prop, ','.join([a]*len(values))))
1669         tables = []
1670         if where:
1671             tables.append('select id as nodeid from _%s where %s'%(
1672                 self.classname, ' and '.join(where)))
1673
1674         # now multilinks
1675         for prop, values in propspec:
1676             if not isinstance(props[prop], hyperdb.Multilink):
1677                 continue
1678             if type(values) is type(''):
1679                 allvalues += (values,)
1680                 s = a
1681             else:
1682                 allvalues += tuple(values.keys())
1683                 s = ','.join([a]*len(values))
1684             tables.append('select nodeid from %s_%s where linkid in (%s)'%(
1685                 self.classname, prop, s))
1686         sql = '\nunion\n'.join(tables)
1687         self.db.sql(sql, allvalues)
1688         l = [x[0] for x in self.db.sql_fetchall()]
1689         if __debug__:
1690             print >>hyperdb.DEBUG, 'find ... ', l
1691         return l
1692
1693     def stringFind(self, **requirements):
1694         '''Locate a particular node by matching a set of its String
1695         properties in a caseless search.
1696
1697         If the property is not a String property, a TypeError is raised.
1698
1699         The return is a list of the id of all nodes that match.
1700         '''
1701         where = []
1702         args = []
1703         for propname in requirements.keys():
1704             prop = self.properties[propname]
1705             if isinstance(not prop, String):
1706                 raise TypeError, "'%s' not a String property"%propname
1707             where.append(propname)
1708             args.append(requirements[propname].lower())
1709
1710         # generate the where clause
1711         s = ' and '.join(['_%s=%s'%(col, self.db.arg) for col in where])
1712         sql = 'select id from _%s where %s'%(self.classname, s)
1713         self.db.sql(sql, tuple(args))
1714         l = [x[0] for x in self.db.sql_fetchall()]
1715         if __debug__:
1716             print >>hyperdb.DEBUG, 'find ... ', l
1717         return l
1718
1719     def list(self):
1720         ''' Return a list of the ids of the active nodes in this class.
1721         '''
1722         return self.getnodeids(retired=0)
1723
1724     def getnodeids(self, retired=None):
1725         ''' Retrieve all the ids of the nodes for a particular Class.
1726
1727             Set retired=None to get all nodes. Otherwise it'll get all the
1728             retired or non-retired nodes, depending on the flag.
1729         '''
1730         # flip the sense of the flag if we don't want all of them
1731         if retired is not None:
1732             retired = not retired
1733         sql = 'select id from _%s where __retired__ <> %s'%(self.classname,
1734             self.db.arg)
1735         if __debug__:
1736             print >>hyperdb.DEBUG, 'getnodeids', (self, sql, retired)
1737         self.db.cursor.execute(sql, (retired,))
1738         return [x[0] for x in self.db.cursor.fetchall()]
1739
1740     def filter(self, search_matches, filterspec, sort=(None,None),
1741             group=(None,None)):
1742         ''' Return a list of the ids of the active nodes in this class that
1743             match the 'filter' spec, sorted by the group spec and then the
1744             sort spec
1745
1746             "filterspec" is {propname: value(s)}
1747             "sort" and "group" are (dir, prop) where dir is '+', '-' or None
1748                                and prop is a prop name or None
1749             "search_matches" is {nodeid: marker}
1750
1751             The filter must match all properties specificed - but if the
1752             property value to match is a list, any one of the values in the
1753             list may match for that property to match.
1754         '''
1755         # just don't bother if the full-text search matched diddly
1756         if search_matches == {}:
1757             return []
1758
1759         cn = self.classname
1760
1761         timezone = self.db.getUserTimezone()
1762
1763         # figure the WHERE clause from the filterspec
1764         props = self.getprops()
1765         frum = ['_'+cn]
1766         where = []
1767         args = []
1768         a = self.db.arg
1769         for k, v in filterspec.items():
1770             propclass = props[k]
1771             # now do other where clause stuff
1772             if isinstance(propclass, Multilink):
1773                 tn = '%s_%s'%(cn, k)
1774                 frum.append(tn)
1775                 if isinstance(v, type([])):
1776                     s = ','.join([a for x in v])
1777                     where.append('id=%s.nodeid and %s.linkid in (%s)'%(tn,tn,s))
1778                     args = args + v
1779                 else:
1780                     where.append('id=%s.nodeid and %s.linkid = %s'%(tn, tn, a))
1781                     args.append(v)
1782             elif k == 'id':
1783                 if isinstance(v, type([])):
1784                     s = ','.join([a for x in v])
1785                     where.append('%s in (%s)'%(k, s))
1786                     args = args + v
1787                 else:
1788                     where.append('%s=%s'%(k, a))
1789                     args.append(v)
1790             elif isinstance(propclass, String):
1791                 if not isinstance(v, type([])):
1792                     v = [v]
1793
1794                 # Quote the bits in the string that need it and then embed
1795                 # in a "substring" search. Note - need to quote the '%' so
1796                 # they make it through the python layer happily
1797                 v = ['%%'+self.db.sql_stringquote(s)+'%%' for s in v]
1798
1799                 # now add to the where clause
1800                 where.append(' or '.join(["_%s LIKE '%s'"%(k, s) for s in v]))
1801                 # note: args are embedded in the query string now
1802             elif isinstance(propclass, Link):
1803                 if isinstance(v, type([])):
1804                     if '-1' in v:
1805                         v.remove('-1')
1806                         xtra = ' or _%s is NULL'%k
1807                     else:
1808                         xtra = ''
1809                     if v:
1810                         s = ','.join([a for x in v])
1811                         where.append('(_%s in (%s)%s)'%(k, s, xtra))
1812                         args = args + v
1813                     else:
1814                         where.append('_%s is NULL'%k)
1815                 else:
1816                     if v == '-1':
1817                         v = None
1818                         where.append('_%s is NULL'%k)
1819                     else:
1820                         where.append('_%s=%s'%(k, a))
1821                         args.append(v)
1822             elif isinstance(propclass, Date):
1823                 if isinstance(v, type([])):
1824                     s = ','.join([a for x in v])
1825                     where.append('_%s in (%s)'%(k, s))
1826                     args = args + [date.Date(x).serialise() for x in v]
1827                 else:
1828                     try:
1829                         # Try to filter on range of dates
1830                         date_rng = Range(v, date.Date, offset=timezone)
1831                         if (date_rng.from_value):
1832                             where.append('_%s > %s'%(k, a))
1833                             args.append(date_rng.from_value.serialise())
1834                         if (date_rng.to_value):
1835                             where.append('_%s < %s'%(k, a))
1836                             args.append(date_rng.to_value.serialise())
1837                     except ValueError:
1838                         # If range creation fails - ignore that search parameter
1839                         pass
1840             elif isinstance(propclass, Interval):
1841                 if isinstance(v, type([])):
1842                     s = ','.join([a for x in v])
1843                     where.append('_%s in (%s)'%(k, s))
1844                     args = args + [date.Interval(x).serialise() for x in v]
1845                 else:
1846                     where.append('_%s=%s'%(k, a))
1847                     args.append(date.Interval(v).serialise())
1848             else:
1849                 if isinstance(v, type([])):
1850                     s = ','.join([a for x in v])
1851                     where.append('_%s in (%s)'%(k, s))
1852                     args = args + v
1853                 else:
1854                     where.append('_%s=%s'%(k, a))
1855                     args.append(v)
1856
1857         # add results of full text search
1858         if search_matches is not None:
1859             v = search_matches.keys()
1860             s = ','.join([a for x in v])
1861             where.append('id in (%s)'%s)
1862             args = args + v
1863
1864         # "grouping" is just the first-order sorting in the SQL fetch
1865         # can modify it...)
1866         orderby = []
1867         ordercols = []
1868         if group[0] is not None and group[1] is not None:
1869             if group[0] != '-':
1870                 orderby.append('_'+group[1])
1871                 ordercols.append('_'+group[1])
1872             else:
1873                 orderby.append('_'+group[1]+' desc')
1874                 ordercols.append('_'+group[1])
1875
1876         # now add in the sorting
1877         group = ''
1878         if sort[0] is not None and sort[1] is not None:
1879             direction, colname = sort
1880             if direction != '-':
1881                 if colname == 'id':
1882                     orderby.append(colname)
1883                 else:
1884                     orderby.append('_'+colname)
1885                     ordercols.append('_'+colname)
1886             else:
1887                 if colname == 'id':
1888                     orderby.append(colname+' desc')
1889                     ordercols.append(colname)
1890                 else:
1891                     orderby.append('_'+colname+' desc')
1892                     ordercols.append('_'+colname)
1893
1894         # construct the SQL
1895         frum = ','.join(frum)
1896         if where:
1897             where = ' where ' + (' and '.join(where))
1898         else:
1899             where = ''
1900         cols = ['id']
1901         if orderby:
1902             cols = cols + ordercols
1903             order = ' order by %s'%(','.join(orderby))
1904         else:
1905             order = ''
1906         cols = ','.join(cols)
1907         sql = 'select %s from %s %s%s%s'%(cols, frum, where, group, order)
1908         args = tuple(args)
1909         if __debug__:
1910             print >>hyperdb.DEBUG, 'filter', (self, sql, args)
1911         self.db.cursor.execute(sql, args)
1912         l = self.db.cursor.fetchall()
1913
1914         # return the IDs (the first column)
1915         # XXX The filter(None, l) bit is sqlite-specific... if there's _NO_
1916         # XXX matches to a fetch, it returns NULL instead of nothing!?!
1917         return filter(None, [row[0] for row in l])
1918
1919     def count(self):
1920         '''Get the number of nodes in this class.
1921
1922         If the returned integer is 'numnodes', the ids of all the nodes
1923         in this class run from 1 to numnodes, and numnodes+1 will be the
1924         id of the next node to be created in this class.
1925         '''
1926         return self.db.countnodes(self.classname)
1927
1928     # Manipulating properties:
1929     def getprops(self, protected=1):
1930         '''Return a dictionary mapping property names to property objects.
1931            If the "protected" flag is true, we include protected properties -
1932            those which may not be modified.
1933         '''
1934         d = self.properties.copy()
1935         if protected:
1936             d['id'] = String()
1937             d['creation'] = hyperdb.Date()
1938             d['activity'] = hyperdb.Date()
1939             d['creator'] = hyperdb.Link('user')
1940         return d
1941
1942     def addprop(self, **properties):
1943         '''Add properties to this class.
1944
1945         The keyword arguments in 'properties' must map names to property
1946         objects, or a TypeError is raised.  None of the keys in 'properties'
1947         may collide with the names of existing properties, or a ValueError
1948         is raised before any properties have been added.
1949         '''
1950         for key in properties.keys():
1951             if self.properties.has_key(key):
1952                 raise ValueError, key
1953         self.properties.update(properties)
1954
1955     def index(self, nodeid):
1956         '''Add (or refresh) the node to search indexes
1957         '''
1958         # find all the String properties that have indexme
1959         for prop, propclass in self.getprops().items():
1960             if isinstance(propclass, String) and propclass.indexme:
1961                 try:
1962                     value = str(self.get(nodeid, prop))
1963                 except IndexError:
1964                     # node no longer exists - entry should be removed
1965                     self.db.indexer.purge_entry((self.classname, nodeid, prop))
1966                 else:
1967                     # and index them under (classname, nodeid, property)
1968                     self.db.indexer.add_text((self.classname, nodeid, prop),
1969                         value)
1970
1971
1972     #
1973     # Detector interface
1974     #
1975     def audit(self, event, detector):
1976         '''Register a detector
1977         '''
1978         l = self.auditors[event]
1979         if detector not in l:
1980             self.auditors[event].append(detector)
1981
1982     def fireAuditors(self, action, nodeid, newvalues):
1983         '''Fire all registered auditors.
1984         '''
1985         for audit in self.auditors[action]:
1986             audit(self.db, self, nodeid, newvalues)
1987
1988     def react(self, event, detector):
1989         '''Register a detector
1990         '''
1991         l = self.reactors[event]
1992         if detector not in l:
1993             self.reactors[event].append(detector)
1994
1995     def fireReactors(self, action, nodeid, oldvalues):
1996         '''Fire all registered reactors.
1997         '''
1998         for react in self.reactors[action]:
1999             react(self.db, self, nodeid, oldvalues)
2000
2001 class FileClass(Class, hyperdb.FileClass):
2002     '''This class defines a large chunk of data. To support this, it has a
2003        mandatory String property "content" which is typically saved off
2004        externally to the hyperdb.
2005
2006        The default MIME type of this data is defined by the
2007        "default_mime_type" class attribute, which may be overridden by each
2008        node if the class defines a "type" String property.
2009     '''
2010     default_mime_type = 'text/plain'
2011
2012     def create(self, **propvalues):
2013         ''' snaffle the file propvalue and store in a file
2014         '''
2015         # we need to fire the auditors now, or the content property won't
2016         # be in propvalues for the auditors to play with
2017         self.fireAuditors('create', None, propvalues)
2018
2019         # now remove the content property so it's not stored in the db
2020         content = propvalues['content']
2021         del propvalues['content']
2022
2023         # do the database create
2024         newid = Class.create_inner(self, **propvalues)
2025
2026         # fire reactors
2027         self.fireReactors('create', newid, None)
2028
2029         # store off the content as a file
2030         self.db.storefile(self.classname, newid, None, content)
2031         return newid
2032
2033     def import_list(self, propnames, proplist):
2034         ''' Trap the "content" property...
2035         '''
2036         # dupe this list so we don't affect others
2037         propnames = propnames[:]
2038
2039         # extract the "content" property from the proplist
2040         i = propnames.index('content')
2041         content = eval(proplist[i])
2042         del propnames[i]
2043         del proplist[i]
2044
2045         # do the normal import
2046         newid = Class.import_list(self, propnames, proplist)
2047
2048         # save off the "content" file
2049         self.db.storefile(self.classname, newid, None, content)
2050         return newid
2051
2052     _marker = []
2053     def get(self, nodeid, propname, default=_marker, cache=1):
2054         ''' trap the content propname and get it from the file
2055         '''
2056         poss_msg = 'Possibly a access right configuration problem.'
2057         if propname == 'content':
2058             try:
2059                 return self.db.getfile(self.classname, nodeid, None)
2060             except IOError, (strerror):
2061                 # BUG: by catching this we donot see an error in the log.
2062                 return 'ERROR reading file: %s%s\n%s\n%s'%(
2063                         self.classname, nodeid, poss_msg, strerror)
2064         if default is not self._marker:
2065             return Class.get(self, nodeid, propname, default, cache=cache)
2066         else:
2067             return Class.get(self, nodeid, propname, cache=cache)
2068
2069     def getprops(self, protected=1):
2070         ''' In addition to the actual properties on the node, these methods
2071             provide the "content" property. If the "protected" flag is true,
2072             we include protected properties - those which may not be
2073             modified.
2074         '''
2075         d = Class.getprops(self, protected=protected).copy()
2076         d['content'] = hyperdb.String()
2077         return d
2078
2079     def index(self, nodeid):
2080         ''' Index the node in the search index.
2081
2082             We want to index the content in addition to the normal String
2083             property indexing.
2084         '''
2085         # perform normal indexing
2086         Class.index(self, nodeid)
2087
2088         # get the content to index
2089         content = self.get(nodeid, 'content')
2090
2091         # figure the mime type
2092         if self.properties.has_key('type'):
2093             mime_type = self.get(nodeid, 'type')
2094         else:
2095             mime_type = self.default_mime_type
2096
2097         # and index!
2098         self.db.indexer.add_text((self.classname, nodeid, 'content'), content,
2099             mime_type)
2100
2101 # XXX deviation from spec - was called ItemClass
2102 class IssueClass(Class, roundupdb.IssueClass):
2103     # Overridden methods:
2104     def __init__(self, db, classname, **properties):
2105         '''The newly-created class automatically includes the "messages",
2106         "files", "nosy", and "superseder" properties.  If the 'properties'
2107         dictionary attempts to specify any of these properties or a
2108         "creation" or "activity" property, a ValueError is raised.
2109         '''
2110         if not properties.has_key('title'):
2111             properties['title'] = hyperdb.String(indexme='yes')
2112         if not properties.has_key('messages'):
2113             properties['messages'] = hyperdb.Multilink("msg")
2114         if not properties.has_key('files'):
2115             properties['files'] = hyperdb.Multilink("file")
2116         if not properties.has_key('nosy'):
2117             # note: journalling is turned off as it really just wastes
2118             # space. this behaviour may be overridden in an instance
2119             properties['nosy'] = hyperdb.Multilink("user", do_journal="no")
2120         if not properties.has_key('superseder'):
2121             properties['superseder'] = hyperdb.Multilink(classname)
2122         Class.__init__(self, db, classname, **properties)
2123