Python StatementCursor.insert方法代码示例

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def add_new_mount(conn, name, mtpt, fstype, opts,
                  dump='0', pass_='0'):
    cursor = StatementCursor(conn)
    data = dict(mnt_name=name, mnt_point=mtpt,
                fstype=fstype, mnt_opts=opts,
                dump=dump)
    data['pass'] = pass_
    cursor.insert(table='mounts', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class TableEditor(ListWin):
    def __init__(self, conn, table, pkey=None, fields=[],
                 command_data=dict(new='new entry', edit='edit entry')):
        ListWin.__init__(self)
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.cursor.set_table(table)
        self._cdata = command_data
        self.tbar.add_button('new', self._cdata['new'], self.toolbar_button_pressed)
        self.tbar.add_button('edit', self._cdata['edit'], self.toolbar_button_pressed)
        if pkey is None:
            print get_pkey_info(StatementCursor(conn), table)
        self._pkey = pkey
        self.reset_rows()
        self._fields = fields
        self.fields = [pkey] + self._fields
        self.dialogs = {}.fromkeys(self._cdata.keys())

    def reset_rows(self):
        self.set_rows(self.cursor.select(order=self._pkey))

    def toolbar_button_pressed(self, button, data):
        row = None
        if data == 'new':
            if self.dialogs['new'] is None:
                row = self.cursor.select()[0]
                self._make_dialog('new', row, self.add_new_record)
        elif data == 'edit':
            if self.dialogs['edit'] is None:
                row = get_single_row(self.listbox, self._pkey)
                if row is not None:
                    self._make_dialog('edit', row, self.edit_record, row[self._pkey])
            
                
                
    def _make_dialog(self, name, row, okfun, pkey=None):
        if name == 'edit':
            fields = self._fields
        else:
            fields = self.fields
        make_record_dialog(self, name, row, okfun, pkey, fields, self._cdata)
        
    def add_new_record(self, *args):
        dialog = self.dialogs['new']
        self.cursor.insert(data=dict(dialog.items()))
        self.destroy_dialog(dialog)
        self.reset_rows()

    def edit_record(self, *args):
        dialog = self.dialogs['edit']
        clause = Eq(self._pkey, dialog.pkey)
        data = dict(dialog.items())
        self.cursor.update(data=data, clause=clause)
        self.destroy_dialog(dialog)
        self.reset_rows()

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class TextFileManager(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.cursor.set_table('textfiles')

    def insert_file(self, datafile):
        md5 = self._md5sum(datafile)
        data = datafile.read()
        md5size = '_'.join([md5, str(len(data))])
        return self._insert_data(md5size, data)

    def insert_data(self, data):
        md5 = md5sum(strfile(data))
        md5size = '_'.join([md5, str(len(data))])
        return self._insert_data(md5size, data)
    
    def _insert_data(self, md5size, data):
        clause=Eq('md5size', md5size)
        try:
            row = self.cursor.select_row(clause=clause)
        except NoExistError:
            row = None
        if not row:
            self.cursor.insert(data={'md5size' : md5size, 'data' : data})
            row = self.cursor.select_row(clause=clause)
        return row.fileid

    def get_data(self, id):
        row = self.cursor.select_row(clause=Eq('fileid', id))
        return row.data

    def get_strfile(self, id):
        return strfile(self.get_data(id))

    def _md5sum(self, datafile):
        datafile.seek(0)
        md5 = md5sum(datafile)
        datafile.seek(0)
        return md5

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class PaellaProfiles(Element):
    def __init__(self, conn):
        Element.__init__(self, 'profiles')
        self.conn = conn
        self.stmt = StatementCursor(self.conn)
        self.env = ProfileEnvironment(self.conn)
        self.profiletraits = ProfileTrait(self.conn)
        self._profiles = {}
        for row in self.stmt.select(table='profiles', order='profile'):
            self._append_profile(row.profile, row.suite)
                
    def _append_profile(self, profile, suite):
        element = self.export_profile(profile, suite)
        self._profiles[profile] = element
        self.appendChild(self._profiles[profile])

    def export_profile(self, profile, suite=None):
        if suite is None:
            row = self.stmt.select_row(table='profiles',clause=Eq('profile', profile))
            suite = row['suite']
        suite = str(suite)
        profile = str(profile)
        self.env.set_profile(profile)
        element = ProfileElement(profile, suite)
        element.append_traits(self.profiletraits.trait_rows(profile))
        element.append_variables(self.env.get_rows())
        return element

    def insert_profile(self, profile):
        idata = {'profile' : profile.name,
                 'suite' : profile.suite}
        self.stmt.insert(table='profiles', data=idata)
        idata = {'profile' : profile.name,
                 'trait' : None,
                 'ord' : 0}
        for trait, ord in profile.traits:
            print trait, ord
            idata['trait'] = trait
            idata['ord'] = ord #str(ord)
            self.stmt.insert(table='profile_trait', data=idata)
        idata = {'profile' : profile.name,
                 'trait' : None,
                 'name' : None,
                 'value': None}
        for trait, name, value in profile.vars:
            idata['trait'] = trait
            idata['name'] = name
            idata['value'] = value
            self.stmt.insert(table='profile_variables', data=idata)

    def export_profiles(self, path):
        rows = self.stmt.select(fields='profile', table='profiles', clause=None)
        for row in rows:
            self.write_profile(row.profile, path)
        
    def write_profile(self, profile, path):
        xmlfile = file(join(path, '%s.xml' % profile), 'w')
        data = self.export_profile(profile)
        data.writexml(xmlfile, indent='\t', newl='\n', addindent='\t')
        xmlfile.close()

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def make_a_machine(conn, machine, mtype, profile, fs):
    cursor = StatementCursor(conn)
    data = dict(machine=machine, machine_type=mtype,
                profile=profile, filesystem=fs)
    cursor.insert(table='machines', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class Family(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        self.suites = Suites(conn).list()
        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 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):
        if family is None:
            family = self.current
        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):
        rows = self.parent_rows(family)
        return [x.parent for x in rows]
    
    def environment_rows(self, family=None):
        if family is None:
            family = self.current
        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):
        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 export_families(self, path):
        families = self.all_families()
        for f in families:
            fxml = file(join(path, '%s.xml' % f), 'w')
            data = self.export_family(f)
            data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
            fxml.close()

#.........这里部分代码省略.........

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def add_mount_to_filesystem(conn, mnt_name, filesystem, ord, partition):
    cursor = StatementCursor(conn)
    data = dict(mnt_name=mnt_name, filesystem=filesystem,
                ord=str(ord), partition=partition)
    cursor.insert(table='filesystem_mounts', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def add_new_filesystem(conn, filesystem):
    cursor = StatementCursor(conn)
    data = dict(filesystem=filesystem)
    cursor.insert(table='filesystems', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def add_new_kernel(conn, kernel):
    cursor = StatementCursor(conn)
    data = dict(kernel=kernel)
    cursor.insert(table='kernels', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class RepositoryManager(object):
    def __init__(self, conn):
        self.conn = conn
        self.main = StatementCursor(self.conn, 'RepositoryMain')
        self.repos = StatementCursor(self.conn, 'Repository')
        self.repos.set_table('repository')
        self.sources = StatementCursor(self.conn, 'Sources')
        self.sources.set_table('sources')
        self.release = ReleaseCursor(self.conn)
        self.repsections = StatementCursor(self.conn, 'repos_section')
        self.repsections.set_table('repos_section')
        self.__init_db__()
        
    def __init_db__(self):
        if not len(self.main.tables()):
            map(self.main.create_table, primary_tables())

    def drop_source(self, name, type):
        nameclause = Eq('name', name)
        clause = nameclause & Eq('type', type)
        for section in self.get_sections(name):
            self.main.drop(list_tablename(name, type, section))
        self.sources.delete(clause=clause)
        sources = self.sources.select(clause=clause)
        if not len(sources):
            self.repsections.delete(clause=nameclause)
            self.repos.delete(clause=nameclause)
            
    def add_source(self, name, source):
        source = make_source(source)
        if name not in [x.name for x in self.repos.select()]:
            self.repos.insert(data=dict(name=name))
        clause = Eq('name', name) & Eq('type', source.type)
        count = int(self.sources.select(fields=['count(name)'], clause=clause)[0][0])
        if count == 0:
            if islocaluri(source.uri):
                data = dict(name=name, type=source.type, uri=source.uri,
                            suite=source.suite)
                self.sources.insert(data=data)
                current_sections = self.get_sections(name)
                sdata = dict(name=name, section=None)
                for section in source.sections:
                    if section not in current_sections:
                        sdata['section'] = section
                        self.repsections.insert(data=sdata)
                    fullparse = FullParseTable(name, source.type, section)
                    if fullparse.name not in self.main.tables():
                        self.main.create_table(fullparse)
                    listtable = ListTable(name, source.type, section)
                    if listtable.name not in self.main.tables():
                        self.main.create_table(listtable)
            else:
                raise Error, 'local uris first'
        else:
            if not islocaluri(source.uri):
                data = dict(remote=source.uri)
                self.sources.update(data=data, clause=clause)
            else:
                raise ExistsError, 'already there'

    def get_sections(self, name):
        clause = Eq('name', name)
        return [x.section for x in self.repsections.iselect(fields=['section'], clause=clause)]

    def make_source_line(self, name, type, remote=False):
        repsrc = self.make_source(name, type, remote)
        return str(repsrc)

    def make_source(self, name, type, remote=False):
        clause = Eq('name', name) & Eq('type', type)
        source = self.sources.select_row(clause=clause)
        repsrc = RepositorySource()
        repsrc.type = source.type
        if remote:
            repsrc.uri = source.remote
        else:
            repsrc.uri = source.uri
        repsrc.suite = source.suite
        repsrc.sections = self.get_sections(name)
        repsrc.set_path()
        return repsrc

    def listfile(self, name, type, section=None):
        source = self.make_source(name, type)
        release = Release(source)
        print 'Need to pull from database!!!'
        if source.has_release():
            return join(source.distpath, release.path(section))
        else:
            return join(source.distpath, source.listfile())
    def get_remote(self, name, type, remote=True):
        return self.make_source(name, type, remote=True)

    def parse_section(self, name, type, section=None):
        listfile = self.listfile(name, type, section)
        debug(listfile)
        if not isfile(listfile):
            raise NoFileError, 'file not there'
        if type == 'deb':
            return full_parse(listfile)
#.........这里部分代码省略.........

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
def add_machine_type(conn, mtype):
    cursor = StatementCursor(conn)
    data = dict(machine_type=mtype)
    cursor.insert(table='machine_types', data=data)

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class ColorThingyWindow(CommandBoxWindow):
    def __init__(self, rgb, conn, name='ColorThingyWindow'):
        CommandBoxWindow.__init__(self, name=name)
        self.browser = ColorThingy(rgb)
        self.rgb = rgb
        self.cmd = StatementCursor(conn, 'themer')
        self.theme = None
        self.vbox.add(self.browser)
        self.tbar.add_button('import', 'import', self.__ask_import__)
        self.tbar.add_button('insert', 'insert', self.__ask_insert__)
        self.tbar.add_button('update', 'update', self.__update_theme__)
        self.tbar.add_button('save', 'save', self.__save_files__)
        self._insert_box = None
        self._import_box = None

    def __ask_import__(self, *args):
        if not self._import_box:
            #print args
            #print '__import__'
            themes = self.cmd.getall(['theme'], 'themes')
            self._import_box = CList('hello')
            self._import_box.set_rows(themes)
            self._import_box.set_ok(self.__import_ok__)

    def __import_ok__(self, *args):
        theme = self._import_box.listbox.get_selected_data()[0]['theme']
        self._import_box.destroy()
        self._import_box = None
        rows = self.cmd.select(table=theme)
        b = self.browser
        b._style.quick_set(rows)
        for e, sb in b._elements.items():
            for s in sb.keys():
                color = b._style.elements[e][s]        
                sb[s] = color.name
                _bg_widget(sb[s].button, color)
        self.theme = theme
                                     
    def __ask_insert__(self, *args):
        if not self._import_box:
            self._insert_box = EntryDialog('please insert name')
            self._insert_box.set_ok(self.__insert_ok__)

    def __insert_ok__(self, *args):
        style = self.browser._style
        tname = self._insert_box.get()
        self.theme = tname
        table = ThemeTable(tname)
        self.cmd.create_table(table)
        self.cmd.insert('themes', {'theme':tname})
        for row in style.to_irows():
            self.cmd.insert(tname, row)

    def __update_theme__(self, *args):
        if self.theme:
            for element, states in self.browser._style.to_urows():
                self.cmd.update(self.theme, states, "element = '%s'" %element)
    def __save_files__(self, *args):
        colordict = Rgbdb()
        tmpl = GtkrcTemplate(self.theme, theme_base, self.browser._style)
        tmpl.write_files()

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class VariablesConfig(RawConfigParser):
    def __init__(self, conn, table, section,
                 mainfield=None, mainvalue=None,
                 option='name', value='value'):
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.cursor.set_table(table)
        self._secfield = section
        bothnone = mainfield is None and mainvalue is None
        bothset = mainfield and mainvalue
        if not bothnone and not bothset:
            raise Error, 'both mainfield and mainvalue need to be set/unset'
        self._mainclause = None
        if bothset:
            self._mainclause = Eq(mainfield, mainvalue)
        self._fields = [self._secfield, option, value]
        RawConfigParser.__init__(self)
        for row in self.cursor.select(fields=self._fields, clause=self._mainclause):
            if row[0] not in self.sections():
                self.add_section(row[0])
            self.set(*row)

    def write(self, cfile):
        sections = self.sections()
        sections.sort()
        for section in sections:
            cfile.write('[%s]\n' % section)
            keys = self.options(section)
            keys.sort()
            for k in keys:
                if k != '__name__':
                    v = str(self.get(section, k)).replace('\n', '\n\t')
                    cfile.write('%s:\t%s\n' % (k, v))
            cfile.write('\n')
            
    def edit(self):
        tmp, path = tempfile.mkstemp('variables', 'config')
        tmp = file(path, 'w')
        self.write(tmp)
        tmp.close()
        os.system('$EDITOR %s' % path)
        tmp = file(path, 'r')
        newconfig = RawConfigParser()
        newconfig.readfp(tmp)
        tmp.close()
        os.remove(path)
        return newconfig

    def diff(self, other):
        ltmp, lpath = tempfile.mkstemp('variables', 'config')
        ltmp = file(lpath, 'w')
        self.write(ltmp)
        ltmp.close()
        rtmp, rpath = tempfile.mkstemp('variables', 'config')
        rtmp = file(rpath, 'w')
        other.write(rtmp)
        rtmp.close()
        os.system('xxdiff %s %s' % (lpath, rpath))
        ltmp, rtmp = file(lpath, 'r'), file(rpath, 'r')
        lcfg, rcfg = RawConfigParser(), RawConfigParser()
        lcfg.readfp(ltmp)
        rcfg.readfp(rtmp)
        ltmp.close()
        rtmp.close()
        self.update(lcfg)
        other.update(rcfg)
        
    
        
    def update(self, newconfig):
        removed = [x for x in self.sections() if x not in newconfig.sections()]
        for section in removed:
            print 'removing', section
            sclause = Eq(self._secfield, section)
            if self._mainclause:
                sclause &= self._mainclause
            self.cursor.delete(clause=sclause)
        for section in newconfig.sections():
            print section
            sclause = Eq(self._secfield, section)
            if self._mainclause:
                sclause = self._mainclause & Eq(self._secfield, section)
            if not self.has_section(section):
                for k,v in newconfig.items(section):
                    idata = dict(zip(self._fields, [section, k, v]))
                    if self._mainclause:
                        idata[self._mainclause.left] = self._mainclause.right
                    print idata
                    self.cursor.insert(data=idata)
            else:
                for name, value in newconfig.items(section):
                    nclause = sclause & Eq(self._fields[1], name)
                    #print 'nclause', nclause
                    #print 'value', self.get(section, name)
                    if self.has_option(section, name):
                        if value != self.get(section, name):
                            #print 'updating'
                            self.cursor.update(data={self._fields[2] : value}, clause=nclause)
                    else:
                        idata = dict(zip(self._fields, [section, name, value]))
#.........这里部分代码省略.........

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class RelationalBrowser(ListNoteBook, HasDialogs):
    def __init__(self, conn, maintable, reltable, pkey, fields):
        self.menu = make_menu(["insert", "update", "done"], self.pkey_command)
        ListNoteBook.__init__(self)
        self.conn = conn
        self.main = StatementCursor(self.conn)
        self.main.set_table(maintable)
        self.rel = StatementCursor(self.conn)
        self.rel.set_table(reltable)
        self.pkey = pkey
        self._fields = fields
        self.fields = [self.pkey] + self._fields
        self.reset_rows()
        self.dialogs = {}.fromkeys(["insert", "update", "delete"])
        self.relmenu = make_menu(["insert", "update", "delete"], self.relmenu_command)

    def reset_rows(self):
        self.set_rows(self.main.select(order=self.pkey))
        self.set_row_select(self.pkey_selected)

    def pkey_selected(self, listbox, row, column, event):
        value = listbox.get_selected_data()[0][0]
        self.current_value = value
        if value not in self.pages:
            rows = self.rel.select(clause=Eq(self.pkey, value), order=self.pkey)
            rtable = ScrollCList(rcmenu=self.relmenu)
            rtable.set_rows(rows)
            self.append_page(rtable, value)
        self.set_current_page(value)

    def pkey_insert_ok(self, *args):
        dialog = self.dialogs["insert"]
        value = dialog.get()
        print value
        try:
            self.main.insert(data={self.pkey: value})
            inserted = True
        except OperationalError:
            dialogs.Message("bad query\n%s is not allowed" % value)
        if inserted:
            self.destroy_dialog(dialog)
            self.reset_rows()

    def relmenu_command(self, menuitem, command):
        print command
        if command in ["insert", "update", "delete"]:
            if self.dialogs[command] is None:
                clause = Eq(self.pkey, self.current_value)
                try:
                    row = self.rel.select(clause=clause)[0]
                except IndexError:
                    row = dict.fromkeys(self.fields)
                row[self.pkey] = self.current_value
                if command in ["insert", "delete"]:
                    fields = self.fields
                    clause = None
                else:
                    fields = self._fields
                    clause = Eq(self.pkey, self.current_value)
                make_record_dialog(
                    self, command, row, self.relmenu_command_selected, self.pkey, fields, {command: command}
                )
            print self.dialogs.items()

    def relmenu_command_selected(self, button, *data):
        command = button.get_name()
        dialog = self.dialogs[command]
        items = dialog.items()
        if command == "insert":
            self.rel.insert(data=dict(items))
        elif command == "delete":
            print "delete delete delete delete"
            clause = SimpleClause(items, "=", "and")
            dialogs.Message(self.rel.stmt.delete(clause=clause))

        if False:
            dialog = self.dialogs["insert"]
            print dialog
            items = dialog.items()
            print items
            self.rel.insert(data=dict(items))
            self.destroy_dialog(dialog)
            self.reset_rows()

# 需要导入模块: from paella.db.midlevel import StatementCursor [as 别名]
# 或者: from paella.db.midlevel.StatementCursor import insert [as 别名]
class BaseDatabase(QSqlDatabase):
    def __init__(self, dsn, name, parent=None, objname=None):
        QSqlDatabase.__init__(self, "QPSQL7", name, parent, objname)
        self.conn = BasicConnection(**dsn)
        self.setDatabaseName(dsn["dbname"])
        self.setHostName(dsn["host"])
        self.dbuser = dsn["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 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)