Mercurial Repository: p/roundup/code: roundup/backends/back

comparison roundup/backends/back_sqlite.py @ 4076:59d02edfaa9c

Uniformly use """...""" instead of '''...''' for comments.

author	Stefan Seefeld <stefan@seefeld.name>
date	Tue, 24 Feb 2009 03:15:57 +0000
parents	bb30bbfc7cdd
children	09e79cbeb827

comparison

equal deleted inserted replaced

-:b87d022a2f40
+:59d02edfaa9c
-# $Id: back_sqlite.py,v 1.51 2007-06-21 07:35:50 schlatterbeck Exp $
+"""Implements a backend for SQLite.
-'''Implements a backend for SQLite.
 See https://pysqlite.sourceforge.net/ for pysqlite info
 NOTE: we use the rdbms_common table creation methods which define datatypes
 for the columns, but sqlite IGNORES these specifications.
-'''
+"""
 __docformat__ = 'restructuredtext'
 import os, base64, marshal, shutil, time, logging
 from roundup import hyperdb, date, password
 time_to_sleep = 0.01 * (2 << min(5, count))
 time.sleep(time_to_sleep)
 return 1
 def sql_open_connection(self):
-'''Open a standard, non-autocommitting connection.
+"""Open a standard, non-autocommitting connection.
 pysqlite will automatically BEGIN TRANSACTION for us.
-'''
+"""
 # make sure the database directory exists
 # database itself will be created by sqlite if needed
 if not os.path.isdir(self.config.DATABASE):
 os.makedirs(self.config.DATABASE)
 def fix_version_3_tables(self):
 # NOOP - no restriction on column length here
 pass
 def update_class(self, spec, old_spec, force=0, adding_v2=0):
-''' Determine the differences between the current spec and the
+""" Determine the differences between the current spec and the
 database version of the spec, and update where necessary.
 If 'force' is true, update the database anyway.
 SQLite doesn't have ALTER TABLE, so we have to copy and
 regenerate the tables with the new schema.
-'''
+"""
 new_has = spec.properties.has_key
 new_spec = spec.schema()
 new_spec[1].sort()
 old_spec[1].sort()
 if not force and new_spec == old_spec:
 sql = 'drop table %s'%tn
 self.sql(sql)
 # re-create and populate the new table
 self.create_multilink_table(spec, propname)
-sql = '''insert into %s (linkid, nodeid) values
+sql = """insert into %s (linkid, nodeid) values
-(%s, %s)'''%(tn, self.arg, self.arg)
+(%s, %s)"""%(tn, self.arg, self.arg)
 for linkid, nodeid in rows:
 self.sql(sql, (int(linkid), int(nodeid)))
 elif old_has(propname):
 # we copy this col over from the old table
 fetch.append('_'+propname)
 self.sql(sql, tuple(d))
 return 1
 def sql_close(self):
-''' Squash any error caused by us already having closed the
+""" 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
 def sql_rollback(self):
-''' Squash any error caused by us having closed the connection (and
+""" Squash any error caused by us having closed the connection (and
 therefore not having anything to roll back)
-'''
+"""
 try:
 self.conn.rollback()
 except sqlite.ProgrammingError, value:
 if str(value) != 'rollback failed - Connection is closed.':
 raise
 def __repr__(self):
 return '<roundlite 0x%x>'%id(self)
 def sql_commit(self, fail_ok=False):
-''' Actually commit to the database.
+""" Actually commit to the database.
 Ignore errors if there's nothing to commit.
-'''
+"""
 try:
 self.conn.commit()
 except sqlite.DatabaseError, error:
 if str(error) != 'cannot commit - no transaction is active':
 raise
 return 1
 return 0
 # old-skool id generation
 def newid(self, classname):
-''' Generate a new id for the given class
+""" Generate a new id for the given class
-'''
+"""
 # get the next ID
 sql = 'select num from ids where name=%s'%self.arg
 self.sql(sql, (classname, ))
 newid = int(self.cursor.fetchone()[0])
 # return as string
 return str(newid)
 def setid(self, classname, setid):
-''' Set the id counter: used during import of database
+""" Set the id counter: used during import of database
 We add one to make it behave like the sequences in postgres.
-'''
+"""
 sql = 'update ids set num=%s where name=%s'%(self.arg, self.arg)
 vals = (int(setid)+1, classname)
 self.sql(sql, vals)
 def clear(self):
 vals = (spec.classname, 1)
 self.sql(sql, vals)
 if sqlite_version in (2,3):
 def load_journal(self, classname, cols, nodeid):
-'''We need to turn the sqlite3.Row into a tuple so it can be
+"""We need to turn the sqlite3.Row into a tuple so it can be
-unpacked'''
+unpacked"""
 l = rdbms_common.Database.load_journal(self,
 classname, cols, nodeid)
 cols = range(5)
 return [[row[col] for col in cols] for row in l]
 class sqliteClass:
 def filter(self, search_matches, filterspec, sort=(None,None),
 group=(None,None)):
-''' If there's NO matches to a fetch, sqlite returns NULL
+""" If there's NO matches to a fetch, sqlite returns NULL
 instead of nothing
-'''
+"""
 return filter(None, rdbms_common.Class.filter(self, search_matches,
 filterspec, sort=sort, group=group))
 class Class(sqliteClass, rdbms_common.Class):
 pass

Mercurial > p > roundup > code

comparison roundup/backends/back_sqlite.py @ 4076:59d02edfaa9c