def addDbSchemaok(self):
dlg = self.dialogs['new-schema']
schema = str(dlg.grid.entries['schema'].text())
self.manager.create_schema(schema)
cursor = StatementCursor(self.db.conn)
cursor.execute('set SESSION search_path to %s' % schema)
self.db.conn.commit()
cursor.execute('show search_path')
print cursor.fetchall()
kschema.create_schema(cursor)
self.refreshlistView()
class Family(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.current = None
self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
self.env = FamilyEnvironment(self.conn)
def set_family(self, family):
self.current = family
self.parent.set_current(family)
self.env.set_family(family)
def _check_family(self, family):
if family is not None:
return family
else:
family = self.current
if family is None:
raise Error, 'either pass a family argument or call set_family on this object'
return family
def get_related_families(self, families=[]):
rows = self.cursor.select(table='family_parent')
graph = kjGraph([(r.family, r.parent) for r in rows])
dfamilies = Set()
for fam in families:
dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
return dfamilies
def parent_rows(self, family=None):
family = self._check_family(family)
self.parent.set_clause(family)
rows = self.parent.cmd.select(fields=['parent'], order='parent')
self.parent.reset_clause()
return rows
def parents(self, family=None):
family = self._check_family(family)
rows = self.parent_rows(family)
return [x.parent for x in rows]
def environment_rows(self, family=None):
family = self._check_family(family)
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
return self.env.cursor.select(**args)
def family_rows(self):
return self.cursor.select(fields=['family'], table='families', order='family')
def all_families(self):
return [r.family for r in self.family_rows()]
def get_all_defaults(self):
suite_cursor = SuiteCursor(self.conn)
suites = suite_cursor.get_suites()
stmt = select_multisuite_union(suites, 'variables')
print stmt
self.cursor.execute(stmt)
return self.cursor.fetchall()
def create_family(self, family):
if family not in self.all_families():
self.cursor.insert(table='families', data=dict(family=family))
else:
raise ExistsError, '%s already exists' % family
def delete_family(self, family=None):
family = self._check_family(family)
self.cursor.execute("select * from delete_family('%s')" % family)
def insert_parents(self, parents, family=None):
family = self._check_family(family)
self.parent.insert('parent', parents)
def delete_parents(self, parents=[], family=None):
family = self._check_family(family)
if not parents:
parents = self.parents()
if not parents:
return
table= 'family_parent'
clause = Eq('family', family) & In('parent', parents)
self.cursor.delete(table=table, clause=clause)
def FamilyData(self, families=[]):
# change sep here
sep = PAELLA_TRAIT_NAME_SEP
# we don't know what to do here
# it is possible to have an empty
# list of families, and if that's the
# case we don't need to make the
# list of [self.current] . I need to look
# for everywhere this method is called.
# In the installer, the family is never set,
# and we use the list of families provided
# by the profile and the machine. In this
# case, the families argument will always
# be a list, empty or not.
# I can't think of any other circumstance
# where this method would be called outside
# of the installer, or a script, and the script
# should be using either a profile or machine
# to get the list of families anyway, make the
# point moot. I will probably remove this part
# of the code in the near future, once I'm sure
# that there's no reason to pass None to the
# families argument.
if families is None:
families = [self.current]
all = self.make_familylist(families)
superdict = {}
for f in all:
superdict.update(self.env.make_tagdict(f, sep=sep))
return superdict
def make_familylist(self, families):
deps = families
all = list(self.get_related_families(families))
setfun = self.set_family
parfun = self.parents
return make_deplist(deps, all, setfun, parfun)
def export_family(self, family=None):
if family is None:
family = self.current
# row isn't used, except to determine that the family exists
row = self.cursor.select_row(table='families', clause=Eq('family', family))
element = FamilyElement(family)
element.append_parents(self.parents(family))
element.append_variables(self.environment_rows(family))
return element
def write_family(self, family, path):
fxml = file(join(path, '%s.xml' % family), 'w')
data = self.export_family(family)
data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
fxml.close()
def export_families(self, path):
families = self.all_families()
self.report_total_families(len(families))
for f in families:
self.write_family(f, path)
self.report_family_exported(f, path)
def import_family(self, element):
parsed = FamilyParser(element)
print 'inserting family', parsed.name
all = self.all_families()
for p in parsed.parents:
if p not in all:
print 'insertion failed for', parsed.name
raise UnbornError
self.create_family(parsed.name)
self.set_family(parsed.name)
self.insert_parents(parsed.parents)
row = dict(family=parsed.name)
for var in parsed.environ:
row.update(var)
self.cursor.insert(table='family_environment', data=row)
def _import_family_xml(self, xmlfile):
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('family')
if len(elements) != 1:
raise Error, 'bad number of family tags %s' % len(elements)
element = elements[0]
return element
def import_family_xml(self, xmlfile):
element = self._import_family_xml(xmlfile)
self.import_family(element)
def import_families(self, path):
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
families = []
for f in xmlfiles:
element = self._import_family_xml(f)
families.append(element)
while len(families):
f = families[0]
try:
self.import_family(f)
except UnbornError:
families.append(f)
del families[0]
print len(families), 'families inserted'
def getVariablesConfig(self, family=None):
family = self._check_family(family)
return FamilyVariablesConfig(self.conn, family)
def deleteVariable(self, trait, name, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
self.env.cursor.delete(clause=clause)
def insertVariable(self, trait, name, value, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
testrows = self.cursor.select(table='family_environment', clause=clause)
if not len(testrows):
data['value'] = value
self.cursor.insert(table='family_environment', data=data)
def report_family_exported(self, family, path):
print 'family %s exported to %s' % (family, path)
def report_total_families(self, total):
print 'exporting %d families' % total
class Family(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
#self.suites = Suites(conn).list()
self.cursor = StatementCursor(self.conn)
self.suites = [r.suite for r in self.cursor.select(table='suites')]
self.current = None
self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
self.env = FamilyEnvironment(self.conn)
def set_family(self, family):
self.current = family
self.parent.set_current(family)
self.env.set_family(family)
def _check_family(self, family):
if family is not None:
return family
else:
family = self.current
if family is None:
raise Error, 'either pass a family arguement or call set_family on this object'
return family
def add_family(self, family, type='general'):
pass
def get_related_families(self, families=[]):
rows = self.cursor.select(table='family_parent')
graph = kjGraph([(r.family, r.parent) for r in rows])
dfamilies = Set()
for fam in families:
dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
return dfamilies
def parent_rows(self, family=None):
family = self._check_family(family)
self.parent.set_clause(family)
rows = self.parent.cmd.select(fields=['parent'], order='parent')
self.parent.reset_clause()
return rows
def parents(self, family=None):
family = self._check_family(family)
rows = self.parent_rows(family)
return [x.parent for x in rows]
def environment_rows(self, family=None):
family = self._check_family(family)
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
return self.env.cursor.select(**args)
def family_rows(self):
return self.cursor.select(fields=['family'], table='families', order='family')
def all_families(self):
return [r.family for r in self.family_rows()]
def get_all_defaults(self):
stmt = select_multisuite_union(self.suites, 'variables')
print stmt
self.cursor.execute(stmt)
return self.cursor.fetchall()
def create_family(self, family):
if family not in self.all_families():
self.cursor.insert(table='families', data=dict(family=family))
else:
raise ExistsError, '%s already exists' % family
def insert_parents(self, parents, family=None):
family = self._check_family(family)
self.parent.insert('parent', parents)
def FamilyData(self, families=[]):
if families is None:
families = [self.current]
all = self.make_familylist(families)
superdict = {}
for f in all:
superdict.update(self.env.make_tagdict(f))
return superdict
def make_familylist(self, families):
deps = families
all = list(self.get_related_families(families))
setfun = self.set_family
parfun = self.parents
return make_deplist(deps, all, setfun, parfun)
def export_family(self, family=None):
if family is None:
family = self.current
element = FamilyElement(family)
element.append_parents(self.parents(family))
element.append_variables(self.environment_rows(family))
return element
def write_family(self, family, path):
fxml = file(join(path, '%s.xml' % family), 'w')
data = self.export_family(family)
data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
fxml.close()
def export_families(self, path):
families = self.all_families()
for f in families:
self.write_family(f, path)
def import_family(self, element):
parsed = FamilyParser(element)
print 'inserting family', parsed.name
all = self.all_families()
for p in parsed.parents:
if p not in all:
print 'insertion failed for', parsed.name
raise UnbornError
self.create_family(parsed.name)
self.set_family(parsed.name)
self.insert_parents(parsed.parents)
row = dict(family=parsed.name)
for var in parsed.environ:
row.update(var)
self.cursor.insert(table='family_environment', data=row)
def _import_family_xml(self, xmlfile):
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('family')
if len(elements) != 1:
raise Error, 'bad number of family tags %s' % len(elements)
element = elements[0]
return element
def import_family_xml(self, xmlfile):
element = self._import_family_xml(xmlfile)
self.import_family(element)
def import_families(self, path):
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
families = []
for f in xmlfiles:
element = self._import_family_xml(f)
families.append(element)
while len(families):
f = families[0]
try:
self.import_family(f)
except UnbornError:
families.append(f)
del families[0]
print len(families), 'families inserted'
def getVariablesConfig(self, family=None):
family = self._check_family(family)
return FamilyVariablesConfig(self.conn, family)
def deleteVariable(self, trait, name, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
self.env.cursor.delete(clause=clause)
def insertVariable(self, trait, name, value, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
testrows = self.cursor.select(table='family_environment', clause=clause)
if not len(testrows):
data['value'] = value
self.cursor.insert(table='family_environment', data=data)
class BaseDatabase(QSqlDatabase):
def __init__(self, dsn, name, parent=None, objname=None):
deprecated('useless.kdedb.BaseDatabase is deprecated')
QSqlDatabase.__init__(self, 'QPSQL7', name, parent, objname)
if hasattr(dsn, 'items'): #if dsn is dictionary
self.conn = BasicConnection(**dsn)
self.setDatabaseName(dsn['dbname'])
self.setHostName(dsn['host'])
self.dbuser = dsn['user']
else: #else a conn was passed as dsn
self.conn = dsn
self.setDatabaseName(self.conn.conn.db)
self.setHostName(self.conn.conn.host)
self.dbuser = self.conn.conn.user
self.setUserName(self.dbuser)
self.stmt = Statement()
self.mcursor = StatementCursor(self.conn)
def set_table(self, table):
self.stmt.table = table
def set_clause(self, items, cmp='=', join='and'):
self.stmt.set_clause(items, cmp=cmp, join=join)
def set_data(self, data):
self.stmt.set(data)
def set_fields(self, fields):
self.stmt.fields = fields
def qdelete(self, table=None, clause=None):
query = self.stmt.delete(table=table, clause=clause)
return self.execStatement(query)
def qinsert(self, table=None, data=None):
query = self.stmt.insert(table=table, data=data)
return self.execStatement(query)
def qupdate(self, table=None, data=None, clause=None):
query = self.stmt.update(table=table, data=data, clause=clause)
return self.execStatement(query)
def qselect(self, fields=None, table=None, clause=None,
group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause,
group=group, having=having, order=order)
return self.execStatement(query)
def delete(self, table=None, clause=None):
query = self.stmt.delete(table=table, clause=clause)
return self.mcursor.execute(query)
def insert(self, table=None, data=None):
query = self.stmt.insert(table=table, data=data)
return self.mcursor.execute(query)
def update(self, table=None, data=None, clause=None):
query = self.stmt.update(table=table, data=data, clause=clause)
return self.mcursor.execute(query)
def select(self, fields=None, table=None, clause=None,
group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause,
group=group, having=having, order=order)
self.mcursor.execute(query)
return self.mcursor.fetchall()
def select_row(self, fields=None, table=None, clause=None,
group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause,
group=group, having=having, order=order)
self.mcursor.execute(query)
rows = len(self.mcursor)
if rows == 1:
return self.mcursor.next()
elif rows == 0:
raise NoExistError
else:
raise RuntimeError, 'bad row count %s' % rows
def clear(self, **args):
self.stmt.clear(**args)
def stdclause(self, data):
return reduce(and_, [Eq(k, v) for k,v in data.items()])
def insertData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
try:
self.mcursor.select_row(fields=[idcol], table=table, clause=clause)
except NoExistError:
self.mcursor.insert(table=table, data=data)
if commit:
self.conn.commit()
def identifyData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
self.insertData(idcol, table, data, commit=commit)
return self.mcursor.select_row(fields=['*'], table=table, clause=clause)
class Family(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.current = None
self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
self.env = FamilyEnvironment(self.conn)
def set_family(self, family):
self.current = family
self.parent.set_current(family)
self.env.set_family(family)
def _check_family(self, family):
if family is not None:
return family
else:
family = self.current
if family is None:
raise Error, 'either pass a family arguement or call set_family on this object'
return family
def add_family(self, family, type='general'):
pass
def get_related_families(self, families=[]):
rows = self.cursor.select(table='family_parent')
graph = kjGraph([(r.family, r.parent) for r in rows])
dfamilies = Set()
for fam in families:
dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
return dfamilies
def parent_rows(self, family=None):
family = self._check_family(family)
self.parent.set_clause(family)
rows = self.parent.cmd.select(fields=['parent'], order='parent')
self.parent.reset_clause()
return rows
def parents(self, family=None):
family = self._check_family(family)
rows = self.parent_rows(family)
return [x.parent for x in rows]
def environment_rows(self, family=None):
family = self._check_family(family)
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
return self.env.cursor.select(**args)
def family_rows(self):
return self.cursor.select(fields=['family'], table='families', order='family')
def all_families(self):
return [r.family for r in self.family_rows()]
def get_all_defaults(self):
suite_cursor = SuiteCursor(self.conn)
suites = suite_cursor.get_suites()
stmt = select_multisuite_union(suites, 'variables')
print stmt
self.cursor.execute(stmt)
return self.cursor.fetchall()
def create_family(self, family):
if family not in self.all_families():
self.cursor.insert(table='families', data=dict(family=family))
else:
raise ExistsError, '%s already exists' % family
def insert_parents(self, parents, family=None):
family = self._check_family(family)
self.parent.insert('parent', parents)
def FamilyData(self, families=[]):
if families is None:
families = [self.current]
all = self.make_familylist(families)
superdict = {}
for f in all:
superdict.update(self.env.make_tagdict(f))
return superdict
def make_familylist(self, families):
deps = families
all = list(self.get_related_families(families))
setfun = self.set_family
parfun = self.parents
return make_deplist(deps, all, setfun, parfun)
def export_family(self, family=None):
if family is None:
family = self.current
element = FamilyElement(family)
element.append_parents(self.parents(family))
element.append_variables(self.environment_rows(family))
return element
def write_family(self, family, path):
fxml = file(join(path, '%s.xml' % family), 'w')
data = self.export_family(family)
data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
fxml.close()
def export_families(self, path):
families = self.all_families()
self.report_total_families(len(families))
for f in families:
self.write_family(f, path)
self.report_family_exported(f, path)
def import_family(self, element):
parsed = FamilyParser(element)
print 'inserting family', parsed.name
all = self.all_families()
for p in parsed.parents:
if p not in all:
print 'insertion failed for', parsed.name
raise UnbornError
self.create_family(parsed.name)
self.set_family(parsed.name)
self.insert_parents(parsed.parents)
row = dict(family=parsed.name)
for var in parsed.environ:
row.update(var)
self.cursor.insert(table='family_environment', data=row)
def _import_family_xml(self, xmlfile):
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('family')
if len(elements) != 1:
raise Error, 'bad number of family tags %s' % len(elements)
element = elements[0]
return element
def import_family_xml(self, xmlfile):
element = self._import_family_xml(xmlfile)
self.import_family(element)
def import_families(self, path):
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
families = []
for f in xmlfiles:
element = self._import_family_xml(f)
families.append(element)
while len(families):
f = families[0]
try:
self.import_family(f)
except UnbornError:
families.append(f)
del families[0]
print len(families), 'families inserted'
def getVariablesConfig(self, family=None):
family = self._check_family(family)
return FamilyVariablesConfig(self.conn, family)
def deleteVariable(self, trait, name, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
self.env.cursor.delete(clause=clause)
def insertVariable(self, trait, name, value, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
testrows = self.cursor.select(table='family_environment', clause=clause)
if not len(testrows):
data['value'] = value
self.cursor.insert(table='family_environment', data=data)
def report_family_exported(self, family, path):
print 'family %s exported to %s' % (family, path)
def report_total_families(self, total):
print 'exporting %d families' % total
class Family(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.current = None
self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
self.env = FamilyEnvironment(self.conn)
def set_family(self, family):
self.current = family
self.parent.set_current(family)
self.env.set_family(family)
def _check_family(self, family):
if family is not None:
return family
else:
family = self.current
if family is None:
raise Error, 'either pass a family argument or call set_family on this object'
return family
def get_related_families(self, families=[]):
rows = self.cursor.select(table='family_parent')
graph = kjGraph([(r.family, r.parent) for r in rows])
dfamilies = Set()
for fam in families:
dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
return dfamilies
def parent_rows(self, family=None):
family = self._check_family(family)
self.parent.set_clause(family)
rows = self.parent.cmd.select(fields=['parent'], order='parent')
self.parent.reset_clause()
return rows
def parents(self, family=None):
family = self._check_family(family)
rows = self.parent_rows(family)
return [x.parent for x in rows]
def environment_rows(self, family=None):
family = self._check_family(family)
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'],
clause=clause,
order=['trait', 'name'])
return self.env.cursor.select(**args)
def family_rows(self):
return self.cursor.select(fields=['family'],
table='families',
order='family')
def all_families(self):
return [r.family for r in self.family_rows()]
def get_all_defaults(self):
suite_cursor = SuiteCursor(self.conn)
suites = suite_cursor.get_suites()
stmt = select_multisuite_union(suites, 'variables')
print stmt
self.cursor.execute(stmt)
return self.cursor.fetchall()
def create_family(self, family):
if family not in self.all_families():
self.cursor.insert(table='families', data=dict(family=family))
else:
raise ExistsError, '%s already exists' % family
def delete_family(self, family=None):
family = self._check_family(family)
self.cursor.execute("select * from delete_family('%s')" % family)
def insert_parents(self, parents, family=None):
family = self._check_family(family)
self.parent.insert('parent', parents)
def delete_parents(self, parents=[], family=None):
family = self._check_family(family)
if not parents:
parents = self.parents()
if not parents:
return
table = 'family_parent'
clause = Eq('family', family) & In('parent', parents)
self.cursor.delete(table=table, clause=clause)
def FamilyData(self, families=[]):
# change sep here
sep = PAELLA_TRAIT_NAME_SEP
# we don't know what to do here
# it is possible to have an empty
# list of families, and if that's the
# case we don't need to make the
# list of [self.current] . I need to look
# for everywhere this method is called.
# In the installer, the family is never set,
# and we use the list of families provided
# by the profile and the machine. In this
# case, the families argument will always
# be a list, empty or not.
# I can't think of any other circumstance
# where this method would be called outside
# of the installer, or a script, and the script
# should be using either a profile or machine
# to get the list of families anyway, make the
# point moot. I will probably remove this part
# of the code in the near future, once I'm sure
# that there's no reason to pass None to the
# families argument.
if families is None:
families = [self.current]
all = self.make_familylist(families)
superdict = {}
for f in all:
superdict.update(self.env.make_tagdict(f, sep=sep))
return superdict
def make_familylist(self, families):
deps = families
all = list(self.get_related_families(families))
setfun = self.set_family
parfun = self.parents
return make_deplist(deps, all, setfun, parfun)
def export_family(self, family=None):
if family is None:
family = self.current
# row isn't used, except to determine that the family exists
row = self.cursor.select_row(table='families',
clause=Eq('family', family))
element = FamilyElement(family)
element.append_parents(self.parents(family))
element.append_variables(self.environment_rows(family))
return element
def write_family(self, family, path):
fxml = file(join(path, '%s.xml' % family), 'w')
data = self.export_family(family)
data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
fxml.close()
def export_families(self, path):
families = self.all_families()
self.report_total_families(len(families))
for f in families:
self.write_family(f, path)
self.report_family_exported(f, path)
def import_family(self, element):
parsed = FamilyParser(element)
print 'inserting family', parsed.name
all = self.all_families()
for p in parsed.parents:
if p not in all:
print 'insertion failed for', parsed.name
raise UnbornError
self.create_family(parsed.name)
self.set_family(parsed.name)
self.insert_parents(parsed.parents)
row = dict(family=parsed.name)
for var in parsed.environ:
row.update(var)
self.cursor.insert(table='family_environment', data=row)
def _import_family_xml(self, xmlfile):
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('family')
if len(elements) != 1:
raise Error, 'bad number of family tags %s' % len(elements)
element = elements[0]
return element
def import_family_xml(self, xmlfile):
element = self._import_family_xml(xmlfile)
self.import_family(element)
def import_families(self, path):
xmlfiles = [
join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'
]
families = []
for f in xmlfiles:
element = self._import_family_xml(f)
families.append(element)
while len(families):
f = families[0]
try:
self.import_family(f)
except UnbornError:
families.append(f)
del families[0]
print len(families), 'families inserted'
def getVariablesConfig(self, family=None):
family = self._check_family(family)
return FamilyVariablesConfig(self.conn, family)
def deleteVariable(self, trait, name, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k, v in data.items()])
self.env.cursor.delete(clause=clause)
def insertVariable(self, trait, name, value, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k, v in data.items()])
testrows = self.cursor.select(table='family_environment',
clause=clause)
if not len(testrows):
data['value'] = value
self.cursor.insert(table='family_environment', data=data)
def report_family_exported(self, family, path):
print 'family %s exported to %s' % (family, path)
def report_total_families(self, total):
print 'exporting %d families' % total
class BaseDatabase(object):
def __init__(self, conn=None):
if conn is None:
self.conn = KonsultantConnection()
else:
self.conn = conn
self.stmt = Statement()
self.mcursor = StatementCursor(self.conn)
def set_table(self, table):
self.stmt.table = table
def set_clause(self, items, cmp='=', join='and'):
self.stmt.set_clause(items, cmp=cmp, join=join)
def set_data(self, data):
self.stmt.set(data)
def set_fields(self, fields):
self.stmt.fields = fields
def delete(self, table=None, clause=None):
query = self.stmt.delete(table=table, clause=clause)
return self.mcursor.execute(query)
def insert(self, table=None, data=None):
query = self.stmt.insert(table=table, data=data)
return self.mcursor.execute(query)
def update(self, table=None, data=None, clause=None):
query = self.stmt.update(table=table, data=data, clause=clause)
return self.mcursor.execute(query)
def select(self, fields=None, table=None, clause=None,
group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause,
group=group, having=having, order=order)
self.mcursor.execute(query)
return self.mcursor.fetchall()
def select_row(self, fields=None, table=None, clause=None,
group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause,
group=group, having=having, order=order)
self.mcursor.execute(query)
rows = len(self.mcursor)
if rows == 1:
return self.mcursor.next()
elif rows == 0:
raise NoExistError
else:
raise Error, 'bad row count %s' % rows
def clear(self, **args):
self.stmt.clear(**args)
def stdclause(self, data):
return reduce(and_, [Eq(k, v) for k,v in data.items()])
def insertData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
try:
self.mcursor.select_row(fields=[idcol], table=table, clause=clause)
except NoExistError:
self.mcursor.insert(table=table, data=data)
if commit:
self.conn.commit()
def identifyData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
self.insertData(idcol, table, data, commit=commit)
return self.mcursor.select_row(fields=['*'], table=table, clause=clause)