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

-------------------------
REMOTE_ADDR = 200.216.145.78
REMOTE_HOST = 
        URL = http://ruby-gnome2.sourceforge.jp/pt_BR/?tut-libgda-full-example
-------------------------
= Tutorial de Ruby/Libgda: Exemplo Completo
{{link("tut-libgda-errors", nil, "tut-libgda", nil)}}

O exemplo a seguir foi testado usando o provedor de MySQL da GDA, usando a vers縊 4.1.0 do ((<servidor MySQL |URL:http://www.mysql.com>)).

Ele deve funcionar com outros provedores GDA. For exemplo, o ((<exemplo original de C|URL:http://www.gnome-db.org/docs/libgda/main_example.html>)) foi criado para ser usado com o provedor de PostgreSQL.

== SQL

Eis o o schema de MySQL exigido, necess疵io para rodar o exemplo:

  -- SQL definitions of tables needed by sample.rb.

  drop table if exists customers;
  create table customers (
      ref int unsigned not null auto_increment primary key,
      name varchar(50),
      surname varchar(50),
      phone varchar(50)
  );

  drop table if exists accounts;
  create table accounts (
      ref int unsigned not null auto_increment primary key,
      ref_customer int unsigned references customers(ref),
      balance int 
  );

Apenas use o comando de fonte ("source command") do console do mysql para configurar o schema:

  % mysql -u your_username -p -h hostname_of_server
  [...]
  mysql> use the_database;
  mysql> source sample.sql;

== Ruby

E aqui esto cigo de Ruby. Vocprecisarmodificar o m騁odo save_ds se vocplaneja executar o exemplo.

  require 'libgda'

  def list_datasources
      Gda::DataSource.each do |ds|
          puts "NOME: '#{ds.name}', PROVEDOR: '#{ds.provider}', CNC: '#{ds.cnc_string}', " \
               "USU倉IO: '#{ds.username}', SENHA: '#{ds.password}'."
      end
  end

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

  def save_ds
      ds = Gda::DataSource.new("arrakis", 
                               "MySQL", 
                               "DATABASE=pinux;HOST=192.168.1.1",
                               "MySQL connection to arrakis for user pinux", 
                               "pinux", "pinux ＠ arrakis")
      ds.save
  end

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

  def show_errors(conn)
      # Obtem lista de erros e faz um loop para pegar as informa苺es de erro.
      conn.errors.each do |error|
          puts "No. do Erro: #{error.number.to_s}"
          puts "Descri艫o: #{error.description}"
          puts "Fonte: #{error.source}"
          puts "Estado da SQL: #{error.sqlstate}"
      end
  end

  def show_table(dm)
      dm.each_column { |title| puts title }
      puts ""
      dm.each_row { |row| row.each_value { |val| puts val.to_s } }
  end

  def create_command(text)
      Gda::Command.new(text, 
                       Gda::Command::TYPE_SQL, 
                       Gda::Command::OPTION_STOP_ON_ERRORS)
  end

  def execute_sql_non_query(conn, text)
      command = create_command(text)
      conn.execute_non_query(command)
  end

  def execute_sql_command(conn, text)
      command = create_command(text)
      array = conn.execute_command(command)
      array.each { |datamodel| show_table(datamodel) }
  end

  def execute_some_queries(conn)
      execute_sql_non_query(conn, "DELETE FROM customers")
      execute_sql_non_query(conn, "INSERT INTO customers (ref, name, surname, phone) " \
                                  "VALUES (1, 'Linus', 'Torvalds', '264-85529-23');" \
                                  "INSERT INTO customers (ref, name, surname, phone) " \
                                  "VALUES (2, 'Alan', 'Cox', '05-564791235416');")
      execute_sql_non_query(conn, "DELETE FROM accounts;" \
                                  "INSERT INTO accounts (ref_customer, balance) " \
                                  "VALUES (1, 1000);" \
                                  "INSERT INTO accounts (ref_customer, balance) " \
                                  "VALUES (2, 5000);")
      execute_sql_command(conn, "SELECT * FROM customers;" \
                                "SELECT * FROM accounts") 
  end

  def process_accounts(conn)
      # Cria a primeira transa艫o.
      transaction_one = Gda::Transaction.new("accounts1")
      # Altera o n逍el de isolamento.
      transaction_one.isolation_level = Gda::Transaction::ISOLATION_SERIALIZABLE
      # Liga-a a conex竢.
      conn.begin_transaction(transaction_one)

      command = Gda::Command.new("UPDATE accounts SET balance=balance+50 WHERE ref_customer=1",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      # Liga o comando a transa艫o.
      command.transaction = transaction_one
      conn.execute_non_query(command)

      command = Gda::Command.new("UPDATE accounts SET balance=balance-50 WHERE ref_customer=2",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      command.transaction = transaction_one
      conn.execute_non_query(command)

      # Faz commit na transaction.
      conn.commit_transaction(transaction_one)

      transaction_two = Gda::Transaction.new("accounts2")

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

      command = Gda::Command.new("UPDATE accounts SET balance=balance+400 WHERE ref_customer=1",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      command.transaction = transaction_two
      conn.execute_non_query(command)

      command = Gda::Command.new("UPDATE accounts SET balance=balance-400 WHERE ref_customer=2",
                                 Gda::Command::TYPE_SQL,
                                 Gda::Command::OPTION_STOP_ON_ERRORS)
      command.transaction = transaction_two
      conn.execute_non_query(command)

      # Faz rollback na segunda transa艫o.
      conn.rollback_transaction(transaction_two)

      execute_sql_command(conn, "SELECT * FROM accounts")
  end

  Gda.init("TestGDA", "0.1")
  save_ds
  Gda.main do
      list_providers
      list_datasources
      client = Gda::Client.new
      client.open_connection("arrakis", nil, nil) do |conn|
          conn.signal_connect('error') { show_errors(conn) }
          execute_some_queries(conn)
          process_accounts(conn)   
      end
      remove_ds
  end

Ruby-GNOME2

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