Índice
Zend_Db_Select é uma ferramenta para construir instruções SQL SELECT independentemente do banco de dados utilizado. Obviamente isso não pode ser perfeito, mas é um avanço para ajudar a fazer consultas portáveis entre banco de dados diferentes. Adicionalmente, ele ajuda a proteger suas consultas contra ataques de SQL injection.
A maneira mais fácil de criar uma instância de Zend_Db_Select é usar o método Zend_Db_Adapter::select().
<?php
require_once 'Zend/Db.php';
$params = array (
'host' => '127.0.0.1',
'username' => 'malory',
'password' => '******',
'dbname' => 'camelot'
);
$db = Zend_Db::factory('pdoMysql', $params);
$select = $db->select();
// $select é agora um objeto Zend_Db_Select_PdoMysql
?>
Então você constrói uma consulta SELECT usando o objeto e seus métodos, e em seguida gera uma string para devolver ao Zend_Db_Adapter para consultas ou buscas.
<?php
//
// SELECT *
// FROM round_table
// WHERE noble_title = "Sir"
// ORDER BY first_name
// LIMIT 10 OFFSET 20
//
// você pode usar um estilo iterativo...
$select->from('round_table', '*');
$select->where('noble_title = ?', 'Sir');
$select->order('first_name');
$select->limit(10,20);
// ...ou um estilo "fluente":
$select->from('round_table', '*')
->where('noble_title = ?', 'Sir')
->order('first_name')
->limit(10,20);
// de um modo ou de outro, busque os resultados
$sql = $select->__toString();
$result = $db->fetchAll($sql);
// alternativamente, você pode passar o objeto $select;
// Zend_Db_Adapter é esperto o suficiente para chamar __toString() nos
// objetos Zend_Db_Select para pegar a string de consulta.
$result = $db->fetchAll($select);
?>
Você também pode usar parâmetros vinculados nas suas consultas em vez de adicionar aspas a cada método.
<?php
//
// SELECT *
// FROM round_table
// WHERE noble_title = "Sir"
// ORDER BY first_name
// LIMIT 10 OFFSET 20
//
$select->from('round_table', '*')
->where('noble_title = :title')
->order('first_name')
->limit(10,20);
// de um modo ou de outro, busque os resultados usando os parãmetros vinculados
$params = array('title' => 'Sir');
$result = $db->fetchAll($select, $params);
?>
Para selecionar colunas de uma tabela específica, use o método from(), specificando a tabela e as colunas que você quer. Você pode usar apelidos para a tabela e para colunas, e você pode usar from() quantas vezes precisar.
<?php
// crie um objeto $db, usando Mysql como o adaptador.
$select = $db->select();
// SELECT a, b, c FROM some_table
$select->from('some_table', 'a, b, c');
// equivalente:
$select->from('some_table', array('a', 'b', 'c');
// SELECT bar.col FROM foo AS bar
$select->from('foo AS bar', 'bar.col');
// SELECT foo.col AS col1, bar.col AS col2 FROM foo, bar
$select->from('foo', 'foo.col AS col1');
$select->from('bar', 'bar.col AS col2');
?>
Para selecionar colunas usando tabelas unidas, use o método join(). Primeiro passe o nome da tabela que se unirá, então a condição da união, e finalmente as colunas que você quer unir. Você pode usar join() quantas vezes precisar.
<?php
// crie um objeto $db, usando Mysql como adaptador.
$select = $db->select();
//
// SELECT foo.*, bar.*
// FROM foo
// JOIN bar ON foo.id = bar.id
//
$select->from('foo', '*');
$select->join('bar', 'foo.id = bar.id', '*');
?>
No momento, apenas a sintaxe de JOIN é suportada; não LEFT JOINs, RIGHT JOINs, etc. Versões futuras vão suportar estas operações de um modo independente de bancos de dados.
Para adicionar condições WHERE, use o método where(). Você pode passar uma string regular, ou uma string com um ponto de interrogação marcando um espaço reservado e um valor para adicionar aspas nela (o valor receberá aspas usando Zend_Db_Adapter::quoteInto).
Chamadas múltiplas a where() adicionarão AND às condições; se você precisar de OR, use orWhere().
<?php
// crie um objeto $db, e pega a ferramenta SELECT.
$select = $db->select();
//
// SELECT *
// FROM round_table
// WHERE noble_title = "Sir"
// AND favorite_color = "yellow"
//
$select->from('round_table', '*');
$select->where('noble_title = "Sir"'); // embedded value
$select->where('favorite_color = ?', 'yellow'); // quoted value
//
// SELECT *
// FROM foo
// WHERE bar = "baz"
// OR id IN("1", "2", "3")
//
$select->from('foo', '*');
$select->where('bar = ?', 'baz');
$select->orWhere('id IN(?)', array(1, 2, 3);
?>
Para agrupar linhas, use o método group() quantas vezes você desejar.
<?php
// crie um objeto $db, e pega a ferramenta SELECT.
$select = $db->select();
//
// SELECT COUNT(id)
// FROM foo
// GROUP BY bar, baz
//
$select->from('foo', 'COUNT(id)');
$select->group('bar');
$select->group('baz');
// chamada equivalente de group():
$select->group('bar, baz');
// outra chamada equivalente de group():
$select->group(array('bar', 'baz'));
?>
Para adicionar condições HAVING aos resultados selecionados, use o método having(). este método é id~entico em função ao método where().
Se você chamar having() múltiplas vezes, as condições são unidas usando AND; se você quiser uma condição OR, use orHaving().
<?php
// crie um objeto $db, e pega a ferramenta SELECT.
$select = $db->select();
//
// SELECT COUNT(id) AS count_id
// FROM foo
// GROUP BY bar, baz
// HAVING count_id > "1"
//
$select->from('foo', 'COUNT(id) AS count_id');
$select->group('bar, baz');
$select->having('count_id > ?', 1);
?>
Para ordenar colunas com ORDER, use o método order() quantas vezes desejar.
<?php
// crie um objeto $db, e pega a ferramenta SELECT.
$select = $db->select();
//
// SELECT * FROM round_table
// ORDER BY noble_title DESC, first_name ASC
//
$select->from('round_table', '*');
$select->order('noble_title DESC');
$select->order('first_name');
// chamada equivalente de order():
$select->order('noble_title DESC, first_name');
// outra chamada equivalente de order():
$select->order(array('noble_title DESC', 'first_name'));
?>
Zend_Db_Select oferece abstrações pra suporte da cláusula LIMIT. Para muitos bancos de dados, como MySQL e PostgreSQL, isso é relativamente fácil, pois eles suportam a sintaxe "LIMIT :count [OFFSET :offset]".
Para outros bancos de dados, como Microsoft SQL e Oracle, isso não é tão fácil, pois eles não suportam cláusulas LIMIT. MS-SQL tem apenas uma cláusula TOP, e Oracle requer que a consulta seja escrita de uma maneira especial para emular um LIMIT. Devido à maneira como o Zend_Db_Select trabalhar internamente, nós podemos reescrever SELECT para emular a funcionalidade LIMIT dos bancos de dados de código aberto mencionados anteriormente.
Para usar LIMIT nos resultados retornados usando count e offset, use o método limit() com um valor count e um offset opcional.
<?php
// primeiro, um simples "LIMIT :count"
$select = $db->select();
$select->from('foo', '*');
$select->order('id');
$select->limit(10);
//
// Em MySQL/PostgreSQL/SQLite, isso se traduz para:
//
// SELECT * FROM foo
// ORDER BY id ASC
// LIMIT 10
//
// Mas em Microsoft SQL, isso se traduz para:
//
// SELECT TOP 10 * FROM FOO
// ORDER BY id ASC
//
//
// agora, um mais complexo "LIMIT :count OFFSET :offset"
$select = $db->select();
$select->from('foo', '*');
$select->order('id');
$select->limit(10, 20);
//
// Em MySQL/PostgreSQL/SQLite, isso se traduz para:
//
// SELECT * FROM foo
// ORDER BY id ASC
// LIMIT 10 OFFSET 20
//
// Mas em Microsoft SQL, que não tem suporte a offset, isso se traduz para
// algo como:
//
// SELECT * FROM (
// SELECT TOP 10 * FROM (
// SELECT TOP 30 * FROM foo ORDER BY id DESC
// ) ORDER BY id ASC
// )
//
// Zend_Db_Adapter faz a tradução da consulta automaticamente.
//
?>
Zend_Db_Select também oferece limites baseados em páginas. Se você quer receber uma certa "página" de resultados, use o método limitPage(); primeiro passe o número da página que voc~e quer, e então o número de linhas que aparecerão em cada página.
<?php
// construa o select básico...
$select = $db->select();
$select->from('foo', '*');
$select->order('id');
// ... e limite o resultado à página 3, cada página com 10 linhas
$select->limitPage(3, 10);
//
// Em MySQL/PostgreSQL/SQLite, isso se traduz para:
//
// SELECT * FROM foo
// ORDER BY id ASC
// LIMIT 10 OFFSET 20
//
?>