[Hiki] create - tut-libgda-full-example (ruby-gnome2-doc-cvs) - Ruby-GNOME2

-------------------------
REMOTE_ADDR = 151.24.189.115
REMOTE_HOST = 
        URL = http://ruby-gnome2.sourceforge.jp/it?tut-libgda-full-example
-------------------------
= Tutorial Ruby/Libgda: Esempio Completo

L'esempio seguente stato provato con il provider GDA per MySQL , con  un 
((< server MySQL |URL:http://www.mysql.com>)) 4.1.0.

Dovrebbe funzionare con altri provider GDA.  Ad esempio, 
l'((<esempio originale in C|URL:http://www.gnome-db.org/docs/libgda/main_example.html>)) 
stato scritto per essere uato con il provider per PostgreSQL.

== SQL

Questo lo schema per MySQL necessario a far girare l'esempio:

  -- definizioni SQL delle tabelle necessarie per sample.rb.

  drop table if exists clienti;
  create table clienti (
      riferimento int unsigned not null auto_increment primary key,
      nome varchar(50),
      cognome varchar(50),
      telefono varchar(50)
  );

  drop table if exists conti;
  create table conti (
      riferimento int unsigned not null auto_increment primary key,
      riferimento_cliente int unsigned references clienti(riferimento),
      saldo int 
  );

Usate semplicemente il comando source dela console mysql per creare questo schema :

  % mysql -u tuo_utente -p -h hostname_del_server
  [...]
  mysql> use il_database;
  mysql> source esempio.sql;

== Ruby

E questo il codice Ruby.  Avrete bisogno di modificare il metodo salva_ds se volete far funzionare questo esempio.

  require 'libgda'

  def elenca_datasource
      Gda::DataSource.each do |ds|
          puts "NOME: '#{ds.name}', PROVIDER: '#{ds.provider}', CNC: '#{ds.cnc_string}', " \
               "UTENTE: '#{ds.username}', PASSWORD: '#{ds.password}'."
      end
  end

  def elenca_provider
      Gda::Provider.each { |provider| puts "ID: '#{provider.prov_id}'." }
  end

  def salva_ds
      ds = Gda::DataSource.new("arrakis", 
                               "MySQL", 
                               "DATABASE=pinux;HOST=192.168.1.1",
                               "connessione MySQL ad arrakis per utente pinux", 
                               "pinux", "pinux ＠ arrakis")
      ds.save
  end

  def rimuovi_ds
      Gda::DataSource.find("arrakis").remove
  end

  def mostra_errori(conn)
      # Ottiene la lista d'errori ed effettua un ciclo per leggere le informazioni.
      conn.errors.each do |error|
          puts "Errore numero: #{error.number.to_s}"
          puts "Descrizione: #{error.description}"
          puts "Sorgente: #{error.source}"
          puts "Stato SQL: #{error.sqlstate}"
      end
  end

  def mostra_tabella(dm)
      dm.each_column { |titolo| puts titolo }
      puts ""
      dm.each_row { |riga| riga.each_value { |val| puts val.to_s } }
  end

  def crea_comando(testo)
      Gda::Command.new(testo, 
                       Gda::Command::TYPE_SQL, 
                       Gda::Command::OPTION_STOP_ON_ERRORS)
  end

  def esegui_sql_non_query(conn, testo)
      comando = crea_comando(testo)
      conn.execute_non_query(comando)
  end

  def esegui_sql_comando(conn, testo)
      comando = crea_comando(testo)
      array = conn.esegui_comando(comando)
      array.each { |datamodel| mostra_tabella(datamodel) }
  end

  def esegui_piu_query(conn)
      esegui_sql_non_query(conn, "DELETE FROM clienti")
      esegui_sql_non_query(conn, "INSERT INTO clienti (riferimento,nome,cognome,telefono)"\
                                 "VALUES (1, 'Linus', 'Torvalds', '264-85529-23');" \
                                 "INSERT INTO clienti(riferimento,nome,cognome,telefono)"\
                                 "VALUES (2, 'Alan', 'Cox', '05-564791235416');")
      esegui_sql_non_query(conn, "DELETE FROM conti;" \
                                  "INSERT INTO conti (riferimento_cliente, saldo) " \
                                  "VALUES (1, 1000);" \
                                  "INSERT INTO conti (riferimento_cliente, saldo) " \
                                  "VALUES (2, 5000);")
      esegui_sql_comando(conn, "SELECT * FROM cliente;" \
                                "SELECT * FROM conto") 
  end

  def processa_conti(conn)
      # Crea la prima transazione.
      transazione_uno = Gda::Transaction.new("conto1")
      # Cambia il livello di isolamento.
      transazione_uno.isolation_level = Gda::Transaction::ISOLATION_SERIALIZABLE
      # La collega alla connessione.
      conn.begin_transaction(transazione_uno)

      comando = Gda::Command.new("UPDATE conti SET saldo=saldo+50 WHERE riferimento_cliente=1",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      # Collega il comando alla transazione.
      comando.transaction = transazione_uno
      conn.execute_non_query(comando)

      comando = Gda::Command.new("UPDATE conti SET saldo=saldo-50 WHERE riferimento_cliente=2",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      comando.transaction = transazione_uno
      conn.execute_non_query(comando)

      # Effettua il commit sulla transazione.
      conn.commit_transaction(transazione_uno)

      transazione_due = Gda::Transaction.new("conto2")

      transazione_due.isolation_level = Gda::Transaction::ISOLATION_SERIALIZABLE
      conn.begin_transaction(transazione_due)

      comando = Gda::Command.new("UPDATE conti SET saldo=saldo+400 WHERE riferimento_cliente=1",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      comando.transaction = transazione_due
      conn.execute_non_query(comando)

      comando = Gda::Command.new("UPDATE conti SET saldo=saldo-400 WHERE riferimento_clienti=2",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      comando.transaction = transazione_due
      conn.execute_non_query(comando)

      # Effettua il rollback sulla seconda transazione.
      conn.rollback_transaction(transazione_due)

      esegui_sql_comando(conn, "SELECT * FROM conti")
  end

  Gda.init("TestGDA", "0.1")
  salva_ds
  Gda.main do
      elenca_provider
      elenca_datasource
      client = Gda::Client.new
      client.open_connection("arrakis", nil, nil) do |conn|
          conn.signal_connect('error') { mostra_errori(conn) }
          esegui_piu_query(conn)
          processa_conti(conn)   
      end
      rimuovi_ds
  end

Ruby-GNOME2

[ruby-gnome2-doc-cvs] [Hiki] create - tut-libgda-full-example