def connect_db(self): try: if (self.params['-s']==''):# and self.params['-d']!=''): print self.params self.mydb=kdb.connect(host=self.params['-h'],database=self.params['-d'],user=self.params['-u'], password=self.params['-p'],dialect=3, charset='UTF8' ) else: self.mydb=kdb.connect(dsn=self.params['-s'],user=self.params['-u'], password=self.params['-p'],dialect=3, charset='UTF8' ) return self.mydb except: print 'Except' self.no_connect() return None
def stopDB(self): import kinterbasdb conn = kinterbasdb.connect(database=self.DB_NAME, host='127.0.0.1', user=self.DB_USER, password=self.DB_PASS) conn.drop_database()
def makeConnection(self): customTPB = (kinterbasdb.isc_tpb_write + kinterbasdb.isc_tpb_read_committed + kinterbasdb.isc_tpb_rec_version) self.con = kinterbasdb.connect(dsn=self.dbname, user=self.login, password=self.passwd) self.con.begin(tpb=customTPB) self.cur = self.con.cursor() self.makeTables()
def connect(self): import kinterbasdb try: kinterbasdb.init(type_conv=0) except: pass self._db = kinterbasdb.connect(dsn=self._bdd, user=self._user, password=self._password, charset=self._charset) try: self._db.cursor().execute("DECLARE EXTERNAL FUNCTION lpad \ CSTRING(255) NULL, INTEGER, CSTRING(1) NULL \ RETURNS CSTRING(255) FREE_IT \ ENTRY_POINT 'IB_UDF_lpad' MODULE_NAME 'ib_udf'") except: pass try: self._db.cursor().execute("DECLARE EXTERNAL FUNCTION Round \ INT BY DESCRIPTOR, INT BY DESCRIPTOR \ RETURNS PARAMETER 2 \ ENTRY_POINT 'fbround' MODULE_NAME 'fbudf'") except: pass
def stopDB(self): import kinterbasdb conn = kinterbasdb.connect(database=self.DB_NAME, host='127.0.0.1', user=self.DB_USER, password=self.DB_PASS) conn.drop_database() conn.close()
def _cursor(self): if self.connection is None: settings_dict = self.settings_dict if settings_dict['NAME'] == '': from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("You need to specify DATABASE_NAME in your Django settings file.") conn_params = { 'charset': 'UNICODE_FSS' } conn_params['dsn'] = settings_dict['NAME'] if settings_dict['HOST']: conn_params['dsn'] = ('%s:%s') % (settings_dict['HOST'], conn_params['dsn']) if settings_dict['PORT']: conn_params['port'] = settings_dict['PORT'] if settings_dict['USER']: conn_params['user'] = settings_dict['USER'] if settings_dict['PASSWORD']: conn_params['password'] = settings_dict['PASSWORD'] options = settings_dict['OPTIONS'].copy() # Normalization for databases with 'NONE', 'OCTETS' or 'ASCII' charset. encoding = options.pop('encoding', 'utf_8') conn_params.update(options) self.connection = Database.connect(**conn_params) self._type_translator.set_charset(self.connection.charset, encoding) connection_created.send(sender=self.__class__) if self.ops.firebird_version[0] >= 2: self.features.can_return_id_from_insert = True return FirebirdCursorWrapper(self.connection.cursor(), self._type_translator)
def PegaListadoBanco(self): ''' Pega os dados do banco de dados e salva na listaProdutos ''' try: conn = kinterbasdb.connect(host="10.1.1.10", database='C:\SIACPlus\siacCX.fdb', user="******", password="******", charset="ISO8859_1" ) print "Conexão aberta" cur = conn.cursor() cur.execute('SELECT a.COD_PRODUTO, a.DESCRICAO, a.CODBARRAS, a.SALDOESTOQUE FROM ACADPROD a') print "Select executado" #print "Lista de Produtos: ", self.listadeProdutos # Pegando dados do select e salvando em lista produtos, no momento salvando com estoque zero for i in cur: (cod_prod, descr, codbarras, saldoestoque) = i self.adicionaProdutos(cod_prod, descr, codbarras, saldoestoque) print "Produtos adicionados a lista" # Fechando acesso ao banco conn.close() print "Conexão fechada" except: print "Erro ao acessar o banco" finally: print "Dados salvo com sucesso"
def connect(self): if self.rdbms == 'mssql': import socket #( To get the computer name for a SQL Server instance. import ipymssql #( Custom IronPython .NET Data Provider for SQL Server Instance = socket.gethostname() + r"\SILFW" Database = 'TestLangProj' conStr = 'Data Source=%s; Initial Catalog=%s; Integrated Security=True' % (Instance, Database) con = ipymssql.connect(conStr) elif self.rdbms == 'fb' or self.rdbms == 'firebird': import kinterbasdb #( http://kinterbasdb.sourceforge.net #( kinterbasdb must be initialized for life to be happy. See #( "Incompatibilities" at the top of: #( #( http://kinterbasdb.sourceforge.net/dist_docs/usage.html #( #( The default for kinterbasdb.init is only for backward compatibility. #( The reasons for this are written up at: #( #( http://kinterbasdb.sourceforge.net/dist_docs/usage.html#faq_fep_is_mxdatetime_required #( #( The ideal is to use type_conv=200 kinterbasdb.init(type_conv=200) con = kinterbasdb.connect( dsn = 'C:\Program Files\Firebird_2_0\Data\TESTLANGPROJ.FDB', user = "******", password = "******", charset = 'UTF8', dialect = 3) return con
def GetConnect(self): self.connect = None self.db_message = '' if self.k_conf.status_config == krconst.kr_status_config_error: self.db_message = self.k_conf.status_config_message try: self.connect = FB.connect(dsn=self.k_conf.db_ip + ':' + self.k_conf.db_path, user=self.k_conf.db_user, password=self.k_conf.db_pass, role=self.k_conf.db_role, charset=self.k_conf.db_charset) # self.connect.begin() self.cursor = self.connect.cursor() except: #print 'self.db_message', sys.exc_value[0] #print 'self.db_message', sys.exc_value[1] #print sys.exc_value[1].find('Unable to complete network request to host') if sys.exc_value[ 0] == -902: #and sys.exc_value[1].find('Unable to complete network request to host')!=-1: #print 'bed connection' self.db_message = sys.exc_value[1] else: self.db_message = sys.exc_value[0] return True
def openFB(): config = ConfigParser.ConfigParser() config.read('config.cfg') conFB = kinterbasdb.connect(dsn=config.get('fb', 'host')+':'+config.get('fb', 'dbname'), \ user=config.get('fb','user'), \ password=config.get('fb', 'password'), \ charset=config.get('fb', 'charset'), \ dialect=config.getint('fb', 'dialect')) return conFB, conFB.cursor()
def CleanUp(self, result): # Drop a database. try: self.__con = kinterbasdb.connect(dsn=str(self.__database_path), \ user=str(self.user_name), password=str(self.user_password)) self.__con.drop_database() except Exception, error: # Cleanup failed. cause = "Database deletion failed. %s" % str(error) result.Fail(cause)
def connect(self): self.initConnection() if not self.hostname: self.checkFileDb() try: self.connector = kinterbasdb.connect(host=self.hostname.encode(UNICODE_ENCODING), database=self.db.encode(UNICODE_ENCODING), \ user=self.user.encode(UNICODE_ENCODING), password=self.password.encode(UNICODE_ENCODING), charset="UTF8") # Reference: http://www.daniweb.com/forums/thread248499.html except kinterbasdb.OperationalError, msg: raise SqlmapConnectionException(msg[1])
def connect(self, dbname, user, passwd, host, **kwargs): try: import kinterbasdb except: print "Missing Firebird support through kinterbasdb" return self.strDbms = "firebird" self.version = kwargs.get("version") self.conn = kinterbasdb.connect(dsn="localhost:%s" % dbname, user=user, password=passwd) self.cursor = self.conn.cursor()
def __init__(self, DBFileName): """ Конструктор. Принимает в качестве аргумента имя файла базы данных и устанавливает с ней соединение """ self.con = k.connect( host=None, database=DBFileName, user="******", password="******", dialect=3, charset="WIN1251" ) customTPB = k.isc_tpb_shared # Explicitly start a transaction with the custom TPB: self.con.begin(tpb=customTPB) self.curs = self.con.cursor()
def fireBirdTests(self, bExec=True): try: import kinterbasdb except: print "Missing Firebird support through kinterbasdb" return self.strDbms = "firebird" info = conn_info[self.strDbms] self.conn = kinterbasdb.connect(dsn="localhost:%s" % info["dbname"], user=info["user"], password=info["pass"]) ddt = DbDmlTest.DbDmlTest(self.strDbms, self.testList, log) ddt.doTests(self.conn, info["version"], bExec=bExec)
def connect(self, info): try: import kinterbasdb except: print "Missing Firebird support through kinterbasdb" return self.strDbms = 'firebird' self.version = info['version'] self.conn = kinterbasdb.connect(dsn='localhost:%s' % info['dbname'], user=info['user'], password=info['pass']) self.cursor = self.conn.cursor()
def connect(self, dbname, user, passwd, host, **kwargs): try: import kinterbasdb except: print "Missing Firebird support through kinterbasdb" return self.strDbms = 'firebird' self.version = kwargs.get('version') self.conn = kinterbasdb.connect(dsn='localhost:%s' % dbname, user=user, password=passwd) self.cursor = self.conn.cursor()
def makeConnection(self): extra = {} if self.dialect: extra['dialect'] = self.dialect return kinterbasdb.connect( host=self.host, database=self.db, user=self.user, password=self.passwd, role=self.role, charset=self.charset, **extra )
def connect(self, info): try: import kinterbasdb except: print "Missing Firebird support through kinterbasdb" return self.strDbms = 'firebird' self.version = info['version'] self.conn = kinterbasdb.connect( dsn='localhost:%s' % info['dbname'], user = info['user'], password = info['pass']) self.cursor = self.conn.cursor()
def connect(self): self.initConnection() if not self.hostname: self.checkFileDb() try: # Reference: http://www.daniweb.com/forums/thread248499.html self.connector = kinterbasdb.connect(host=self.hostname.encode(UNICODE_ENCODING), database=self.db.encode(UNICODE_ENCODING), user=self.user.encode(UNICODE_ENCODING), password=self.password.encode(UNICODE_ENCODING), charset="UTF8") except kinterbasdb.OperationalError as ex: raise SqlmapConnectionException(getSafeExString(ex)) self.initCursor() self.printConnected()
def test_fb(): cn = kinterbasdb.connect(dsn=DBNAME, user=DBUSER, password=DBPASS, charset=DBCHAR) cur = cn.cursor() cur.execute('''insert into ttest (id, c1, c2) values (3, 'xyz', 'abc');''') cur.execute('''insert into ttest (id, c1, c2) values (3, 'abc', 'xyz');''') cur.execute('''insert into ttest (id, c1, c2) values (3, 'bbb', 'aaa');''') cn.commit() cur.execute('''select * from ttest;''') for row in cur.fetchall(): print row cur.close() cn.close()
def Connect(self): # Считываем параметры соединения из текстовых полей вкладки Настройки user = str(self.lineEdit_2.text()) passw = str(self.lineEdit_3.text()) path = str(self.lineEdit.text()) try: # Подключаемся к базе con = kinterbasdb.connect(dsn=path, user=user, password=passw) except: self.lineEdit_4.setText(u"Не удалось подключиться к базе ") return False self.label_2.setText(u"Подключено") self.lineEdit_4.setText(u"Подключение к avto_db удалось.") return con
def execute(): source_id = 'ics.db' # logger logging.config.dictConfig(settings.LOG_CONF) root_logger = logging.getLogger('stat_ics_db_collector.entry_point') # source ics_db_conn_str = settings.ICS_DB_CONN_STR prepared_conn_str = dict(map(lambda k: (k, str(ics_db_conn_str[k])), ics_db_conn_str)) source_connect_factory = lambda: kinterbasdb.connect(**prepared_conn_str) # dest dest_db_conn_str = settings.DEST_DB_CONN_STR dest_storage = SqliteStorage(dest_db_conn_str, root_logger.getChild('dest_storage')) # collect_task collect_task_list = collect_task_def.collect_task_def # db source collect task task = DbSourceCollectTask(source_id, collect_task_list, source_connect_factory, dest_storage, root_logger) return task.execute()
def _connect(): global con, work_time, thTimeOut work_time = time.time(); if not con or con.closed: if DEBUG_LEVEL > 0: Log("Connect to DB:\t%s" % DB_PATH) try: lcTimeOut.acquire() con = fb.connect(dsn=DB_PATH, user=DB_USER, password=DB_PASSWD) lcTimeOut.release() if not thTimeOut.is_alive(): thTimeOut = threading.Thread(target=chTimeOut, name="chTimeOut") thTimeOut.start() except Exception as e: if type(e) == fb.OperationalError: Log("Connect DataBase:\t%s" % e[1], True) else: Log("Connect:\t%s" % e, True) raise
def _cursor(self): new_connection = False if self.connection is None: new_connection = True self.connection = Database.connect(**self.settings) connection_created.send(sender=self.__class__) cursor = self.connection.cursor() if new_connection: if self.connection.charset == 'UTF8': self.ops.FB_CHARSET_CODE = 4 # UTF-8 with Firebird 2.0+ self.connection.set_type_trans_in({ 'DATE': self.ops.conv_in_date, 'TIME': self.ops.conv_in_time, 'TIMESTAMP': self.ops.conv_in_timestamp, 'FIXED': self.ops.conv_in_fixed, 'TEXT': self.ops.conv_in_ascii, 'TEXT_UNICODE': self.ops.conv_in_unicode, 'BLOB': self.ops.conv_in_blob }) self.connection.set_type_trans_out({ 'DATE': typeconv_datetime.date_conv_out, 'TIME': typeconv_datetime.time_conv_out, 'TIMESTAMP': typeconv_datetime.timestamp_conv_out, 'FIXED': typeconv_fixeddecimal.fixed_conv_out_precise, 'TEXT': self.ops.conv_out_ascii, 'TEXT_UNICODE': typeconv_textunicode.unicode_conv_out, 'BLOB': self.ops.conv_out_blob }) version = re.search(r'\s(\d{1,2})\.(\d{1,2})', self.connection.server_version) self.server_version = tuple([int(x) for x in version.groups()]) # feature for Firebird version 2 and above if self.server_version[0] >=2: self.features.can_return_id_from_insert = True return CursorWrapper(cursor)
def _cursor(self): if self.connection is None: settings_dict = self.settings_dict if settings_dict["NAME"] == "": from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("You need to specify DATABASE_NAME in your Django settings file.") conn_params = {"charset": "UNICODE_FSS"} conn_params["dsn"] = settings_dict["NAME"] if settings_dict["HOST"]: conn_params["dsn"] = ("%s:%s") % (settings_dict["HOST"], conn_params["dsn"]) if settings_dict["PORT"]: conn_params["port"] = settings_dict["PORT"] if settings_dict["USER"]: conn_params["user"] = settings_dict["USER"] if settings_dict["PASSWORD"]: conn_params["password"] = settings_dict["PASSWORD"] conn_params.update(settings_dict["OPTIONS"]) self.connection = Database.connect(**conn_params) self._type_translator.set_charset(self.connection.charset) return FirebirdCursorWrapper(self.connection.cursor(), self._type_translator)
def __init__(self, ui, filename=None, dsn=None, host=None, user="******", pwd="masterkey"): SqlConnection.__init__(self, ui) self.dbapi = kinterbasdb self._user = user self._pwd = pwd if dsn is not None: assert host is None assert filename is None host, filename = dsn.split(':', 1) self._host = host if filename is None: self._filename = r"c:\temp\tmp.fdb" self._host = "localhost" if os.path.exists(self._filename): os.remove(self._filename) else: self._filename = filename if os.path.exists(filename): self._mtime = os.stat(filename).st_mtime self._status = self.CST_OPENED self._dbconn = kinterbasdb.connect(host=self._host, database=filename, user=self._user, password=self._pwd) self.setup_connection() return self._mtime = 0.0 self._dbconn = kinterbasdb.create_database( "create database '%s:%s' user '%s' password '%s'" % (self._host, self._filename, self._user, self._pwd)) self.setup_connection()
def __init__(self,ui, filename=None, dsn=None, host=None, user="******",pwd="masterkey"): SqlConnection.__init__(self,ui) self.dbapi = kinterbasdb self._user=user self._pwd=pwd if dsn is not None: assert host is None assert filename is None host,filename=dsn.split(':',1) self._host=host if filename is None: self._filename=r"c:\temp\tmp.fdb" self._host="localhost" if os.path.exists(self._filename): os.remove(self._filename) else: self._filename = filename if os.path.exists(filename): self._mtime = os.stat(filename).st_mtime self._status = self.CST_OPENED self._dbconn = kinterbasdb.connect( host=self._host, database=filename, user=self._user, password=self._pwd) self.setup_connection() return self._mtime = 0.0 self._dbconn = kinterbasdb.create_database( "create database '%s:%s' user '%s' password '%s'" % ( self._host,self._filename, self._user,self._pwd)) self.setup_connection()
def getConnection(connUser): """ Returns a database connection as defined by connUser. If this module already has an open connection for connUser, it returns it; otherwise, it creates a new connection, stores it, and returns it. """ if not _users.has_key(connUser): raise SkunkStandardError, 'user %s is not initialized' % (connUser) connectParams=_users[connUser] if not _connections.has_key(connUser): try: _connections[connUser] = kinterbasdb.connect(**connectParams) except kinterbasdb.Error: # XXX Do not raise the connect string! The trace may be seen # by users!!! raise SkunkStandardError, ('cannot connect to Firebird: %s' % (sys.exc_info()[1],)) return _connections[connUser]
def PegaListadoBanco(self): ''' Pega os dados do banco de dados e salva na listaProdutos ''' try: conn = kinterbasdb.connect(host="10.1.1.10", database='C:\SIACPlus\siacCX.fdb', user="******", password="******", charset="ISO8859_1") print "Conexão aberta" cur = conn.cursor() cur.execute( 'SELECT a.COD_PRODUTO, a.DESCRICAO, a.CODBARRAS, a.SALDOESTOQUE FROM ACADPROD a' ) print "Select executado" #print "Lista de Produtos: ", self.listadeProdutos # Pegando dados do select e salvando em lista produtos, no momento salvando com estoque zero for i in cur: (cod_prod, descr, codbarras, saldoestoque) = i self.adicionaProdutos(cod_prod, descr, codbarras, saldoestoque) print "Produtos adicionados a lista" # Fechando acesso ao banco conn.close() print "Conexão fechada" except: print "Erro ao acessar o banco" finally: print "Dados salvo com sucesso"
def __init__(self, **kw): """ This constructor supports all those key word parameters the kinterbas.connect() function supports: For details on any of these parameters see U{http://kinterbasdb.sourceforge.net/dist_docs/usage.html#tutorial_connect} @param dsn: A DSN pointing to the desired database @param user: Username @param password: The corresponding password @param host: The database host (if no DSN given) @param database: The database path (if no DSN given) @param charset: Charset for this connection. Unicode strings will be uncoding using this charset before they are sent to the database. Note that this requires a backend encoding name (see U{this site <http://www.firebirdsql.org/index.php?op=doc&id=fb_1_5_charsets&nosb=1>} for details. @param dialect: Chose the SQL dialect to use. This doesn't influence anything orm does (up to now). """ orm2.datasource.datasource_base.__init__(self) self._connection_spec = kw self._conn = kinterbasdb.connect(**kw) self._update_cursor = self._conn.cursor()
def doFirebird(self): global strSelect1, strSelect2, strInsertT1, strInsertT2 import kinterbasdb self.dbms = 'firebird' print kinterbasdb.paramstyle info = conn_info['firebird'] self.conn = kinterbasdb.connect( dsn='localhost:%s' % info['dbname'], user = info['user'], password = info['pass']) self.cursor = self.conn.cursor() strSelect1 = strSelect1.replace("%s", "?") strSelect2 = strSelect2.replace("%s", "?") strInsertT1 = strInsertT1.replace("%s", "?") strInsertT2 = strInsertT2.replace("%s", "?") self.doTests() strSelect1 = strSelect1.replace("?", "%s") strSelect2 = strSelect2.replace("?", "%s") strInsertT1 = strInsertT1.replace("?", "%s") strInsertT2 = strInsertT2.replace("?", "%s")
cfg = {} cfg['dsn'] = cfg_json['firebird']['dsn'].encode('latin-1') cfg['usr'] = cfg_json['firebird']['usr'].encode('latin-1') cfg['psw'] = cfg_json['firebird']['psw'].encode('latin-1') info = {} info['data_ini'] = cfg_json['datas']['ini'].encode('latin-1') info['data_fin'] = cfg_json['datas']['fin'].encode('latin-1') sefaz_doc = '' print "Configurações carregadas" # Conecta ao BD print "Conectado ao banco de dados..." con = kinterbasdb.connect(dsn=cfg['dsn'], user=cfg['usr'], password=cfg['psw']) print "Conexão estabelecida" # Bloco 0 # Linha 0000 print "Gerando Bloco 0..." l_0000 = open('templates/0000.txt').read(); l_0000 = l_0000.replace("{@data_inicial}", info['data_ini']).replace('/', '') l_0000 = l_0000.replace("{@data_final}", info['data_fin']).replace('/', '') print l_0000
import DNS import kinterbasdb DNS.AddNameServer('172.16.0.4') r = DNS.Request() con = kinterbasdb.connect(dsn="spider:/var/ib/swamp_test.gdb", user="******", password="******") cur = con.cursor() query = """ select * from s_computers """ cur.execute(query) for i in cur.fetchall(): name = i[4].lower() res = r.req('%s.swamp.lan' % name, qtype='A') if len(res.answers): print "%s\t%s" % (name, res.answers[0]['data']) pass else: print "%s [not found]" % name
def connect(self): self.con = kinterbasdb.connect(dsn='/home/gustavo/Documentos/LG3_7_TRS.FDB', user='******', password='******')
def main(): # get date print "\n\ +------------------------------------------+\n\ | |\n\ | MKU -> BIOS |\n\ | |\n\ +------------------------------------------+\n\ \n" print " DATE (01-31): ", rw_date = int(sys.stdin.readline(10)) print "MONTH (01-12): ", rw_month = int(sys.stdin.readline(10)) print "GOD (200?) : ", rw_year = int(sys.stdin.readline(10)) print rw_year, "-", rw_month, "-", rw_date # create firebird connection con = fb.connect(dsn='%s:%s' % (FB_HOST, FB_DB), user=FB_USER, password=FB_PASS) cur = con.cursor() # query cur.execute("select number, rwdate, wei, pos, cert, a from vagons\ where a is not null and wei is not null and\ pos is not null and cert is not null and number is not null and\ rwdate='%4d-%2d-%2d'" % (rw_year, rw_month, rw_date)) # create new dbf dn = dbf_new() dn.add_field("N_VAG", 'C', 8) dn.add_field("DATA", 'D', 8) dn.add_field("KOL_R", 'N', 8, 2) dn.add_field("N_POZ", 'C', 7) dn.add_field("N_UD", 'C', 5) dn.add_field("AN_ZOL", 'N', 5, 2) dn.write(DBF_FILE) d = Dbf() d.openFile(DBF_FILE, readOnly=0) #d.reportOn() print for row in cur: #print row # add a record rec = DbfRecord(d) rec['N_VAG'] = str(row[0]) rec['DATA'] = row[1].timetuple() rec['KOL_R'] = float(row[2]) rec['N_POZ'] = "% 7s" % str(row[3]) rec['N_UD'] = "% 5s" % str(row[4]) rec['AN_ZOL'] = float(row[5]) rec.store() #print row[0], row[1], row[2], row[3], row[4], row[5] print rec['N_VAG'], rec['DATA'], rec['KOL_R'], rec['N_POZ'], rec[ 'N_UD'], rec['AN_ZOL'] print "Records exported: ", d.recordCount() print d.close() # save to floppy print "Insert disk in floppy drive and press enter" sys.stdin.readline() copyfile(DBF_FILE, "c://%s" % DBF_FILE) print "Ready" time.sleep(3)
#importamos a lib de acesso import kinterbasdb #instalar o driver - download firebirdsql.org #conectamos ao banco de dados con = kinterbasdb.connect(dsn='localhost:c:/meubanco.fdb', user='******', password='******') #buscamos o cursor cursor = con.cursor() #select para listar o nome de todos os clientes cadastrados sql = 'SELECT NOME FROM CLIENTES ORDER BY NOME' #executamos o select cursor.execute(sql) #percorremos todos os registros mostrando o nome retornado for pessoa in cursor.fetchall(): print pessoa[0] #o índice aqui refere-se ao campo retornado. Como somente retornamos o nome existe apenas um campo retornado. O índice começa em zero. #se o select retornasse mais dados, como NOME, ENDERECO, TELEFONE, por exemplo, o endereco seria pessoa[1] e o telefone pessoa[2] #depois de retornarmos os dados, fechamos a conexão con.close()
#!/usr/bin/python #coding: utf-8 import kinterbasdb con = kinterbasdb.connect(dsn='localhost:temp/cds.fdb', user='******', password='******') cur = con.cursor() sql = "create table cds("\ "nome varchar(20),"\ "artista varchar(20)"\ "ano integer, "\ "faixas integer,"\ "primary key(nome, artista, ano));" #cria uma tabela cur.execute(sql) con.commit() dados = [ ('IV', 'Led Zeppelin', 1971, 8), ('Zenyatta Mondatta', 'The Police', 1980, 11), ('OK Computer', 'Radio Head', 1997, 12), ('In Absentia', 'Porcupine Tree', 2002, 12), ] #insere resultados e faz interpolacao insert = "insert into cds"\
import kinterbasdb # The server is named 'bison'; the database file is at '/temp/test.db'. con = kinterbasdb.connect(dsn='bison:/temp/test.db', user='******', password='******') # Or, equivalently: con = kinterbasdb.connect(host='bison', database='/temp/test.db', user='******', password='******')
# SQlite con2 = sqlite.connect('nome do arquivo', mode=775) # mode define o modo de trabalho # PostgreSQL con3 = PgSQL.connect( host = 'servidor', database = 'banco de dados', user = '******' password = '******' ) # Interbase / Firebird con4 = kinterbasdb.connect( dsn = 'servidor:/path/arquivo.fdb', user = '******', password = '******' ) # MS-SQL con5 = pymssql.connect( host = 'servidor', user = '******', password = '******', database = 'base de dados' # nome do banco ) # Oracle database con6 = cx_Oracle.connect('usuario/senha@tnsname')
self.State='COMPLIT' newState='END' return (newState, val) def error(self,val): self.db.rollback() print 'ERROR' self.State='ERROR' newState='End' return (newState, val) def create_state(self,m): m.add_state('READ_LINE', self.get_line) #, 'TERM','EXT_TERM','COMMIT','SKIP' m.add_state('CLEAN_REM', self.clean_leades_rem) m.add_state('TERM', self.get_term) m.add_state('EX_TERM', self.get_ex_term) m.add_state('EXEC_SQL',self.exec_SQL) m.add_state('COMMIT',self.commit) m.add_state('ERROR',self.error) m.add_state('END',None,end_state=1) m.set_start('READ_LINE') if __name__== "__main__": mydb=kdb.connect(dsn='platon_svn',user='******', password='******',dialect=3, charset='UTF8' ) input_file=os.path.dirname(__file__)+'\\indexer.sql' output_file=os.path.dirname(__file__)+'\\out.sql' parser=ParserScript(mydb,input_file,output_file) parser.run() print parser.State
t2 = time.time() cur.execute("select * from test where date_ins between 17250101 and 17441231") t3 = time.time() print "Tempo estrazione dati dal 01/01/1725 al 31/12/1744: %f" % (t3 - t2) t4 = time.time() cur.execute("select * from test where date_ins between 17250101 and 18241231") t5 = time.time() print "Tempo estrazione dati dal 01/01/1725 al 31/12/1824 %f" % (t5 - t4) t6 = time.time() cur.execute("select * from test where date_ins between 17250101 and 19241231") t7 = time.time() print "Tempo estrazione dati dal 01/01/1725 al 31/12/1924 %f" % (t7 - t6) cur.close() if __name__ == "__main__": print "Inizio test" con = db.connect(host="localhost", database="test.fdb", user="******", password="******") print "Inserimento dati" insert_data(con.cursor()) print "Esecuzione query" query_data(con.cursor()) print "Fine test" con.close()
def _destroy_test_db(self, test_database_name, verbosity): connection = Database.connect(**self._get_connection_params(database=test_database_name)) connection.drop_database() connection.close()
import DNS import kinterbasdb DNS.AddNameServer('172.16.0.4') r=DNS.Request() con = kinterbasdb.connect( dsn="spider:/var/ib/swamp_test.gdb", user="******", password="******" ) cur = con.cursor() query = """ select * from s_computers """ cur.execute(query) for i in cur.fetchall(): name = i[4].lower() res = r.req('%s.swamp.lan' % name ,qtype='A') if len(res.answers): print "%s\t%s" % (name, res.answers[0]['data']) pass else: print "%s [not found]" % name
def connect(self): self._db = kinterbasdb.connect(dsn=self._bdd, user=self._user, password=self._password, charset=self._charset)
from pysqlite2 import dbapi2 as sqlite con = sqlite.connect('adoradores.sqlite') version = FullVersionBuilder(SQLite, connection=con, version_number=1) version.export_to_file('version1.py') if CASE_4: print 'Full Version generating from Firebird database...' import kinterbasdb con = kinterbasdb.connect( host='localhost', database='phonus', user='******', password='******', dialect=3, charset='ISO88591', ) version = FullVersionBuilder(Firebird, connection=con, version_number=1) version.export_to_file('version1.py') if CASE_5: print 'Parsing:', versions_path import kinterbasdb con = kinterbasdb.connect( host='localhost', database='phonus_teste',
def connect(self): if self.dbObject != None: raise Exception("Firebird: already connected to %s" % self.db) self.dbObject = kinterbasdb.connect(dsn=self.db, user=self.user, password=self.password, charset=self.charset)