accesso al database Rubino - DBI Tutorial

architettura applicativa DBI

DBI indipendente da qualsiasi database disponibile in background. Sia che si sta utilizzando Oracle, MySQL, Informix, è possibile utilizzare la DBI. La seguente tabella illustra chiaramente questo punto.

architettura generale rubino DBI utilizza due strati:

• Interfaccia Database (DBI) strato. Questo strato è indipendente dal database e fornisce una serie di metodo di accesso pubblico, utilizzando un server di database, indipendentemente dal tipo di approccio.
• driver di database (DBD) strato. Questo strato dipende dal database, una diversa unità fornisce accesso a diversi motori di database. MySQL, PostgreSQL,, InterBase, Oracle, rispettivamente, utilizzando una diversa unità. Ogni conducente è responsabile per interpretare le richieste del livello di DBI, e queste richieste vengono mappati da applicare a una richiesta di un determinato tipo di server di database.

installare

Se si desidera scrivere script Ruby per accedere al database MySQL, è necessario installare il modulo di Ruby MySQL.

Kit di installazione Mysql Sviluppo

# Ubuntu
sudo apt-get install mysql-client
sudo apt-get install libmysqlclient15-dev

# Centos
yum install mysql-devel

Mac OS, è necessario modificare ~ / .bash_profile o file ~ / .profile, aggiungere il seguente codice:

MYSQL=/usr/local/mysql/bin
export PATH=$PATH:$MYSQL
export DYLD_LIBRARY_PATH=/usr/local/mysql/lib:$DYLD_LIBRARY_PATH

Oppure utilizzare la connessione morbido:

sudo ln -s /usr/local/mysql/lib/libmysqlclient.18.dylib /usr/lib/libmysqlclient.18.dylib

Utilizzare RubyGems installare DBI (consigliato)

RubyGems circa fondata nel novembre 2003, entrò a far parte della libreria standard di Ruby da Ruby 1.9 versione. Maggiori dettagli possono essere visualizzate: Ruby RubyGems

Utilizzare gem install DBI e DBD-mysql:

sudo gem install dbi
sudo gem install mysql
sudo gem install dbd-mysql

installazione Utilizzare Codice (versione di Ruby meno di 1.9 per utilizzare questo metodo)

Il modulo è un DBD, da http://tmtm.org/downloads/mysql/ruby/ download.

Dopo aver scaricato l'ultimo pacchetto, decomprimere nella directory, eseguire il seguente comando per installare:

% ruby extconf.rb

或者

% ruby extconf.rb --with-mysql-dir=/usr/local/mysql

或者

% ruby extconf.rb --with-mysql-config

Quindi compilare:

% make

Ottenere e installare Ruby / DBI

È possibile scaricare e installare il modulo di Ruby DBI dal seguente link:

Prima di iniziare l'installazione, assicurarsi di avere i privilegi di root. Ora, installare i seguenti passaggi per installare:

fase 1

git clone https://github.com/erikh/ruby-dbi.git

O direttamente sotto un altro compressione e decompressione.

fase 2

Inserire la directoryruby-DBI-master,utilizzare script di configurazionesetup.rbnella directory. I comandi di configurazione più comuni non sono seguiti da eventuali parametri di configurazione dei parametri. Il comando di configurazione di default per installare tutti i driver.

$ ruby setup.rb config

Più in particolare, è possibile utilizzare l'opzione --with per elencare la parte specifica che si desidera utilizzare. Ad esempio, se si desidera configurare il modulo DBI principale e l'unità strato di MySQL DBD, digitare il seguente comando:

$ ruby setup.rb config --with=dbi,dbd_mysql

fase 3

L'ultimo passo è quello di creare l'unità, utilizzare il seguente comando per installare:

$ ruby setup.rb setup
$ ruby setup.rb install

Database Connectivity

Supponiamo che stiamo usando il database MySQL prima connessione al database, assicurarsi che:

• È stato creato un database di TESTDB.
• È stato creato il DIPENDENTE tavolo in TESTDB.
• La tabella con un campo FIRST_NAME, LAST_NAME, età, sesso e reddito.
• Impostare ID utente "testuser" e la "test123" password per accedere TESTDB
• Già sul computer è installato correttamente il modulo di Ruby DBI.
• Hai visto MySQL tutorial, la comprensione del MySQL operativo sottostante.

I seguenti sono esempi di MySQL connessione al database "TESTDB" di:

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     # 获取服务器版本字符串，并显示
     row = dbh.select_one("SELECT VERSION()")
     puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Quando si esegue questo script, produrrà i seguenti risultati su una macchina Linux.

Server version: 5.0.45

Se si stabilisce una connessione con una fonte di dati, la maniglia del database restituita (maniglia database), e salvatol'dbh per un utilizzo successivo, o dbhverrà impostato suvalore nullo,e.err ede :: errstrrestituire il codice di errore e l'errore stringa.

Infine, prima di uscire questo programma, assicurarsi di chiudere la connessione al database, il rilascio di risorse.

operazione INSERT

Quando si desidera creare un record in una tabella del database, è necessario utilizzare operazione di inserimento.

Una volta che una connessione al database, siamo pronti per creare una tabella o inserire dati nella tabella per creare un metodo di registrazione usando undo o preparareedeseguiremetodi.

Usa do istruzione

La dichiarazione non restituisce righe chiamandofare metodi di lavorazione del database.Questo metodo richiede un parametro di stringa dichiarazione e restituisce il numero di righe interessate dall'istruzione.

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
     FIRST_NAME  CHAR(20) NOT NULL,
     LAST_NAME  CHAR(20),
     AGE INT,  
     SEX CHAR(1),
     INCOME FLOAT )" );

Allo stesso modo, è possibileeseguireun'istruzione SQLINSERTper creare record nella tabella DIPENDENTE.

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME,
                   LAST_NAME, 
                   AGE, 
         SEX, 
         INCOME)
          VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
     puts "Record has been created"
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Utilizzandopreparareedeseguire

È possibile utilizzare il metodo di DBIpreparareedeseguireper eseguire Rubino istruzioni di codice SQL.

Per creare un record come segue:

• SQL preparata con l'istruzione INSERT. Ciò verrà realizzato attraverso l'uso metodo dipreparazione.
• Esegui query SQL, selezionare tutti i risultati dal database. Ciò verrà realizzato utilizzandoil metodo di esecuzione.
• Rilasciare l'handle di istruzione. Ciò verrà realizzato attraverso l'uso difinitura API.
• Se tutto va bene, allora l'operazione dicommit, oppure è possibile completare il rollbackdelletransazioni.

Ecco la sintassi di questi due metodi:

sth = dbh.prepare(statement)
sth.execute
   ... zero or more SQL operations ...
sth.finish

Entrambi i metodi possono essere utilizzati perassociare un valore da passare istruzioni SQL.A volte il valore viene inserito non può essere dato in anticipo, in questo caso, viene utilizzato per legare valori. Utilizzare un punto interrogativo(?) Al posto del valore effettivo, il valore effettivo di passare attraverso execute () API.

L'esempio seguente crea due record nella tabella DIPENDENTE:

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME,
                   LAST_NAME, 
                   AGE, 
         SEX, 
         INCOME)
                   VALUES (?, ?, ?, ?, ?)" )
     sth.execute('John', 'Poul', 25, 'M', 2300)
     sth.execute('Zara', 'Ali', 17, 'F', 1000)
     sth.finish
     dbh.commit
     puts "Record has been created"
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Se si usa inserire più, quindi prima di preparare una dichiarazione, e quindi eseguire più volte in un ciclo attraverso ogni ciclo di quello che chiama fare molto più efficiente.

operazione LEGGI

un'operazione di lettura su qualsiasi database si riferisce a ottenere informazioni utili dal database.

Una volta che una connessione al database, siamo pronti per interrogare il database. Possiamo usare un metodo o unacosa prepararee metodoexecuteper ottenere il valore da una tabella del database.

Get passo registrata come segue:

• In base alle condizioni richieste per la preparazione di query SQL. Ciò verrà realizzato attraverso l'uso metodo dipreparazione.
• Esegui query SQL, selezionare tutti i risultati dal database. Ciò verrà realizzato utilizzandoil metodo di esecuzione.
• Uno dopo l'altro per ottenere risultati, e le uscite i risultati. Ciò verrà realizzato attraverso l'uso direcuperare metodi.
• Rilasciare l'handle di istruzione. Ciò verrà realizzato attraverso l'uso di metodidi finitura.

La seguente query di esempio tutto retribuzione (stipendio) ha registrato più di 1.000 dal tavolo DIPENDENTE.

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     sth = dbh.prepare("SELECT * FROM EMPLOYEE 
                        WHERE INCOME > ?")
     sth.execute(1000)

     sth.fetch do |row|
        printf "First Name: %s, Last Name : %s\n", row[0], row[1]
        printf "Age: %d, Sex : %s\n", row[2], row[3]
        printf "Salary :%d \n\n", row[4]
     end
     sth.finish
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Questo produce i seguenti risultati:

First Name: Mac, Last Name : Mohan
Age: 20, Sex : M
Salary :2000

First Name: John, Last Name : Poul
Age: 25, Sex : M
Salary :2300

Ci sono molti metodi per ottenere record dal database, se siete interessati, è possibile visualizzare il funzionamento di Ruby DBI Leggi .

operazione di aggiornamento

Qualsiasi operazione aggiornamento del database si riferisce a uno o più database di aggiornare i record esistenti. Il seguente esempio aggiorna EROTICHE 'M' per tutti i record. Qui, aggiungeremo un anno tutti i maschi di età. Sarà diviso in tre fasi:

• In base alle condizioni richieste per la preparazione di query SQL. Ciò verrà realizzato attraverso l'uso metodo dipreparazione.
• Esegui query SQL, selezionare tutti i risultati dal database. Ciò verrà realizzato utilizzandoil metodo di esecuzione.
• Rilasciare l'handle di istruzione. Ciò verrà realizzato attraverso l'uso di metodidi finitura.
• Se tutto va bene, allora l'operazione dicommit, oppure è possibile completare il rollbackdelletransazioni.

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1
                        WHERE SEX = ?")
     sth.execute('M')
     sth.finish
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

un'operazione DELETE

Quando si desidera eliminare i record dal database, è necessario utilizzare l'operazione di eliminazione. Gli esempi che seguono eliminare AGE 20 su tutti i record del dipendente. I passi operativi sono i seguenti:

• In base alle condizioni richieste per la preparazione di query SQL. Ciò verrà realizzato attraverso l'uso metodo dipreparazione.
• Eseguire query SQL, eliminare i record desiderati dal database. Ciò verrà realizzato utilizzandoil metodo di esecuzione.
• Rilasciare l'handle di istruzione. Ciò verrà realizzato attraverso l'uso di metodidi finitura.
• Se tutto va bene, allora l'operazione dicommit, oppure è possibile completare il rollbackdelletransazioni.

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     sth = dbh.prepare("DELETE FROM EMPLOYEE 
                        WHERE AGE > ?")
     sth.execute(20)
     sth.finish
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

affari esecutivi

Una transazione è un meccanismo per garantire la coerenza delle transazioni. I servizi dovrebbero avere le seguenti quattro caratteristiche:

• Atomicity (Atomicity): atomicità della transazione significa che il programma è incluso nella transazione come unità logica del database di lavoro, fa le operazioni di modifica dei dati o tutti eseguiti o meno affatto.
• La coerenza (coerenza): operazione coerenza si riferisce ad una transazione eseguita prima e dopo la realizzazione del database deve essere in uno stato coerente.Se lo stato del database soddisfa tutti i vincoli di integrità, dire il database è coerente.
• Isolation (Isolamento): isolamento delle transazioni si riferisce alle transazioni concorrenti sono isolati gli uni dagli altri, cioè, all'interno di una transazione di dati di funzionamento e di gestione devono essere sigillato, non si vede gli altri tentativi di modificare la transazione.
• Persistente (Durata): durata della transazione significa che quando un sistema o di supporto fallimento, impegna le operazioni per garantire che gli aggiornamenti non possono essere persi.Che una volta una transazione commit, modificare i propri dati nel database dovrebbe essere permanente, sopportare qualsiasi guasto del sistema di database. Persistente garantita da backup e ripristino del database.

DBI fornisce due metodi per effettuare la transazione. Uno è ilcommitorollbackmetodi per commettere o rollback della transazione. Vi è anche un metodotransazionepuò essere utilizzato per realizzare l'operazione. Successivo introduciamo due metodo semplice di transazioni attuazione:

Metodo I

Il primo metodo utilizzacommiterollbackmetodi di DBI per commettere o annullare la transazione in modo esplicito:

   dbh['AutoCommit'] = false # 设置自动提交为 false.
   begin
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'John'")
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'Zara'")
     dbh.commit
   rescue
     puts "transaction failed"
     dbh.rollback
   end
   dbh['AutoCommit'] = true

metodo II

Il secondo metodo utilizza il metodo ditransazione.Questo metodo è relativamente semplice, perché richiede una operazione costituisce un blocco di codice contenente economico.ilmetodo ditransazioneesegue il blocco, e poi il blocco viene eseguito con successo, invocare automaticamentecommitorollback:

   dbh['AutoCommit'] = false # 设置自动提交为 false
   dbh.transaction do |dbh|
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'John'")
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'Zara'")
   end
   dbh['AutoCommit'] = true

COMMIT operazione

Commit è un operazione è stata completata per identificare le modifiche del database, e dopo questa operazione, tutte le modifiche non sono ripetibili.

Ecco un semplice esempiocommettere chiamata di metodo.

     dbh.commit

operazione di rollback

Se non sei soddisfatto con uno o pochi cambiamenti, si desidera ripristinare completamente queste modifiche, utilizzare il metododi rollback.

Ecco un semplice esempio di chiamata di metodorollback.

     dbh.rollback

Scollegare il database

Per disconnettere dal database, utilizzare l'API di disconnessione.

    dbh.disconnect

Se l'utente chiude il metodo di disconnessione connessione al database, DBI rollback tutte le transazioni incomplete. Tuttavia, non si basa sui dettagli di implementazione di qualsiasi DBI, e l'applicazione può essere una buona chiamata esplicita a commettere o rollback.

errore di elaborazione

Ci sono molte fonti diverse di errore. Ad esempio, gli errori di sintassi nella realizzazione di SQL o la connessione non riesce, o è una dichiarazione completa o una maniglia chiamate annullate metodo recupero.

Se un metodo non riesce DBI, DBI un'eccezione. Metodo DBI può lanciare qualsiasi tipo di eccezione, ma i due più importanti classe eccezione èDBI :: InterfaceErroreDBI :: DatabaseError.

oggetti eccezione di queste classi sonoerr,errstr tre attributi e lostato,sub-tabella rappresenta il numero di errore, una stringa di errore descrittivo e un codice di errore standard. Attributo specificato come segue:

• err: restituisce un errore intero che si è verificato la notazione, se DBD non supporta il ritorno pari azero.Ad esempio, Oracle DBD Restituisce sezione messaggio di errore ORA-XXXX.
• errstr: Restituisce una stringa che rappresenta l'errore che si è verificato.
• Stato: restituisce si è verificato il codice di errore SQLSTATE.SQLSTATE è una lunghezza stringa di cinque caratteri. La maggior parte del DBD non lo supporta, verrà restituito zero.

Nel precedente esempio, avete visto il codice seguente:

rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Per ottenere le informazioni di debug sul contenuto dello script viene eseguito quando si esegue lo script, è possibile attivare l'analisi. Per fare questo, è necessario prima scaricare il modulo DBI / traccia, e quindi chiamare il monitoraggio modalità di controllo e di metodo di uscita destinazionetraccia:

require "dbi/trace"
..............

trace(mode, destination)

modalità valore può essere 0 (off), 1,2 o 3, il valore della destinazione deve essere un oggetto IO. I valori predefiniti sono 2 e STDERR.

metodo di blocco

Ci sono modi per creare una maniglia. Questi metodi sono invocati dal blocco di codice. I vantaggi di utilizzare blocchi di codice con il metodo è che essi forniscono una maniglia per il blocco come argomento quando il blocco termina maniglia eliminato automaticamente. Ecco alcuni esempi per aiutare a capire questo concetto.

• DBI.connect: Questo metodo genera un gestore del database, si consiglia alla fine delsezionatoreblocco chiamata per scollegare il database.
• dbh.prepare: Questo metodo genera un handle di istruzione, raccomanda chiamandofinituraalla fine del blocco.All'interno di un blocco, è necessario chiamare il metodoexecuteper eseguire l'istruzione.
• dbh.execute: Questo metodo è simile a dbh.prepare, ma non dbh.execute bisogno di chiamare il metodo eseguire all'interno del blocco.Una maniglia istruzione viene eseguita automaticamente.

esempio 1

DBI.connect può avere un blocco di codice, passando la maniglia database e la maniglia viene automaticamente scollegare alla fine del blocco.

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                  "testuser", "test123") do |dbh|

esempio 2

dbh.prepare può avere un blocco di codice, passando l'handle di istruzione, e chiama automaticamente finitura alla fine del blocco.

dbh.prepare("SHOW DATABASES") do |sth|
       sth.execute
       puts "Databases: " + sth.fetch_all.join(", ")
end

esempio 3

dbh.execute può avere un blocco di codice, passando l'handle di istruzione, e chiama automaticamente finitura alla fine del blocco.

dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

metodo di transazioneDBIpuò anche essere dotato di un blocco di codice, che nelle sezioni precedenti hanno spiegato prima.

funzioni e proprietà specifiche del driver

Lasciate driver di database DBI fornisce ulteriori funzioni di database specifico, queste funzioni possono essere chiamati da qualsiasi oggetto metodo maniglia utentefunc.

Usare[] = o ilmetodo[]per impostare o ottenere gli attributi driver specifici.

DBD :: MySQL implementa la funzione a seguito di un driver specifico:

Esempi

#!/usr/bin/ruby

require "dbi"
begin
   # 连接到 MySQL 服务器
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123") 
   puts dbh.func(:client_info)
   puts dbh.func(:client_version)
   puts dbh.func(:host_info)
   puts dbh.func(:proto_info)
   puts dbh.func(:server_info)
   puts dbh.func(:thread_id)
   puts dbh.func(:stat)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

Questo produce i seguenti risultati:

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860