index 965245f4be22e1e6d91a2d5360d9166b27ee88e4..69d258523dbd1e335b435b710c0775b18bce85b2 100644 (file)
-# $Id: back_sqlite.py,v 1.3 2002-09-19 02:37:41 richard Exp $
+# $Id: back_sqlite.py,v 1.8 2002-12-12 09:31:04 richard Exp $
__doc__ = '''
See https://pysqlite.sourceforge.net/ for pysqlite info
'''
import base64, marshal
from roundup.backends.rdbms_common import *
__doc__ = '''
See https://pysqlite.sourceforge.net/ for pysqlite info
'''
import base64, marshal
from roundup.backends.rdbms_common import *
+from roundup.backends import locking
import sqlite
class Database(Database):
import sqlite
class Database(Database):
# ensure files are group readable and writable
os.umask(0002)
db = os.path.join(self.config.DATABASE, 'db')
# ensure files are group readable and writable
os.umask(0002)
db = os.path.join(self.config.DATABASE, 'db')
+
+ # lock it
+ lockfilenm = db[:-3] + 'lck'
+ self.lockfile = locking.acquire_lock(lockfilenm)
+ self.lockfile.write(str(os.getpid()))
+ self.lockfile.flush()
+
self.conn = sqlite.connect(db=db)
self.conn = sqlite.connect(db=db)
- cursor = self.conn.cursor()
+ self.cursor = self.conn.cursor()
try:
try:
- self.database_schema = self.load_dbschema(cursor)
+ self.database_schema = self.load_dbschema()
except sqlite.DatabaseError, error:
if str(error) != 'no such table: schema':
raise
self.database_schema = {}
except sqlite.DatabaseError, error:
if str(error) != 'no such table: schema':
raise
self.database_schema = {}
- cursor = self.conn.cursor()
- cursor.execute('create table schema (schema varchar)')
- cursor.execute('create table ids (name varchar, num integer)')
+ self.cursor.execute('create table schema (schema varchar)')
+ self.cursor.execute('create table ids (name varchar, num integer)')
+
+ def close(self):
+ ''' Close off the connection.
+
+ Squash any error caused by us already having closed the
+ connection.
+ '''
+ try:
+ self.conn.close()
+ except sqlite.ProgrammingError, value:
+ if str(value) != 'close failed - Connection is closed.':
+ raise
+
+ # release the lock too
+ if self.lockfile is not None:
+ locking.release_lock(self.lockfile)
+ if self.lockfile is not None:
+ self.lockfile.close()
+ self.lockfile = None
+
+ def rollback(self):
+ ''' Reverse all actions from the current transaction.
+
+ Undo all the changes made since the database was opened or the
+ last commit() or rollback() was performed.
+
+ Squash any error caused by us having closed the connection (and
+ therefore not having anything to roll back)
+ '''
+ if __debug__:
+ print >>hyperdb.DEBUG, 'rollback', (self,)
+
+ # roll back
+ try:
+ self.conn.rollback()
+ except sqlite.ProgrammingError, value:
+ if str(value) != 'rollback failed - Connection is closed.':
+ raise
+
+ # roll back "other" transaction stuff
+ for method, args in self.transactions:
+ # delete temporary files
+ if method == self.doStoreFile:
+ self.rollbackStoreFile(*args)
+ self.transactions = []
def __repr__(self):
return '<roundlite 0x%x>'%id(self)
def __repr__(self):
return '<roundlite 0x%x>'%id(self)
- def sql_fetchone(self, cursor):
+ def sql_fetchone(self):
''' Fetch a single row. If there's nothing to fetch, return None.
'''
''' Fetch a single row. If there's nothing to fetch, return None.
'''
- return cursor.fetchone()
+ return self.cursor.fetchone()
+
+ def sql_fetchall(self):
+ ''' Fetch a single row. If there's nothing to fetch, return [].
+ '''
+ return self.cursor.fetchall()
def sql_commit(self):
''' Actually commit to the database.
def sql_commit(self):
''' Actually commit to the database.
if str(error) != 'cannot commit - no transaction is active':
raise
if str(error) != 'cannot commit - no transaction is active':
raise
- def save_dbschema(self, cursor, schema):
+ def save_dbschema(self, schema):
''' Save the schema definition that the database currently implements
'''
s = repr(self.database_schema)
''' Save the schema definition that the database currently implements
'''
s = repr(self.database_schema)
- self.sql(cursor, 'insert into schema values (%s)', (s,))
+ self.sql('insert into schema values (%s)', (s,))
- def load_dbschema(self, cursor):
+ def load_dbschema(self):
''' Load the schema definition that the database currently implements
'''
''' Load the schema definition that the database currently implements
'''
- cursor.execute('select schema from schema')
- return eval(cursor.fetchone()[0])
+ self.cursor.execute('select schema from schema')
+ return eval(self.cursor.fetchone()[0])
- def save_journal(self, cursor, classname, cols, nodeid, journaldate,
+ def save_journal(self, classname, cols, nodeid, journaldate,
journaltag, action, params):
''' Save the journal entry to the database
'''
journaltag, action, params):
''' Save the journal entry to the database
'''
cols, a, a, a, a, a)
if __debug__:
print >>hyperdb.DEBUG, 'addjournal', (self, sql, entry)
cols, a, a, a, a, a)
if __debug__:
print >>hyperdb.DEBUG, 'addjournal', (self, sql, entry)
- cursor.execute(sql, entry)
+ self.cursor.execute(sql, entry)
- def load_journal(self, cursor, classname, cols, nodeid):
+ def load_journal(self, classname, cols, nodeid):
''' Load the journal from the database
'''
# now get the journal entries
''' Load the journal from the database
'''
# now get the journal entries
self.arg)
if __debug__:
print >>hyperdb.DEBUG, 'getjournal', (self, sql, nodeid)
self.arg)
if __debug__:
print >>hyperdb.DEBUG, 'getjournal', (self, sql, nodeid)
- cursor.execute(sql, (nodeid,))
+ self.cursor.execute(sql, (nodeid,))
res = []
res = []
- for nodeid, date_stamp, user, action, params in cursor.fetchall():
+ for nodeid, date_stamp, user, action, params in self.cursor.fetchall():
params = eval(params)
res.append((nodeid, date.Date(date_stamp), user, action, params))
return res
params = eval(params)
res.append((nodeid, date.Date(date_stamp), user, action, params))
return res
d[k] = date.Date(v)
elif isinstance(prop, Interval) and v is not None:
d[k] = date.Interval(v)
d[k] = date.Date(v)
elif isinstance(prop, Interval) and v is not None:
d[k] = date.Interval(v)
- elif isinstance(prop, Password):
+ elif isinstance(prop, Password) and v is not None:
p = password.Password()
p.unpack(v)
d[k] = p
p = password.Password()
p.unpack(v)
d[k] = p