From 6c80e37ab0248d1e27868e25610a49ca07119017 Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Fri, 5 Oct 2007 15:54:21 +0000 Subject: Clean up some of the gctx mess svn path=/scripts/rpki/left_right.py; revision=1099 --- scripts/rpki/sql.py | 64 ++++++++++++++++++++++++++--------------------------- 1 file changed, 32 insertions(+), 32 deletions(-) (limited to 'scripts/rpki/sql.py') diff --git a/scripts/rpki/sql.py b/scripts/rpki/sql.py index b9eb2f7d..186df9af 100644 --- a/scripts/rpki/sql.py +++ b/scripts/rpki/sql.py @@ -46,10 +46,10 @@ def sql_sweep(db, cur): for s in sql_dirty: s.sql_store(db, cur) -def fetch_column(cur, *query): +def fetch_column(gctx, *query): """Pull a single column from SQL, return it as a list.""" - cur.execute(*query) - return [x[0] for x in cur.fetchall()] + gctx.cur.execute(*query) + return [x[0] for x in gctx.cur.fetchall()] class sql_persistant(object): """Mixin for persistant class that needs to be stored in SQL. @@ -60,8 +60,8 @@ class sql_persistant(object): sql_in_db = False @classmethod - def sql_fetch(cls, db, cur, id): - results = cls.sql_fetch_where(db, cur, "%s = %s" % (cls.sql_template.index, id)) + def sql_fetch(cls, gctx, id): + results = cls.sql_fetch_where(gctx, "%s = %s" % (cls.sql_template.index, id)) assert len(results) <= 1 if len(results) == 0: return None @@ -71,31 +71,31 @@ class sql_persistant(object): raise rpki.exceptions.DBConsistancyError, "Database contained multiple matches for %s.%s" % (cls.__name__, id) @classmethod - def sql_fetch_all(cls, db, cur): - return cls.sql_fetch_where(db, cur, None) + def sql_fetch_all(gctx, cur): + return cls.sql_fetch_where(gctx, None) @classmethod - def sql_fetch_where(cls, db, cur, where): + def sql_fetch_where(cls, gctx, where): if where is None: - cur.execute(cls.sql_template.select) + gctx.cur.execute(cls.sql_template.select) else: - cur.execute(cls.sql_template.select + " WHERE " + where) + gctx.cur.execute(cls.sql_template.select + " WHERE " + where) results = [] - for row in cur.fetchall(): + for row in gctx.cur.fetchall(): key = (cls, row[0]) if key in sql_cache: results.append(sql_cache[key]) else: - results.append(cls.sql_init(db, cur, row, key)) + results.append(cls.sql_init(gctx, row, key)) return results @classmethod - def sql_init(cls, db, cur, row, key): + def sql_init(cls, gctx, row, key): self = cls() self.sql_decode(dict(zip(cls.sql_template.columns, row))) sql_cache[key] = self self.sql_in_db = True - self.sql_fetch_hook(db, cur) + self.sql_fetch_hook(gctx) return self def sql_mark_dirty(self): @@ -107,25 +107,25 @@ class sql_persistant(object): def sql_is_dirty(self): return self in sql_dirty - def sql_store(self, db, cur): + def sql_store(self, gctx): if not self.sql_in_db: - cur.execute(self.sql_template.insert, self.sql_encode()) - setattr(self, self.sql_template.index, cur.lastrowid) - sql_cache[(self.__class__, cur.lastrowid)] = self - self.sql_insert_hook(db, cur) + gctx.cur.execute(self.sql_template.insert, self.sql_encode()) + setattr(self, self.sql_template.index, gctx.cur.lastrowid) + sql_cache[(self.__class__, gctx.cur.lastrowid)] = self + self.sql_insert_hook(gctx) elif self in sql_dirty: - cur.execute(self.sql_template.update, self.sql_encode()) - self.sql_update_hook(db, cur) + gctx.cur.execute(self.sql_template.update, self.sql_encode()) + self.sql_update_hook(gctx) key = (self.__class__, getattr(self, self.sql_template.index)) assert key in sql_cache and sql_cache[key] == self self.sql_mark_clean() self.sql_in_db = True - def sql_delete(self, db, cur): + def sql_delete(self, gctx): if self.sql_in_db: id = getattr(self, self.sql_template.index) - cur.execute(self.sql_template.delete, id) - self.sql_delete_hook(db, cur) + gctx.cur.execute(self.sql_template.delete, id) + self.sql_delete_hook(gctx) key = (self.__class__, id) if sql_cache.get(key) == self: del sql_cache[key] @@ -150,20 +150,20 @@ class sql_persistant(object): for a in self.sql_template.columns: setattr(self, a, vals[a]) - def sql_fetch_hook(self, db, cur): + def sql_fetch_hook(self, gctx): """Customization hook.""" pass - def sql_insert_hook(self, db, cur): + def sql_insert_hook(self, gctx): """Customization hook.""" pass - def sql_update_hook(self, db, cur): + def sql_update_hook(self, gctx): """Customization hook.""" - self.sql_delete_hook(db, cur) - self.sql_insert_hook(db, cur) + self.sql_delete_hook(gctx) + self.sql_insert_hook(gctx) - def sql_delete_hook(self, db, cur): + def sql_delete_hook(self, gctx): """Customization hook.""" pass @@ -205,8 +205,8 @@ class ca_detail_obj(sql_persistant): return d @classmethod - def sql_fetch_active(cls, db, cur, ca_id): - hits = cls.sql_fetch_where(db, cur, "ca_id = %s AND state = 'active'" % ca_id) + def sql_fetch_active(cls, gctx, ca_id): + hits = cls.sql_fetch_where(gctx, "ca_id = %s AND state = 'active'" % ca_id) assert len(hits) < 2, "Found more than one 'active' ca_detail record, this should not happen!" if hits: return hits[0] -- cgit v1.2.3