Archive for agosto \27\-02:00 2010

PostgreSQL Dicas

Posted on agosto 27, 2010. Filed under: PostgreSQL |

Neste rápido artigo procurei reunir algumas dicas úteis ao se trabalhar com o banco de dados PostgreSQL.

Setando uma chave estrangeira (foreign key) em um campo já existente na tabela:

ALTER TABLE endereco ADD CONSTRAINT endereco_usuario_id_fkey FOREIGN KEY (usuario_id) REFERENCES usuario(id);

No exemplo anterior, foi criado uma constraint no campo usuario_id da tabela endereco referenciando a tabela usuario campo id.

Alterando a senha do usuário postgres do banco de dados:

Entrar no banco de dados template1
psql -d template1 -U postgres
Executar a query para alterar a senha:
alter user postgres with password 'senha';

Os comandos anteriores de mudança de senha são válidos somente para as versões 7.3 e mais recentes do PostgreSQL.

Renomenado tabelas:

Renomear tabelas no Postgres é bem simples:

ALTER TABLE “nome_tabela” RENAME TO “novo_nome”

Exemplos:
ALTER TABLE user RENAME TO usuario;
ALTER TABLE employee RENAME TO funcionario;

Criando indexes:

Para criar um indíce no campo nome da tabela usuario:
create index idx_nome on usuario(nome);

O PostgreSQL permite também criar indíces usando expressões. Exemplo:
create index idx_lower_nome on usuario(lower(nome));

Você pode rodar queries usando o indíce criado no exemplo acima:
select * from usuario WHERE lower(nome) = 'alberto';

Exibir resultado das queries em formato modo extendido no psql:

Para habilitar o formato modo extendido no psql, utilize o comando abaixo:
\x

Esta função é útil quando você precisa printar na tela valores de campos muito longos. Os nomes de campos são exibidos em uma coluna à esquerda e os valores em outra coluna à direita.

Para listar os nomes dos banco de dados no psql:
\l

Para listar os nomes de tabelas ou os detalhes de uma tabela no psql:
\d <tabela>

Ler Post Completo | Make a Comment ( None so far )

Lentidão na cópia de arquivos por NFS

Posted on agosto 27, 2010. Filed under: Linux |

Recentemente precisei criar uma forma de atualização de dados entre servidores. Para acessar as informações do servidor remoto utilizei o sistema de arquivos de rede chamado NFS ou Network File System. Não entrarei em detalhes sobre o funcionamento do NFS, gostaria apenas de informar como resolvi um problema de lentidão na cópia de arquivos de um servidor para outro. O Linux utilizado nos exemplos foi o Ubuntu Server.

Primeiramente, configurei no arquivo /etc/exports o diretório que gostaria de exportar através do nfs para os outros servidores. Minha intenção era que os servidores “clientes” tivessem acesso para gravar e permissão de root no compartilhamento nfs. A proposta do compartilhamento é para que os servidores “clientes” realizem cópias de vários arquivos para o servidor. Portanto, inicialmente meu arquivo /etc/exports ficou da seguinte maneira:

/apps ip_cliente(rw,no_root_squash)

Até aqui tudo bem, consegui montar o diretório nos servidores “clientes” e rodar os scripts de cópia. Porém percebi que o tempo que levava para cópiar os arquivos estava fora do normal. Estava muito lento. Pesquisando sobre nfs achei uma informação que foi muito util para resolver o meu problema. Duas opções que melhoraram drasticamente o desempenho da cópia foram os seguintes:

  • no_subtree_check : Habilitar essa opção influência no modo como os arquivos dentro do diretório exportado são tratados. O padrão do nfs é ter o “subtree_check” habilitado. Dessa forma todos arquivos requisitados no diretório são checados se os mesmos pertencem ao diretório exportado. Para desabilitar a checagem utilize a opção “no_subtree_check”. Como são muitos arquivos sendo requisitados dentro do diretório exportado, usar essa opção melhora a velocidade na transferência dos arquivos.
  • async : Com essa opção habilitada, a resposta da requisição é retornada antes dos dados serem gravados em disco, aumentando dessa forma o desempenho na transferência dos arquivos.

Para finalizar, vejam como ficou o /etc/exports:

/apps ip_cliente(rw,no_root_squash,async,no_subtree_check)

Ler Post Completo | Make a Comment ( 1 so far )

PHP Patterns parte 2: Registry

Posted on agosto 24, 2010. Filed under: PHP |

Avançando um pouco mais em cima do pattern Singleton, obtemos o pattern Registry. O pattern Registry pode ser comparado a uma agenda de telefone ou um diretório que armazena e obtem referências para objetos. Um dos principais objetivos deste pattern é armazenar os dados globalmente de uma forma segura e organizada. Com o Registry podemos armazenar qualquer objeto como se fosse um Singleton. Ou de outra forma, enquanto o objeto que implementa o pattern Singleton consegue guardar a referência de um único objeto, o objeto que implementa o pattern Registry consegue guardar a referência de dois ou mais objetos.
Vamos a um exemplo prático da utilzação do pattern Registry: Você tem um objeto de banco de dados que deseja utilzar durante o ciclo da sua aplicação. Você pode facilmente resolver esse problema de forma elegante utilizando o pattern Singleton. Porém, supondo que na mesma aplicação, você necessita conectar em um segundo banco de dados. Dessa forma, você terá 2 objetos de banco de dados para serem armazenados. Utilizando o pattern Singleton isto é impossível, à não ser que você tenha duas classes separadas implementando o Singleton, o que não é muito elegante. O pattern Registry soluciona essa situação de uma forma muito fácil. Vamos ao código:

class Registry {
  private static $_register;

  public static function add(&$item, $name = null)
  {
    if (is_object($item) && is_null($name)) {
      $name = get_class($item);
    } elseif (is_null($name)) {
      $msg = "Você deve setar um nome para não-objetos";
      throw new Exception($msg);
    }
    $name = strtolower($name);
    self::$_register[$name] = $item;
  }

  public static function &get($name)
  {
    $name = strtolower($name);
    if (array_key_exists($name, self::$_register)) {
      return self::$_register[$name];
    } else {
      $msg = "’$name’ não esta registrado.";
      throw new Exception($msg);
    }
  }

  public static function exists($name)
  {
    $name = strtolower($name);
    if (array_key_exists($name, self::$_register)) {
      return true;
    } else {
      return false;
    }
  }
}

Utilizando o Registry em sua aplicação: Em uma primeira parte, registramos o objeto chamado $db na classe Registry utilizando o método estático add:
$db = new DB();
Registry::add($db, 'DB');

Em outra parte da aplicação podemos acessar o objeto $db, registrado anteriormente, simplesmente utilizando o método estático get da classe Registry. Nosso objeto dentro do Registry se torna “global” de uma maneira segura e elegante:

$db = Registry::get(’DB’);

Entendendo a implementação do pattern Registry:

Primeiro declaramos a propriedade $_register que irá armazenar os objetos registrados. A propriedade $_register é um array:

  private static $_register;

Depois criamos o método add que receberá um objeto ou um outro tipo de dados para ser registrado. O segundo parâmetro é opcional, ele será o nome usado para referênciar o objeto registrado. No caso de um objeto passado no primeiro parâmetro, o segundo parâmetro é opcional, e se você não fornecê-lo, o método irá seta-lo como sendo o nome da classe do objeto instanciado passado no primeiro parâmetro. Caso o primeiro parâmetro não seja um objeto, você é obrigado a fornecer um nome para referência, pois não temos como sugerir um nome para um elemento que não seja um objeto.

  public static function add(&$item, $name = null)
  {
    if (is_object($item) && is_null($name)) {
      $name = get_class($item);
    } elseif (is_null($name)) {
      $msg = "Você deve setar um nome para não-objetos";
      throw new Exception($msg);
    }
    $name = strtolower($name);
    self::$_register[$name] = $item;
  }

O método get irá recuperar o elemento registrado anteriomente. O elemento pode ser um objeto ou qualquer outro tipo de dados. Você deve fornecer o nome que referência o elemento como parâmetro para o método get.

  public static function &get($name)
  {
    $name = strtolower($name);
    if (array_key_exists($name, self::$_register)) {
      return self::$_register[$name];
    } else {
      $msg = "’$name’ não esta registrado.";
      throw new Exception($msg);
    }
  }

Esses são os dois principais métodos da implementação do pattern Registry. Caso você tenha interesse em se aprofundar mais, sugiro olhar o código fonte fornecido pelo Zend Framework que implementa o pattern Registry através da classe chamada Zend_Registry. Esta classe implementa o pattern Registry de forma muito bem codificada. Se você trabalha com o Zend Framework você deve saber da utilidade dessa classe. Segue abaixo exemplos de utilização da classe Zend_Registry:

Zend_Registry::set('log', $logger); // registrando o objeto $logger
// mais tarde em sua aplicação, obtendo o objeto logger
$log = Zend_Registry::get('log');
$log->info('Alertas...');

// ou utilizando diretamente
Zend_Registry::get('log')->info('Alertas...');

Ler Post Completo | Make a Comment ( 1 so far )

PHP Patterns parte 1: Singleton

Posted on agosto 3, 2010. Filed under: PHP |

Situação:

Em determinadas situações no desenvolvimento de nossa aplicação precisamos que um ou mais recursos criados uma única vez sejam compartilhados ficando disponíveis em todo o ciclo da aplicação. Um exemplo bem comum na utilização do pattern Singleton é o objeto de conexão com o banco de dados. Geralmente o objeto é criado quando a aplicação é chamada e destruída quando a aplicação termina. Você não precisa criar o objeto de conexão com o banco em todos os lugares que precisa dele, isso enquanto a aplicação estiver sendo executada. Ao invés disso a idéia é que possamos reutilizar a conexão que já foi estabilizada anteriormente.

Solução:

Quando você precisa de uma instância exclusiva de uma classe, como no caso da conexão com o banco de dados, podemos utilizar um pattern chamado Singleton. Uma classe baseado no pattern Singleton, inicializa uma instância da classe desejada e à disponibiliza através de um método statico tipicamente chamado de getInstance(). O mesmo objeto será retornado toda vez que solicitado. O objeto será criado uma única vez.

Implementar o Singleton no PHP 5 é muito simples. Segue abaixo o código de implementação do pattern Singleton.

<php
class DB {
  private static $instance = false;

  private function __construct() {}

  public static function getInstance() {
    if (false === DB::$instance) {
      DB::$instance = new DB;
    }
    return DB::$instance;
  }
}

$db = DB::getInstance();
$db->query("SELECT * FROM tabela");

Primeiramente definimos uma propriedade privada onde será armazenado o objeto único.
private static $instance = false;

Criamos um constrtutor da classe privado e sem corpo. Dessa forma, impedimos que a classe seja instanciada diretamente. A idéia aqui é forçar o programador a usar o método getInstance() que é declarado de forma estática.
private function __construct() {}

Finalmente implementamos o método estático getInstance() que irá nos retornar o objeto armazenado na propriedade $instance. Na primeira chamada ao método, o objeto DB será criado. Nas chamadas seguintes, o método retorna o objeto já criado anteriormente:
public static function getInstance() {
  if (false === DB::$instance) {
    DB::$instance = new DB;
  }
  return DB::$instance;
}

Utilizando a classe baseado no pattern Singleton:
$db = DB::getInstance();
$db->query("SELECT * FROM tabela");

Ler Post Completo | Make a Comment ( 1 so far )

Liked it here?
Why not try sites on the blogroll...

%d blogueiros gostam disto: