|
|
@@ -0,0 +1,2372 @@
|
|
|
+<?xml version="1.0" encoding="UTF-8"?>
|
|
|
+<!-- EN-Revision: 19173 -->
|
|
|
+<!-- Reviewed: no -->
|
|
|
+<sect1 id="zend.db.adapter">
|
|
|
+ <title>Zend_Db_Adapter</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ <classname>Zend_Db</classname> e suas classes relacionadas provêem uma interface de banco de dados
|
|
|
+ <acronym>SQL</acronym> simples para Zend Framework.
|
|
|
+ <classname>Zend_Db_Adapter</classname> é a classe básica que você usa para conectar sua aplicação
|
|
|
+ <acronym>PHP</acronym>a um <acronym>SGBDR</acronym>. Há uma classe adaptadora diferente
|
|
|
+ para cada marca de <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Os adaptadores <classname>Zend_Db</classname> criam uma ponte entre extensões
|
|
|
+ <acronym>PHP</acronym> específicas de cada fabricante para uma interface comum que ajudam você a escrever aplicações
|
|
|
+ <acronym>PHP</acronym> uma vez e distribui-las com múltiplas marcas de
|
|
|
+ <acronym>SGBDR</acronym> com muito pouco esforço.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ A interface da classe adaptadora é similar à interface da extensão
|
|
|
+ <ulink url="http://www.php.net/pdo">PHP Data Objects</ulink>.
|
|
|
+ <classname>Zend_Db</classname> provê classes adaptadoras para drivers <acronym>PDO</acronym>
|
|
|
+ das seguintes marcas de <acronym>SGBDR</acronym>:
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ IBM DB2 e Informix Dynamic Server (IDS), usando a extensão <acronym>PHP</acronym>
|
|
|
+ <ulink url="http://www.php.net/pdo-ibm">pdo_ibm</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ MySQL, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/pdo-mysql">pdo_mysql</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Microsoft <acronym>SQL</acronym> Server, usando a extensão <acronym>PHP</acronym> <ulink
|
|
|
+ url="http://www.php.net/pdo-dblib">pdo_dblib</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Oracle, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/pdo-oci">pdo_oci</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ PostgreSQL, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/pdo-pgsql">pdo_pgsql</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ SQLite, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/pdo-sqlite">pdo_sqlite</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Além disso, <classname>Zend_Db</classname> provê classes adaptadoras que utilizam extensões de bancos de dados
|
|
|
+ <acronym>PHP</acronym> para as seguintes marcas de <acronym>SGBDR</acronym>:
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ MySQL, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/mysqli">mysqli</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Oracle, usando a extensão <acronym>PHP</acronym> <ulink url="http://www.php.net/oci8">oci8</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ IBM DB2 e DB2/i5, usando a extensão <acronym>PHP</acronym> <ulink
|
|
|
+ url="http://www.php.net/ibm_db2">ibm_db2</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Firebird/Interbase, usando a extensão <acronym>PHP</acronym> <ulink
|
|
|
+ url="http://www.php.net/ibase">php_interbase</ulink>
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+
|
|
|
+ <note>
|
|
|
+ <para>
|
|
|
+ Cada classe acaptadora <classname>Zend_Db</classname> usa uma extensão <acronym>PHP</acronym>. Você
|
|
|
+ deve ter a respectiva extensão <acronym>PHP</acronym> habilitada em seu ambiente
|
|
|
+ <acronym>PHP</acronym> para usar uma classe adaptadora <classname>Zend_Db</classname>. Por
|
|
|
+ exemplo, se você usa qualquer uma das classes adaptadoras <acronym>PDO</acronym> do <classname>Zend_Db</classname>
|
|
|
+ , você precisa habilitar tanto a extensão <acronym>PDO</acronym> quanto o driver
|
|
|
+ <acronym>PDO</acronym> para a marca de <acronym>SGBDR</acronym> que você usa.
|
|
|
+ </para>
|
|
|
+ </note>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.connecting">
|
|
|
+ <title>Conectando-se a um Banco de Dados Usando uma Adaptadora</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Esta seção descreve como criar uma instância de uma classe adaptadora de banco de dados.
|
|
|
+ Isso corresponde a fazer uma conexão com seu servidor <acronym>SGBDR</acronym> a partir de
|
|
|
+ sua aplicação <acronym>PHP</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.connecting.constructor">
|
|
|
+ <title>Usando um Construtor de Adaptadora Zend_Db</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode criar uma instância de uma classe adaptadora usando seu construtor.
|
|
|
+ Um construtor de classe adaptadora leva um argumento, que é um matriz
|
|
|
+ de parâmetros usado para declarar a conexão.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.constructor.example">
|
|
|
+ <title>Usando um Construtor de Adaptadora</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db = new Zend_Db_Adapter_Pdo_Mysql(array(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test'
|
|
|
+));
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.connecting.factory">
|
|
|
+ <title>Usando a Fábrica Zend_Db</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Como uma alternativa ao uso direto do construtor da classe adaptadora, você
|
|
|
+ pode criar uma instância de uma adaptadora usando o método estático
|
|
|
+ <methodname>Zend_Db::factory()</methodname>. Este método carrega dinamicamente
|
|
|
+ o arquivo da classe adaptadora sob demanda usando o método
|
|
|
+ <link linkend="zend.loader.load.class">Zend_Loader::loadClass()</link>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O primeiro argumento é um string que identifica o nome base da
|
|
|
+ classe adaptadora. Por exemplo, a string '<classname>Pdo_Mysql</classname>' corresponde
|
|
|
+ à classe <classname>Zend_Db_Adapter_Pdo_Mysql</classname>. O segundo argumento
|
|
|
+ é o mesmo matriz de parâmetros que você teria passado para
|
|
|
+ o construtor da adaptadora.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.factory.example">
|
|
|
+ <title>Using the Adapter Factory Method</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+// Nós não precisamos seguir a declaração a seguir porque o
|
|
|
+// arquivo Zend_Db_Adapter_Pdo_Mysql será carregado para nós pelo método Zend_Db
|
|
|
+// factory.
|
|
|
+
|
|
|
+// require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
|
|
|
+
|
|
|
+// Carrega automaticamente a classe Zend_Db_Adapter_Pdo_Mysql
|
|
|
+// e cria uma instância dela.
|
|
|
+$db = Zend_Db::factory('Pdo_Mysql', matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test'
|
|
|
+));
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você criar sua própria classe que estende
|
|
|
+ <classname>Zend_Db_Adapter_Abstract</classname>, mas não nomear sua
|
|
|
+ classe com o prefixo de pacote "<classname>Zend_Db_Adapter</classname>", você pode usar
|
|
|
+ o método <methodname>factory()</methodname> para carregar sua adaptadora se você
|
|
|
+ especificar a parte principal da classe adaptadora com a
|
|
|
+ chave 'adapterNamespace' no matriz de parâmetros.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.factory.example2">
|
|
|
+ <title>Usando o Método de Fábrica da Adaptadora para uma Classe Adaptadora Personalizada</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+// Nós não precisamos carregar o arquivo da classe adaptadora
|
|
|
+// porque ele será carregado para nós pelo método de fábrica do Zend_Db.
|
|
|
+
|
|
|
+// Carrega automaticamente a classe MyProject_Db_Adapter_Pdo_Mysql e cria
|
|
|
+// uma instância dela.
|
|
|
+$db = Zend_Db::factory('Pdo_Mysql', matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'adapterNamespace' => 'MyProject_Db_Adapter'
|
|
|
+));
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.connecting.factory-config">
|
|
|
+ <title>Usando Zend_Config com Zend_Db Factory</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Opcionalmente, você pode especificar cada argumento do
|
|
|
+ método <methodname>factory()</methodname> como um objeto do tipo
|
|
|
+ <link linkend="zend.config">Zend_Config</link>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se o primeiro argumento é um objeto de configuração, espera-se que
|
|
|
+ ele contenha uma propriedade chamada <property>adapter</property>, contendo uma
|
|
|
+ string que designa a base do nome da classe adaptadora. Opcionalmente, o objeto
|
|
|
+ pode conter uma propriedade chamada <property>params</property>, com
|
|
|
+ subpropriedades correspondentes aos nomes de parâmetro da adaptadora.
|
|
|
+ Isso é usado somente se o segundo argumento do
|
|
|
+ método <methodname>factory()</methodname> for omitido.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.factory.example1">
|
|
|
+ <title>Usando o Método de Fábrica da Adaptadora com um Objeto Zend_Config</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ No exemplo abaixo, um objeto <classname>Zend_Config</classname> é criado
|
|
|
+ a partir de um matriz. Você pode também carregar dados a partir de um arquivo externo usando classes tais
|
|
|
+ como <link linkend="zend.config.adapters.ini">Zend_Config_Ini</link>
|
|
|
+ e <link linkend="zend.config.adapters.xml">Zend_Config_Xml</link>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$config = new Zend_Config(
|
|
|
+ matriz(
|
|
|
+ 'database' => matriz(
|
|
|
+ 'adapter' => 'Mysqli',
|
|
|
+ 'params' => matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'secret',
|
|
|
+ )
|
|
|
+ )
|
|
|
+ )
|
|
|
+);
|
|
|
+
|
|
|
+$db = Zend_Db::factory($config->database);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O segundo argumento do método <methodname>factory()</methodname> pode ser
|
|
|
+ um matriz associativo contendo entradas correspondentes aos
|
|
|
+ parâmetros da adaptadora. Esse argumento é opcional. Se o primeiro
|
|
|
+ argumento é do tipo <classname>Zend_Config</classname>, é assumido que ele contém todos os
|
|
|
+ parâmetros, e o segundo argumento é ignorado
|
|
|
+ </para>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.connecting.parameters">
|
|
|
+ <title>Parâmetros da Adaptadora</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ A seguinte lista explica parâmetros comuns reconhecidos pelas
|
|
|
+ classes adaptadoras <classname>Zend_Db</classname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>host</emphasis>:
|
|
|
+ uma string contendo um hostname ou endereço IP do
|
|
|
+ servidor de banco de dados. Se o banco de dados está rodando no
|
|
|
+ mesmo servidor anfitrião da aplicação <acronym>PHP</acronym>, você pode usar
|
|
|
+ 'localhost' ou '127.0.0.1'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>username</emphasis>:
|
|
|
+ identificador da conta para autenticar uma conexão com o
|
|
|
+ servidor <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>password</emphasis>:
|
|
|
+ credencial de senha para autenticar uma
|
|
|
+ conexão com o servidor <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>dbname</emphasis>:
|
|
|
+ nome da instância do banco de dados no servidor <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>port</emphasis>:
|
|
|
+ alguns servidores <acronym>SGBDR</acronym> podem aceitar conexões de rede em um
|
|
|
+ número de porta especificado pelo administrador. O parâmetro port
|
|
|
+ permite que você especifique a porta a qual sua
|
|
|
+ aplicação <acronym>PHP</acronym> se conecta, para casar com a porta configurada
|
|
|
+ no servidor <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>charset</emphasis>:
|
|
|
+ especifica o conjunto de caracteres usado para a conexão.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>options</emphasis>:
|
|
|
+ este parâmetro é um matriz associativo de opções
|
|
|
+ que são genéricas para todas as classes <classname>Zend_Db_Adapter</classname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>driver_options</emphasis>:
|
|
|
+ este parâmetro é um matriz associativo de opções
|
|
|
+ adicionais que são específicas para uma dada extensão
|
|
|
+ de banco de dados. Um uso típico deste parâmetro é para
|
|
|
+ configurar atributos de um driver <acronym>PDO</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>adapterNamespace</emphasis>:
|
|
|
+ nomeia a parte inicial do nome da classe para a
|
|
|
+ adaptadora, em vez de '<classname>Zend_Db_Adapter</classname>'. Use isto se
|
|
|
+ você precisar do método <methodname>factory()</methodname> para
|
|
|
+ carregar uma classe adaptadora de banco de dados não-Zend.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.parameters.example1">
|
|
|
+ <title>Passando a Opção Case-Folding para a Fábrica</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode especificar essa opção pela constante
|
|
|
+ <constant>Zend_Db::CASE_FOLDING</constant>.
|
|
|
+ Ela corresponde ao atributo <constant>ATTR_CASE</constant> nos
|
|
|
+ drivers de banco de dados <acronym>PDO</acronym> e IBM DB2, ajustando a caixa
|
|
|
+ das chaves de string nos conjuntos de resultado de consulta. A opção leva os valores
|
|
|
+ <constant>Zend_Db::CASE_NATURAL</constant> (padrão),
|
|
|
+ <constant>Zend_Db::CASE_UPPER</constant>, e
|
|
|
+ <constant>Zend_Db::CASE_LOWER</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$options = matriz(
|
|
|
+ Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER
|
|
|
+);
|
|
|
+
|
|
|
+$params = matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'options' => $options
|
|
|
+);
|
|
|
+
|
|
|
+$db = Zend_Db::factory('Db2', $params);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.parameters.example2">
|
|
|
+ <title>Passando a Opção Auto-Quoting para a Fábrica</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode especificar essa opção pela constante
|
|
|
+ <constant>Zend_Db::AUTO_QUOTE_IDENTIFIERS</constant>. Se o valor
|
|
|
+ é <constant>TRUE</constant> (padrão), identificadores como nomes de
|
|
|
+ tabela, nomes de coluna, e mesmo apelidos são delimitados em toda
|
|
|
+ sintaxe <acronym>SQL</acronym> gerada pelo objeto adaptador. Isso torna simples
|
|
|
+ usar identificadores que contêm palavras-chave <acronym>SQL</acronym>, ou
|
|
|
+ caracteres especiais. Se o valor é <constant>FALSE</constant>,
|
|
|
+ identificadores não são delimitados automaticamente. Se você precisa
|
|
|
+ delimitar identificadores, você deve fazer por conta própria usando
|
|
|
+ o método <methodname>quoteIdentifier()</methodname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$options = matriz(
|
|
|
+ Zend_Db::AUTO_QUOTE_IDENTIFIERS => false
|
|
|
+);
|
|
|
+
|
|
|
+$params = matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'options' => $options
|
|
|
+);
|
|
|
+
|
|
|
+$db = Zend_Db::factory('Pdo_Mysql', $params);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.parameters.example3">
|
|
|
+ <title>Passando Opções de Driver PDO para a a Fábrica</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$pdoParams = matriz(
|
|
|
+ PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
|
|
|
+);
|
|
|
+
|
|
|
+$params = matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'driver_options' => $pdoParams
|
|
|
+);
|
|
|
+
|
|
|
+$db = Zend_Db::factory('Pdo_Mysql', $params);
|
|
|
+
|
|
|
+echo $db->getConnection()
|
|
|
+ ->getAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.parameters.example4">
|
|
|
+ <title>Passando Opções de Serialização para a Fábrica</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$options = matriz(
|
|
|
+ Zend_Db::ALLOW_SERIALIZATION => false
|
|
|
+);
|
|
|
+
|
|
|
+$params = matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'options' => $options
|
|
|
+);
|
|
|
+
|
|
|
+$db = Zend_Db::factory('Pdo_Mysql', $params);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.connecting.getconnection">
|
|
|
+ <title>Gerenciando Conexões Preguiçosas</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Criar uma instância de uma classe adaptadora não abre uma conexão
|
|
|
+ com o servidor <acronym>SGBDR</acronym> imediatamente. A adaptadora guarda os parâmetros
|
|
|
+ de conexão, e a estabelece por demanda, na primeira
|
|
|
+ vez que você precisar executar uma consulta. Isso garante que
|
|
|
+ criar um objeto adaptador é rápido é barato. Você pode
|
|
|
+ criar uma instância de uma adaptadora mesmo se não estiver certo
|
|
|
+ que precisa rodar quaisquer consultas de banco de dados durante a requisição
|
|
|
+ atual que sua aplicação está servindo.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você precisa forçar a adaptador a se conectar ao <acronym>SGBDR</acronym>, use
|
|
|
+ o método <methodname>getConnection()</methodname>. Esse método retorna
|
|
|
+ um objeto para a conexão como representado pela respectiva
|
|
|
+ extensão de banco de dados <acronym>PHP</acronym>. Por exemplo, se você usar qualquer uma
|
|
|
+ das classes adaptadoras para drivers <acronym>PDO</acronym>, então
|
|
|
+ <methodname>getConnection()</methodname> retorna o objeto <acronym>PDO</acronym>,
|
|
|
+ depois de iniciá-lo como uma conexão ativa para o banco de dados especificado.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Pode ser útil forçar a conexão se você quer capturar
|
|
|
+ quaisquer exceções que ela lançar como resultado de credenciais de conta
|
|
|
+ inválidas, ou outra falha ao conectar-se ao servidor <acronym>SGBDR</acronym>.
|
|
|
+ Essas exceções não são lançadas até que a conexão seja feita,
|
|
|
+ assim isso pode ajudar a simplificar o código de sua aplicação se você manipular as
|
|
|
+ exceções em um lugar, em vez de fazê-lo
|
|
|
+ na primeira consulta ao banco de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Adicionalmente, uma adaptadora pode ser serializada para armazená-la, por exemplo,
|
|
|
+ em uma variável de sessão. Isso pode ser muito útil não somente para a
|
|
|
+ própria adaptadora, mas para outros objetos que a agreguem, como um
|
|
|
+ objeto <classname>Zend_Db_Select</classname>. Por padrão, adaptadoras têm permissão
|
|
|
+ de serem serializadas, se você não quiser isso, deve considerar passar a
|
|
|
+ opção <constant>Zend_Db::ALLOW_SERIALIZATION</constant> com
|
|
|
+ <constant>FALSE</constant>, veja o exemplo abaixo. Em respeito ao princípio de conexões
|
|
|
+ preguiçosas, a adaptadora não reconectará a si própria depois de ser revertida sua serialização. Você deve
|
|
|
+ então chamar <methodname>getConnection()</methodname> por conta própria. Você pode fazer a
|
|
|
+ adaptadora se autorreconectar pela passagem de
|
|
|
+ <constant>Zend_Db::AUTO_RECONNECT_ON_UNSERIALIZE</constant> com
|
|
|
+ <constant>TRUE</constant> como uma opção da adaptadora.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.getconnection.example">
|
|
|
+ <title>Manipulando Exceções de Conexão</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+try {
|
|
|
+ $db = Zend_Db::factory('Pdo_Mysql', $parameters);
|
|
|
+ $db->getConnection();
|
|
|
+} catch (Zend_Db_Adapter_Exception $e) {
|
|
|
+ // talvez uma credencial de login falhou, ou talvez o SGBDR não está rodando
|
|
|
+} catch (Zend_Exception $e) {
|
|
|
+ // talvez factory() falhou em carregar a classe adaptadora especificada
|
|
|
+}
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.example-database">
|
|
|
+
|
|
|
+ <title>Banco de Dados de Exemplo</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Na documentação para classes <classname>Zend_Db</classname>, nós usamos um conjunto de
|
|
|
+ tabelas simples para ilustrar o uso de classes e métodos. Estas
|
|
|
+ tabelas de exemplo podem armazenar informações sobre rastreamento de bugs em um
|
|
|
+ projeto de desenvolvimento de software. O banco de dados contém quatro tabelas:
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>accounts</emphasis> armazena
|
|
|
+ informação sobre cada usuário do banco de dados de rastreamento de bugs.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>products</emphasis> armazena
|
|
|
+ informação sobre cada produto para o qual um bug pode ser
|
|
|
+ registrado.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>bugs</emphasis> armazena informação
|
|
|
+ sobre bugs, incluindo o estado atual do bug, a
|
|
|
+ pessoa que o reportou, a pessoa que se encarregou de
|
|
|
+ corrigí-lo e a pessoa que se encarregou de verificar a
|
|
|
+ correção.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>bugs_products</emphasis> armazena um
|
|
|
+ relacionamento entre bugs e produtos. Ela implementa um
|
|
|
+ relacionamento muitos-para-muitos, porque para um dado bug pode ter
|
|
|
+ relevância para múltiplos produtos, e, obviamente, um dado
|
|
|
+ produto pode ter múltiplos bugs.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O seguinte pseudocódigo de linguagem de definição de dados <acronym>SQL</acronym> descreve as
|
|
|
+ tabeas neste banco de dados de exemplo. Estas tabelas de exemplo são extensivamente usadas
|
|
|
+ pelos testes unitários automatizados de <classname>Zend_Db</classname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <programlisting language="sql"><![CDATA[
|
|
|
+CREATE TABLE accounts (
|
|
|
+ account_name VARCHAR(100) NOT NULL PRIMARY KEY
|
|
|
+);
|
|
|
+
|
|
|
+CREATE TABLE products (
|
|
|
+ product_id INTEGER NOT NULL PRIMARY KEY,
|
|
|
+ product_name VARCHAR(100)
|
|
|
+);
|
|
|
+
|
|
|
+CREATE TABLE bugs (
|
|
|
+ bug_id INTEGER NOT NULL PRIMARY KEY,
|
|
|
+ bug_description VARCHAR(100),
|
|
|
+ bug_status VARCHAR(20),
|
|
|
+ reported_by VARCHAR(100) REFERENCES accounts(account_name),
|
|
|
+ assigned_to VARCHAR(100) REFERENCES accounts(account_name),
|
|
|
+ verified_by VARCHAR(100) REFERENCES accounts(account_name)
|
|
|
+);
|
|
|
+
|
|
|
+CREATE TABLE bugs_products (
|
|
|
+ bug_id INTEGER NOT NULL REFERENCES bugs,
|
|
|
+ product_id INTEGER NOT NULL REFERENCES products,
|
|
|
+ PRIMARY KEY (bug_id, product_id)
|
|
|
+);
|
|
|
+]]></programlisting>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Note também que a tabela 'bugs' contém múltiplas
|
|
|
+ referências de chave estrangeira para a tabela 'accounts'.
|
|
|
+ Cada uma das chaves estrangeiras pode referenciar uma linha diferente na
|
|
|
+ tabela 'accounts' para um dado bug.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O diagrama abaixo ilustra o modelo físico de dados do
|
|
|
+ banco de dados de exemplo.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ <inlinegraphic width="387" scale="100" align="center" valign="middle"
|
|
|
+ fileref="figures/zend.db.adapter.example-database.png" format="PNG" />
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.select">
|
|
|
+
|
|
|
+ <title>Lendo Resultados de Consulta</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Esta seção descreve métodos da classe adaptadora com os quais você
|
|
|
+ pode rodar consultas <acronym>SELECT</acronym> e recuperar seus resultados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchall">
|
|
|
+
|
|
|
+ <title>Buscando um Conjunto Completo de Resultados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode rodar uma consulta <acronym>SQL</acronym> <acronym>SELECT</acronym> e recuperar
|
|
|
+ seus resultados em um passo usando o método <methodname>fetchAll()</methodname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O primeiro argumento para este método é uma string contendo uma
|
|
|
+ declaração <acronym>SELECT</acronym>. Como alternativa, o primeiro argumento pode ser um
|
|
|
+ objeto da classe <link linkend="zend.db.select">Zend_Db_Select</link>.
|
|
|
+ A classe adaptadora converte automaticamente esse objeto em uma representação de string
|
|
|
+ da declaração <acronym>SELECT</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O segundo argumento para <methodname>fetchAll()</methodname> é um matriz de
|
|
|
+ valores para substituir por curingas de parâmetro na declaração <acronym>SQL</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchall.example">
|
|
|
+ <title>Usando fetchAll()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$sql = 'SELECT * FROM bugs WHERE bug_id = ?';
|
|
|
+
|
|
|
+$result = $db->fetchAll($sql, 2);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetch-mode">
|
|
|
+
|
|
|
+ <title>Alterando o Modo de Busca</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Por padrão, <methodname>fetchAll()</methodname> retorna um matriz de
|
|
|
+ linhas, cada uma das quais é um matriz associativo. As chaves do
|
|
|
+ matriz associativo são as colunas ou apelidos de coluna dados
|
|
|
+ na consulta de seleção.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode especificar um estilo diferente de resultados de busca usando o
|
|
|
+ método <methodname>setFetchMode()</methodname>. Os modos suportados são
|
|
|
+ identificados por constantes:
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>Zend_Db::FETCH_ASSOC</emphasis>:
|
|
|
+ retorna dados em um matriz de matrizs associativos.
|
|
|
+ As chaves de matriz são nomes de coluna, como strings. Este é o modo padrão de busca
|
|
|
+ para classes <classname>Zend_Db_Adapter</classname>.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Note que se sua lista de seleção contém mais de uma
|
|
|
+ coluna com o mesmo nome, por exemplo se elas são de
|
|
|
+ duas tabelas diferentes em um <acronym>JOIN</acronym>, pode haver somente uma
|
|
|
+ entrada no matriz associativo para o nome dado.
|
|
|
+ Se você usa o modo <acronym>FETCH_ASSOC</acronym>, deve especificar
|
|
|
+ apelidos de coluna em sua consulta <acronym>SELECT</acronym> para garantir que os
|
|
|
+ nomes resultem em chaves de matriz únicas.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Por padrão, essas strings são devolvidas como foram
|
|
|
+ devolvidas pelo driver de banco de dados. Isso é tipicamente
|
|
|
+ a leitura da coluna no servidor <acronym>SGBDR</acronym>. Você pode
|
|
|
+ especificar a caixa para essas strings, usando a
|
|
|
+ opção <constant>Zend_Db::CASE_FOLDING</constant>.
|
|
|
+ Especifique isso quando instanciar a adaptadora.
|
|
|
+ Veja <xref linkend="zend.db.adapter.connecting.parameters.example1" />.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>Zend_Db::FETCH_NUM</emphasis>:
|
|
|
+ retorna dados em um matriz de matrizs. Os matrizs são
|
|
|
+ indexados por inteiros, correspondendo à posição do
|
|
|
+ respectivo campo na lista de seleção da consulta.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>Zend_Db::FETCH_BOTH</emphasis>:
|
|
|
+ retorna dados em um matriz de matrizs. As chaves de matriz são
|
|
|
+ tanto strings como as usadas no modo FETCH_ASSOC, como
|
|
|
+ inteiros como os usados no modo FETCH_NUM. Note que o
|
|
|
+ número de elementos no matriz é o dobro do que
|
|
|
+ seria se você usasse FETCH_ASSOC
|
|
|
+ ou FETCH_NUM.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>Zend_Db::FETCH_COLUMN</emphasis>:
|
|
|
+ retorna dados em um matriz de valores. O valor em cada matriz
|
|
|
+ é o valor retornado pela coluna do conjunto de resultados.
|
|
|
+ Por padrão, essa é a primeira coluna, indexada por 0.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <emphasis>Zend_Db::FETCH_OBJ</emphasis>:
|
|
|
+ retorna dados em um matriz de objetos. A classe padrão
|
|
|
+ é a classe interna <acronym>PHP</acronym> stdClass. Colunas do conjunto de resultados
|
|
|
+ estão disponíveis como propriedades públicas do
|
|
|
+ objeto.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetch-mode.example">
|
|
|
+ <title>Usando setFetchMode()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->setFetchMode(Zend_Db::FETCH_OBJ);
|
|
|
+
|
|
|
+$result = $db->fetchAll('SELECT * FROM bugs WHERE bug_id = ?', 2);
|
|
|
+
|
|
|
+// $result é um matriz de objetos
|
|
|
+echo $result[0]->bug_description;
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchassoc">
|
|
|
+
|
|
|
+ <title>Buscando um Conjunto de Resultados como um matriz Associativo</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>fetchAssoc()</methodname> retorna dados em um matriz
|
|
|
+ de matrizs associativos, independente de qual valor você tenha configurado
|
|
|
+ para o modo de busca.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchassoc.example">
|
|
|
+ <title>Usando fetchAssoc()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->setFetchMode(Zend_Db::FETCH_OBJ);
|
|
|
+
|
|
|
+$result = $db->fetchAssoc('SELECT * FROM bugs WHERE bug_id = ?', 2);
|
|
|
+
|
|
|
+// $result é um matriz de matrizs associativos, conforme o modo de busca
|
|
|
+echo $result[0]['bug_description'];
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchcol">
|
|
|
+
|
|
|
+ <title>Buscando uma Única Coluna a partir de um Conjunto de Resultados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>fetchCol()</methodname> retorna dados em um matriz
|
|
|
+ de valores, independente do valor que você tenha configurado para o modo de busca
|
|
|
+ Ele devolve somente a primeira coluna devolvida pela consulta.
|
|
|
+ Quaisquer outras colunas devolvidas pela consulta são descartadas.
|
|
|
+ Se você precisar devolver uma outra coluna que não seja a primeira, veja
|
|
|
+ <xref linkend="zend.db.statement.fetching.fetchcolumn" />.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchcol.example">
|
|
|
+ <title>Usando fetchCol()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->setFetchMode(Zend_Db::FETCH_OBJ);
|
|
|
+
|
|
|
+$result = $db->fetchCol(
|
|
|
+ 'SELECT bug_description, bug_id FROM bugs WHERE bug_id = ?', 2);
|
|
|
+
|
|
|
+// contém bug_description; bug_id não é devolvida
|
|
|
+echo $result[0];
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchpairs">
|
|
|
+
|
|
|
+ <title>Buscando Pares Chave-Valor a partir de um Conjunto de Resultados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>fetchPairs()</methodname> retorna dados em um matriz
|
|
|
+ de pares chave-valor, como um matriz associativo com uma entrada única
|
|
|
+ por linha. A chave desse matriz associativo é tomada da
|
|
|
+ primeira coluna devolvida pela consulta <acronym>SELECT</acronym>. O valor é tomado
|
|
|
+ da segunda coluna devolvida pela consulta <acronym>SELECT</acronym>. Quaisquer outras
|
|
|
+ colunas devolvidas pela consulta são descartadas.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você deve projetar a conuslta <acronym>SELECT</acronym> de modo que a primeira coluna
|
|
|
+ devolvida tenha valores únicos. Se há valores duplicados na
|
|
|
+ primeira coluna, entradas no matriz associativo serão
|
|
|
+ sobrescritas.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchpairs.example">
|
|
|
+ <title>Usando fetchPairs()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->setFetchMode(Zend_Db::FETCH_OBJ);
|
|
|
+
|
|
|
+$result = $db->fetchPairs('SELECT bug_id, bug_status FROM bugs');
|
|
|
+
|
|
|
+echo $result[2];
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchrow">
|
|
|
+
|
|
|
+ <title>Buscando uma Linha Única a partir de um Conjunto de Resultados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>fetchRow()</methodname> retorna dados usando o
|
|
|
+ modo de busca atual, mas retorna somente a primeira linha
|
|
|
+ buscada a partir do conjunto de resultados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchrow.example">
|
|
|
+ <title>Using fetchRow()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->setFetchMode(Zend_Db::FETCH_OBJ);
|
|
|
+
|
|
|
+$result = $db->fetchRow('SELECT * FROM bugs WHERE bug_id = 2');
|
|
|
+
|
|
|
+// note que $result é um único objeto, não um matriz de objetos
|
|
|
+echo $result->bug_description;
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.select.fetchone">
|
|
|
+
|
|
|
+ <title>Buscando um Escalar Único a partir de um Conjunto de Resultados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>fetchOne()</methodname> é como uma combinação
|
|
|
+ do método <methodname>fetchRow()</methodname> com o método <methodname>fetchCol()</methodname>,
|
|
|
+ no que ele retorna dados somente para a primeira linha buscada a partir
|
|
|
+ do conjunto de resultados, e retorna somente o valor da primeira
|
|
|
+ coluna naquela linha. Portanto ele retorna somente um único
|
|
|
+ valor escalar, nem um matriz nem um objeto.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.select.fetchone.example">
|
|
|
+ <title>Usando fetchOne()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$result = $db->fetchOne('SELECT bug_status FROM bugs WHERE bug_id = 2');
|
|
|
+
|
|
|
+// este é um valor string único
|
|
|
+echo $result;
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.write">
|
|
|
+
|
|
|
+ <title>Gravando Mudanças no Banco de Dados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode usar a classe adaptadora para gravar novos dados ou alterar
|
|
|
+ dados existentes em seu banco de dados. Esta seção descreve métodos para fazer essas
|
|
|
+ operações.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.write.insert">
|
|
|
+
|
|
|
+ <title>Incluindo Dados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode adicionar novas linhas em uma tabela de seu banco de dados usando
|
|
|
+ o método <methodname>insert()</methodname>. O primeiro argumento é uma string
|
|
|
+ que denomina a tabela, e o segundo argumento é um matriz
|
|
|
+ associativo, mapeando nomes de coluna para valores de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.insert.example">
|
|
|
+ <title>Incluindo em uma Tabela</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$data = matriz(
|
|
|
+ 'created_on' => '2007-03-22',
|
|
|
+ 'bug_description' => 'Something wrong',
|
|
|
+ 'bug_status' => 'NEW'
|
|
|
+);
|
|
|
+
|
|
|
+$db->insert('bugs', $data);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Colunas que você excluir do matriz de dados não serão especificadas para
|
|
|
+ o banco de dados. Portanto, elas seguem as mesmas regras que uma
|
|
|
+ declaração <acronym>SQL</acronym> <acronym>INSERT</acronym> segue: se a coluna
|
|
|
+ tem uma cláusula <acronym>DEFAULT</acronym>, a coluna leva o valor na linha
|
|
|
+ criada, caso contrário é deixado em um estado <acronym>NULL</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Por padrão, os valores em seu matriz de dados são incluídos usando
|
|
|
+ parâmetros. ISso reduz o risco de alguns tipos de problemas de
|
|
|
+ segurança. Você não precisa aplicar escaping ou quoting para valores
|
|
|
+ no matriz de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode precisar que valores no matriz de dados sejam tratados como expressões
|
|
|
+ <acronym>SQL</acronym>, caso no qual elas não devam sofrer quoting. Por
|
|
|
+ padrão, todos os valores de dados passados como strings são tratados como
|
|
|
+ literais string. Para especificar que o valor é uma expressão <acronym>SQL</acronym>
|
|
|
+ e portanto não deve sofrer quoting, passe o valor
|
|
|
+ no matriz de dados como um objeto do tipo <classname>Zend_Db_Expr</classname> em vez de
|
|
|
+ texto claro.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.insert.example2">
|
|
|
+ <title>Incluindo Expressões em uma Tabela</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$data = matriz(
|
|
|
+ 'created_on' => new Zend_Db_Expr('CURDATE()'),
|
|
|
+ 'bug_description' => 'Something wrong',
|
|
|
+ 'bug_status' => 'NEW'
|
|
|
+);
|
|
|
+
|
|
|
+$db->insert('bugs', $data);
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.write.lastinsertid">
|
|
|
+
|
|
|
+ <title>Recuperando um Valor Gerado</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Algumas marcas de <acronym>SGBDR</acronym> suportam autoincremento de chaves primárias.
|
|
|
+ Uma tabela definida desse modo gera um valor de chave primária
|
|
|
+ automaticamente durante um <acronym>INSERT</acronym> de uma nova linha. O valor de retorno
|
|
|
+ do método <methodname>insert()</methodname> <emphasis>não</emphasis> é
|
|
|
+ o último ID incluído, porque a tabela pode não ter uma
|
|
|
+ coluna de autoincremento. Em vez disso, o valor de retorno é o
|
|
|
+ número de linhas afetadas (geralmente 1).
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se sua tabela é definida com uma chave primária de autoincremento
|
|
|
+ você pode chamar o método <methodname>lastInsertId()</methodname> depois da
|
|
|
+ inclusão. Esse método retonra o último valor gerado no
|
|
|
+ escopo da conexão atual com o banco de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.lastinsertid.example-1">
|
|
|
+ <title>Usando lastInsertId() para uma Chave de Autoincremento</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->insert('bugs', $data);
|
|
|
+
|
|
|
+// retorna o último valor gerado por uma coluna de autoincremento
|
|
|
+$id = $db->lastInsertId();
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Algumas marcas de <acronym>SGBDR</acronym> suportam um objeto de sequencia, que gera
|
|
|
+ valores únicos para servir como valores da chave primária. Para suportar
|
|
|
+ sequencias, o método <methodname>lastInsertId()</methodname> aceita dois
|
|
|
+ argumentos string opcionais. Esses argumentos denominam a tabela e
|
|
|
+ a coluna, assumindo que você tenha seguido a convenção de que uma
|
|
|
+ sequencias é denominada usando os nomes de tabela e coluna para os quais
|
|
|
+ a sequencia gera valores, e um sufixo "_seq". Isso é
|
|
|
+ baseado na convenção usada pelo PostgreSQL quando nomeia
|
|
|
+ sequencias para colunas SERIAL. Por exemplo, uma tabela "bugs" com
|
|
|
+ a coluna de chave primária "bug_id" usaria uma sequencia denominada
|
|
|
+ "bugs_bug_id_seq".
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.lastinsertid.example-2">
|
|
|
+ <title>Usando lastInsertId() para uma Sequencia</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->insert('bugs', $data);
|
|
|
+
|
|
|
+// retorna o último valor gerado pela sequencia 'bugs_bug_id_seq'.
|
|
|
+$id = $db->lastInsertId('bugs', 'bug_id');
|
|
|
+
|
|
|
+// alternativamente, retorna o último valor gerado pela sequencia 'bugs_seq'.
|
|
|
+$id = $db->lastInsertId('bugs');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se o nome de seu objeto de sequencia não seguir essa convenção
|
|
|
+ de nomes, use o método <methodname>lastSequenceId()</methodname>
|
|
|
+ em seu lugar. Esse método leva um único argumento string, nomeando
|
|
|
+ literalmente a sequencia.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.lastinsertid.example-3">
|
|
|
+ <title>Usando lastSequenceId()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->insert('bugs', $data);
|
|
|
+
|
|
|
+// retorna o último valor gerado pela sequencia 'bugs_id_gen'.
|
|
|
+$id = $db->lastSequenceId('bugs_id_gen');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Para as marcas de <acronym>SGBDR</acronym> que não suportam sequencias, incluindo MySQL,
|
|
|
+ Microsoft <acronym>SQL</acronym> Server, e SQLite, os argumentos para
|
|
|
+ o método <methodname>lastInsertId()</methodname> são ignorados, e o valor devolvido
|
|
|
+ é o valor mais recente gerado para qualquer tabela por operações <acronym>INSERT</acronym>
|
|
|
+ durante a conexão atual. Para essas marcas de <acronym>SGBDR</acronym>,
|
|
|
+ o método <methodname>lastSequenceId()</methodname> sempre devolve
|
|
|
+ <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <note>
|
|
|
+ <title>Porque Não Usar "SELECT MAX(id) FROM table"?</title>
|
|
|
+ <para>
|
|
|
+ Algumas essa consulta retorna valor de chave primária mais recente
|
|
|
+ incluído em uma tabela. Entretanto, essa técnica
|
|
|
+ não é segura para ser usada em um ambiente onde múltiplos clientes estão
|
|
|
+ incluindo registros no banco de dados. É possível, e
|
|
|
+ portanto pode acontecer eventualmente, que outro
|
|
|
+ cliente inclua outra linha no instante entre a
|
|
|
+ inclusão executada por sua aplicação cliente e sua consulta
|
|
|
+ para o valor de <methodname>MAX(id)</methodname>. Assim o valor devolvido
|
|
|
+ não identifica a linha que você incluiu, mas sim a linha
|
|
|
+ incluída por algum outro cliente. Não há um modo de saber
|
|
|
+ quando isso aconteceu.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Usar um modo de isolamento de transação forte tal como
|
|
|
+ "repeatable read" pode mitigar esse risco, mas algumas marcas de <acronym>SGBDR</acronym>
|
|
|
+ não suportam o isolamento de transação necessário para
|
|
|
+ isso, ou sua aplicação pode usar um modo de isolamento
|
|
|
+ de transação baixo por projeto.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Além disso, usar uma expressão como "MAX (id) +1" para gerar
|
|
|
+ um novo valor para uma chave primária não é seguro, porque dois clientes
|
|
|
+ poderiam fazer esta consulta simultanamente, e em seguida, ambos usariam o mesma
|
|
|
+ valor calculado para sua próxima operação <acronym>INSERT</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Todas as marcas de <acronym>SGBDR</acronym> fornecem mecanismos para gerar
|
|
|
+ valores únicos e retornar o último valor gerado. Esses
|
|
|
+ mecanismos necessariamente trabalham fora do escopo de
|
|
|
+ isolamento da transação, portanto, não há chance de dois clientes
|
|
|
+ gerarem o mesmo valor, e não há chance de que o
|
|
|
+ valor gerado por um outro cliente possa ser informado à sua
|
|
|
+ conexão de cliente como o último valor gerado.
|
|
|
+ </para>
|
|
|
+ </note>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.write.update">
|
|
|
+ <title>Updating Data</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode atualizar linhas em uma tabela de banco de dados usando o
|
|
|
+ método <methodname>update()</methodname> de uma adaptadora. Esse método leva
|
|
|
+ três argumentos: o primeiro é o nome da tabela, o
|
|
|
+ segundo é um matriz associativo mapeando as colunas a serem alteradas para os novos
|
|
|
+ valores a serem atribuídos a essas colunas.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Os valores no matriz de dados são tratados como sequências de caracteres.
|
|
|
+ Veja <xref linkend="zend.db.adapter.write.insert" />
|
|
|
+ para obter informações sobre como utilizar expressões <acronym>SQL</acronym> no matriz de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O terceiro argumento é uma string contendo uma expressão <acronym>SQL</acronym>
|
|
|
+ que é usada como critério para as linhas a serem alteradas. Os valores
|
|
|
+ e identificadores nesse argumento não são citados ou escapados.
|
|
|
+ Você é responsável por garantir que o conteúdo dinâmico seja
|
|
|
+ interpolados para essa sequência de forma segura.
|
|
|
+ Veja <xref linkend="zend.db.adapter.quoting" />
|
|
|
+ para métodos que o ajudam a fazer isso.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O valor de retorno é o número de linhas afetadas pela operação
|
|
|
+ de atualização.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.update.example">
|
|
|
+ <title>Atualizando Linhas</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$data = matriz(
|
|
|
+ 'updated_on' => '2007-03-23',
|
|
|
+ 'bug_status' => 'FIXED'
|
|
|
+);
|
|
|
+
|
|
|
+$n = $db->update('bugs', $data, 'bug_id = 2');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você omitir o terceiro argumento, então todas as linhas na tabela
|
|
|
+ do banco de dados são atualizadas com os valores especificados no matriz de dados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você fornecer um matriz de strings como terceiro argumento, essas
|
|
|
+ strings são unidas como termos em uma expressão separada
|
|
|
+ por operadores <constant>AND</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você fornecer um matriz de matrizs como terceiro argumento, os
|
|
|
+ valores serão automaticamente citados dentro das chaves. Esses
|
|
|
+ serão então unidos como termos, separados por
|
|
|
+ operadores <constant>AND</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.update.example-array">
|
|
|
+ <title>Atualizando Linhas Usando um matriz de Expressões</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$data = matriz(
|
|
|
+ 'updated_on' => '2007-03-23',
|
|
|
+ 'bug_status' => 'FIXED'
|
|
|
+);
|
|
|
+
|
|
|
+$where[] = "reported_by = 'goofy'";
|
|
|
+$where[] = "bug_status = 'OPEN'";
|
|
|
+
|
|
|
+$n = $db->update('bugs', $data, $where);
|
|
|
+
|
|
|
+// A SQL resultante é:
|
|
|
+// UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
|
|
|
+// WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.update.example-arrayofarrays">
|
|
|
+ <title>Atualizando Linhas Usando um matriz de matrizs</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$data = matriz(
|
|
|
+ 'updated_on' => '2007-03-23',
|
|
|
+ 'bug_status' => 'FIXED'
|
|
|
+);
|
|
|
+
|
|
|
+$where['reported_by = ?'] = 'goofy';
|
|
|
+$where['bug_status = ?'] = 'OPEN';
|
|
|
+
|
|
|
+$n = $db->update('bugs', $data, $where);
|
|
|
+
|
|
|
+// A SQL resultante é:
|
|
|
+// UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
|
|
|
+// WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.write.delete">
|
|
|
+ <title>Excluindo Dados</title>
|
|
|
+ <para>
|
|
|
+ Você pode excluir linhas de uma tabela de banco de dados usando o
|
|
|
+ método <methodname>delete()</methodname>methodName>. Esse método leva dois argumentos:
|
|
|
+ O primeiro é uma string com o nome da tabela.
|
|
|
+
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O segundo argumento é uma string contendo uma expressão <acronym>SQL</acronym>
|
|
|
+ que é usada como critério para as linhas a eliminar. Os valores
|
|
|
+ e identificadores nesse argumento não são citados ou escapado.
|
|
|
+ Você é responsável por garantir que o conteúdo dinâmico seja
|
|
|
+ interpolado para esta seqüência de forma segura.
|
|
|
+ Veja <xref linkend="zend.db.adapter.quoting" />
|
|
|
+ para métodos que o ajudam a fazer isso.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O valor de retorno é o número de linhas afetadas pela operação
|
|
|
+ de exclusão.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.write.delete.example">
|
|
|
+ <title>Excluindo Linhas</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$n = $db->delete('bugs', 'bug_id = 3');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você omitir o segundo argumento, o resultado é que todas as linhas na
|
|
|
+ tabela do banco de dados são eliminadas.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você fornecer um matriz de strings como o segundo argumento, essas
|
|
|
+ strings são unidas como termos em uma expressão separada
|
|
|
+ por operadores <constant>AND</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se você fornecer um matriz de matrizs como segundo argumento, os
|
|
|
+ valores serão automaticamente citados dentro das chaves. Esses
|
|
|
+ serão então unidos como termos, separados por
|
|
|
+ operadores <constant>AND</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.quoting">
|
|
|
+
|
|
|
+ <title>Citando Valores e Identificadores</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ When you form <acronym>SQL</acronym> queries, often it is the case that you need to
|
|
|
+ include the values of <acronym>PHP</acronym> variables in <acronym>SQL</acronym>
|
|
|
+ expressions. This is risky, because if the value in a <acronym>PHP</acronym> string
|
|
|
+ contains certain symbols, such as the quote symbol, it could result in invalid
|
|
|
+ <acronym>SQL</acronym>. For example, notice the imbalanced quote characters in the
|
|
|
+ following query:
|
|
|
+
|
|
|
+ Quando você monta consultas <acronym>SQL</acronym>, muitas vezes é o caso de você precisar
|
|
|
+ incluir os valores de variáveis<acronym>PHP</acronym> em expressões <acronym>SQL</acronym>.
|
|
|
+ Isso é arriscado, porque se o valor em uma string <acronym>PHP</acronym>
|
|
|
+ contém certos símbolos, como o símbolo de citação, isso pode resultar em
|
|
|
+ <acronym>SQL</acronym> inválido. Por exemplo, observe os apóstrofos não balanceados na
|
|
|
+ seguinte consulta:
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$name = "O'Reilly";
|
|
|
+$sql = "SELECT * FROM bugs WHERE reported_by = '$name'";
|
|
|
+
|
|
|
+echo $sql;
|
|
|
+// SELECT * FROM bugs WHERE reported_by = 'O'Reilly'
|
|
|
+]]></programlisting>
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Ainda pior é o risco de tais erros de código possam ser explorados
|
|
|
+ deliberadamente por uma pessoa que está tentando manipular a função
|
|
|
+ de sua aplicação web. Se eles podem especificar o valor de uma variável <acronym>PHP</acronym>
|
|
|
+ través do uso de um parâmetro <acronym>HTTP</acronym> ou outro mecanismo,
|
|
|
+ eles podem ser capazes de fazer suas consultas <acronym>SQL</acronym> fazerem coisas que você
|
|
|
+ não pretendia que elas fizessem, tais retornar dados para a pessoa
|
|
|
+ que não deveria ter o privilégio de lê-los. Essa é uma técnica grave e generalizada
|
|
|
+ para violar a segurança do aplicativo, conhecido como "SQL Injection" (veja <ulink
|
|
|
+ url="http://en.wikipedia.org/wiki/SQL_Injection">http://en.wikipedia.org/wiki/SQL_Injection</ulink>).
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ A classe adaptadora <classname>Zend_Db</classname> fornece funções convenientes para ajudar
|
|
|
+ a reduzir as vulnerabilidades para ataques de Injeção de <acronym>SQL</acronym> em seu
|
|
|
+ código <acronym>PHP</acronym>. A solução é escapar caracteres especiais tais como apóstrofos
|
|
|
+ em valores <acronym>PHP</acronym> antes deles serem interpolados em suas
|
|
|
+ strings <acronym>SQL</acronym>. Isso protege tanto contra manipulação acidental quanto deliberada
|
|
|
+ de strings <acronym>SQL</acronym> por variáveis <acronym>PHP</acronym> que
|
|
|
+ contém caracteres especiais.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.quoting.quote">
|
|
|
+
|
|
|
+ <title>Usando quote()</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>quote()</methodname> aceita um único argumento, um
|
|
|
+ valor string escalar. Ele retorna o valor com
|
|
|
+ caracteres especiais de uma forma adequada para o <acronym>SGBDR</acronym> que você
|
|
|
+ está usando, e rodeado por delimitadores de valor de string. O
|
|
|
+ delimitador de valor de string padrão <acronym>SQL</acronym> é o apóstrofo
|
|
|
+ ( ').
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.quoting.quote.example">
|
|
|
+ <title>Usando quote()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$name = $db->quote("O'Reilly");
|
|
|
+echo $name;
|
|
|
+// 'O\'Reilly'
|
|
|
+
|
|
|
+$sql = "SELECT * FROM bugs WHERE reported_by = $name";
|
|
|
+
|
|
|
+echo $sql;
|
|
|
+// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Note que o valor de retorno de <methodname>quote()</methodname> inclui os
|
|
|
+ delimitadores de citação em torno da cadeia. Isso é diferente de
|
|
|
+ algumas funções que escapam caracteres especiais, mas não adicionam
|
|
|
+ os delimitadores de citação, por exemplo
|
|
|
+ <ulink url="http://www.php.net/mysqli_real_escape_string">mysql_real_escape_string()</ulink>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Os valores podem precisar ser citados ou não citados de acordo com o
|
|
|
+ contexto de tipo de dados <acronym>SQL</acronym> em que eles são usados. Por exemplo, em algumas
|
|
|
+ marcas de SGBDR, um valor inteiro não deve ser citado como uma string
|
|
|
+ se for comparado a uma coluna ou expressão do tipo inteiro.
|
|
|
+ Em outras palavras, o código seguinte é um erro em algumas implementações <acronym>SQL</acronym>,
|
|
|
+ assumindo que <property>intColumn</property> tem um tipo de dados
|
|
|
+ <acronym>SQL</acronym> <constant>INTEGER</constant>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+SELECT * FROM atable WHERE intColumn = '123'
|
|
|
+]]></programlisting>
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode usar o segundo argumento opcional para o
|
|
|
+ método <methodname>quote()</methodname> para aplicar citação seletivamente para
|
|
|
+ o tipo de dados <acronym>SQL</acronym> que você especificar.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.quoting.quote.example-2">
|
|
|
+ <title>Usando quote() com um Tipo SQL</title>
|
|
|
+
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$value = '1234';
|
|
|
+$sql = 'SELECT * FROM atable WHERE intColumn = '
|
|
|
+ . $db->quote($value, 'INTEGER');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Cada classe <classname>Zend_Db_Adapter</classname> tem codificada os nomes de
|
|
|
+ tipos de dados <acronym>SQL</acronym> numéricos para a respectiva marca de
|
|
|
+ <acronym>SGBDR</acronym>. Você também pode usar as constantes
|
|
|
+ <constant>Zend_Db::INT_TYPE</constant>, <constant>Zend_Db::BIGINT_TYPE</constant>,
|
|
|
+ e <constant>Zend_Db::FLOAT_TYPE</constant> para escrever código de uma forma mais
|
|
|
+ independente de <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ <classname>Zend_Db_Table</classname> especifica <acronym>SQL</acronym> para
|
|
|
+ <methodname>quote()</methodname> automaticamente ao gerar
|
|
|
+ consultas <acronym>SQL</acronym> que referenciam colunas-chave de uma tabela.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.quoting.quote-into">
|
|
|
+
|
|
|
+ <title>Usando quoteInto()</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O uso mais típico de citação é para interpolar uma variável <acronym>PHP</acronym>
|
|
|
+ em uma expressão ou declaração <acronym>SQL</acronym>. Você pode usar o
|
|
|
+ método <methodname>quoteInto()</methodname> para fazer isso em uma única etapa. Esse
|
|
|
+ método leva dois argumentos: o primeiro argumento é uma string
|
|
|
+ contendo um símbolo marcador (?), e o
|
|
|
+ segundo argumento é um valor ou variável <acronym>PHP</acronym> que deve ser
|
|
|
+ substituída pelo marcador.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O símbolo marcador é o mesmo símbolo usado por muitas marcas de <acronym>SGBDR</acronym>
|
|
|
+ para parâmetros posicionais, mas o
|
|
|
+ método <methodname>quoteInto()</methodname> apenas emula parâmetros de consulta.
|
|
|
+ O método simplesmente interpola o valor para a string,
|
|
|
+ escapa caracteres especiais, e aplica apóstrofos em torno dele.
|
|
|
+ Parâmetros de consulta verdadeiros mantêm a separação entre a string <acronym>SQL</acronym>
|
|
|
+ e os parâmetros assim que a declaração é analisada no
|
|
|
+ servidor <acronym>SGBDR</acronym>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.quoting.quote-into.example">
|
|
|
+ <title>Usando quoteInto()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$sql = $db->quoteInto("SELECT * FROM bugs WHERE reported_by = ?", "O'Reilly");
|
|
|
+
|
|
|
+echo $sql;
|
|
|
+// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Você pode usar o terceiro parâmetro opcional de
|
|
|
+ <methodname>quoteInto()</methodname> para especificar o tipo de dados <acronym>SQL</acronym>.
|
|
|
+ Tipos de dados numéricos não são citados, e outros tipos são citados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.quoting.quote-into.example-2">
|
|
|
+ <title>Using quoteInto() with a SQL Type</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$sql = $db
|
|
|
+ ->quoteInto("SELECT * FROM bugs WHERE bug_id = ?", '1234', 'INTEGER');
|
|
|
+
|
|
|
+echo $sql;
|
|
|
+// SELECT * FROM bugs WHERE reported_by = 1234
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+ <sect3 id="zend.db.adapter.quoting.quote-identifier">
|
|
|
+
|
|
|
+ <title>Usando quoteIdentifier()</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Os valores não são a única parte da sintaxe <acronym>SQL</acronym> que pode precisar
|
|
|
+ ser variável. Se você usar variáveis <acronym>PHP</acronym> para nomear tabelas, colunas,
|
|
|
+ ou outros identificadores em suas declarações <acronym>SQL</acronym>, pode ser necessário
|
|
|
+ citar essas strings também. Por padrão, identificadores <acronym>SQL</acronym> têm
|
|
|
+ regras de sintaxe como <acronym>PHP</acronym> e a maioria das outras linguagens de programação.
|
|
|
+ Por exemplo, os identificadores não devem conter espaços, certas
|
|
|
+ pontuações ou caracteres especiais, ou ainda caracteres internacionais.
|
|
|
+ Certas palavras também são reservadas para a sintaxe <acronym>SQL</acronym>, e não devem
|
|
|
+ ser usadas como identificadores.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ No entanto, <acronym>SQL</acronym> tem um recurso chamado
|
|
|
+ <emphasis>identificadores delimitados</emphasis>, que permite escolhas mais amplas para a
|
|
|
+ grafia de identificadores. Se você colocar um identificador <acronym>SQL</acronym> no
|
|
|
+ tipo adequado de aspas, pode usar identificadores com dados que seriam inválidos
|
|
|
+ sem as aspas. Identificadores delimitados podem conter espaços,
|
|
|
+ pontuação, ou caracteres internacionais. Você também pode usar palavras reservadas
|
|
|
+ da <acronym>SQL</acronym> se colocá-las em identificadores delimitados.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>quoteIdentifier()</methodname> trabalha como
|
|
|
+ <methodname>quote()</methodname>, mas ele aplica caracteres delimitadores
|
|
|
+ de identificador para a string de acordo com o tipo de adaptador que você
|
|
|
+ usar. Por exemplo, a <acronym>SQL</acronym> padrão usa aspas duplas (")
|
|
|
+ para delimitadores de identificador, e a maioria das marcas de <acronym>SGBDR</acronym>
|
|
|
+ marcas usam esse símbolo. O MySQL usa crase (`) por padrão. O
|
|
|
+ método <methodname>quoteIdentifier()</methodname> também escapa caracteres especiais
|
|
|
+ dentro do argumento string.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.quoting.quote-identifier.example">
|
|
|
+ <title>Usando quoteIdentifier()</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+// podemos deter um nome de tabela que é uma palavra reservada SQL
|
|
|
+$tableName = $db->quoteIdentifier("order");
|
|
|
+
|
|
|
+$sql = "SELECT * FROM $tableName";
|
|
|
+
|
|
|
+echo $sql
|
|
|
+// SELECT * FROM "order"
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Identificadores delimitados <acronym>SQL</acronym> são sensíveis à caixa, ao contrário
|
|
|
+ de identificadores não citados. Portanto, se você usar identificadores delimitados, você
|
|
|
+ deve usar a ortografia do identificador exatamente como ela é armazenada
|
|
|
+ no seu esquema, incluindo a caixa das letras.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Na maioria dos casos onde <acronym>SQL</acronym> é gerada dentro
|
|
|
+ de classes <classname>Zend_Db</classname>, o padrão é que todos os identificadores sejam
|
|
|
+ delimitados automaticamente. Você pode alterar esse comportamento com a opção
|
|
|
+ <constant>Zend_Db::AUTO_QUOTE_IDENTIFIERS </constant>. Especifique essa opção
|
|
|
+ ao instanciar o adaptador.
|
|
|
+ Veja <xref linkend="zend.db.adapter.connecting.parameters.example2" />.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.transactions">
|
|
|
+
|
|
|
+ <title>Controlando Transações de Banco de Dados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Bases de dados definem as operações como unidades lógicas de trabalho que podem ser
|
|
|
+ confirmadas ou revertidas como uma única mudança, mesmo que operem
|
|
|
+ em várias tabelas. Todas as consultas ao banco de dados são executadas no
|
|
|
+ no contexto de uma transação, mesmo se o driver de banco de dados as gerencia
|
|
|
+ implicitamente. Isso é chamado modo <emphasis>auto-commit</emphasis>,
|
|
|
+ no qual o driver de banco cria uma transação para cada
|
|
|
+ declaração que você executa, e confirma essa transação após sua
|
|
|
+ declaração <acronym>SQL</acronym> ser executada. Por padrão, todas
|
|
|
+ as classes adaptadoras <classname>Zend_Db</classname> operam em modo auto-commit.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ De forma alternativa, você pode especificar o início e resolução de uma
|
|
|
+ transação, e assim controlar quantas consultas <acronym>SQL</acronym> estão incluídas em
|
|
|
+ um único grupo que é confirmado (ou revertido) como uma única
|
|
|
+ transação. Use o método <methodname>beginTransaction()</methodname> para
|
|
|
+ iniciar uma transação. Posteriormente declarações <acronym>SQL</acronym> são executadas
|
|
|
+ no contexto da mesma transação, até que você o resolva explicitamente.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Para resolver a transação, use o método <methodname>commit()</methodname> ou
|
|
|
+ <methodname>rollBack()</methodname>. O método <methodname>commit()</methodname>
|
|
|
+ altera marcas feitas durante a sua transação como confirmadas, o que
|
|
|
+ significa que os efeitos dessas mudanças são mostrados em consultas executadas em
|
|
|
+ outras transações.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>rollBack()</methodname> faz o oposto: ele descarta
|
|
|
+ as alterações feitas durante a transação. As mudanças são
|
|
|
+ efetivamente desfeitas, e o estado dos dados retorna a como estava
|
|
|
+ antes de você começar sua transação. No entanto, a reversão de sua
|
|
|
+ transação não tem efeito sobre as mudanças feitas por outras transações
|
|
|
+ executadas simultaneamente.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Depois de resolver essa operação, <classname>Zend_Db_Adapter</classname>
|
|
|
+ retorna ao modo auto-commit, até que você chame
|
|
|
+ <methodname>beginTransaction()</methodname> novamente.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.transactions.example">
|
|
|
+ <title>Gerenciando uma Transação para Garantir Consistência</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+// Inicie uma transação explicitamente.
|
|
|
+$db->beginTransaction();
|
|
|
+
|
|
|
+try {
|
|
|
+ // Tenta executar uma ou mais consultas:
|
|
|
+ $db->query(...);
|
|
|
+ $db->query(...);
|
|
|
+ $db->query(...);
|
|
|
+
|
|
|
+ // Se todas tem sucesso, confirma a transação e todas as mudanças
|
|
|
+ // são confirmadas de uma vez.
|
|
|
+ $db->commit();
|
|
|
+
|
|
|
+} catch (Exception $e) {
|
|
|
+ // Se qualquer uma das consultas falhar e lançar uma exceção
|
|
|
+ // nós queremos desfazer a transação inteira, revertendo
|
|
|
+ // mudanças feitas na transação, mesmo aquelas que tiveram sucesso
|
|
|
+ // Assim todas as mudanças são confirmadas juntas, ou nenhuma é.
|
|
|
+ $db->rollBack();
|
|
|
+ echo $e->getMessage();
|
|
|
+}
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.list-describe">
|
|
|
+
|
|
|
+ <title>Listando e Descrevendo Tabelas</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>listTables()</methodname> retorna uma matriz de strings,
|
|
|
+ com os nomes de todas as tabelas do banco de dados atual.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ O método <methodname>describeTable()</methodname> retorna uma matriz associativa
|
|
|
+ de metadados sobre uma tabela. Especifique o nome da tabela
|
|
|
+ como uma string no primeiro argumento para este método. O segundo
|
|
|
+ argumento é opcional, e identifica o esquema no qual a tabela
|
|
|
+ existe.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ As chaves da matriz associativa retornada são os nomes das colunas
|
|
|
+ da tabela. O valor correspondente a cada coluna é também uma
|
|
|
+ matriz associativa, com as seguintes chaves e valores:
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <table frame="all" cellpadding="5" id="zend.db.adapter.list-describe.metadata">
|
|
|
+ <title>Campos de Metadados Devolvidos por describeTable()</title>
|
|
|
+ <tgroup cols="3" align="left" colsep="1" rowsep="1">
|
|
|
+ <thead>
|
|
|
+ <row>
|
|
|
+ <entry>Key</entry>
|
|
|
+ <entry>Type</entry>
|
|
|
+ <entry>Description</entry>
|
|
|
+ </row>
|
|
|
+ </thead>
|
|
|
+ <tbody>
|
|
|
+ <row>
|
|
|
+ <entry><constant>SCHEMA_NAME</constant></entry>
|
|
|
+ <entry>(string)</entry>
|
|
|
+ <entry>Nome do esquema do banco de dados no qual essa tabela existe.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>TABLE_NAME</constant></entry>
|
|
|
+ <entry>(string)</entry>
|
|
|
+ <entry>Nome da tabela a qual esta coluna pertence.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>COLUMN_NAME</constant></entry>
|
|
|
+ <entry>(string)</entry>
|
|
|
+ <entry>Nome da coluna.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>COLUMN_POSITION</constant></entry>
|
|
|
+ <entry>(integer)</entry>
|
|
|
+ <entry>Posição ordinal da coluna na tabela.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>DATA_TYPE</constant></entry>
|
|
|
+ <entry>(string)</entry>
|
|
|
+ <entry>Nome do tipo de dados do SGBDR da coluna.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>DEFAULT</constant></entry>
|
|
|
+ <entry>(string)</entry>
|
|
|
+ <entry>Valor padrão para a coluna, se houver.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>NULLABLE</constant></entry>
|
|
|
+ <entry>(boolean)</entry>
|
|
|
+ <entry>
|
|
|
+ True se a coluna aceita <acronym>SQL</acronym> NULLs, false se a
|
|
|
+ coluna não tem uma restrição NOT NULL.
|
|
|
+ </entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>LENGTH</constant></entry>
|
|
|
+ <entry>(integer)</entry>
|
|
|
+ <entry>
|
|
|
+ Comprimento ou tamanho da coluna como informado pelo
|
|
|
+ <acronym>SGBDR</acronym>.
|
|
|
+ </entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>SCALE</constant></entry>
|
|
|
+ <entry>(integer)</entry>
|
|
|
+ <entry>
|
|
|
+ Escala de tipo <acronym>SQL</acronym> NUMERIC ou <constant>DECIMAL</constant>.
|
|
|
+ </entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>PRECISION</constant></entry>
|
|
|
+ <entry>(integer)</entry>
|
|
|
+ <entry>
|
|
|
+ Precisão de tipo <acronym>SQL</acronym> NUMERIC ou
|
|
|
+ <constant>DECIMAL</constant>.
|
|
|
+ </entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>UNSIGNED</constant></entry>
|
|
|
+ <entry>(boolean)</entry>
|
|
|
+ <entry>
|
|
|
+ True se um tipo baseado em inteiro for informado como
|
|
|
+ <constant>UNSIGNED</constant>.
|
|
|
+ </entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>PRIMARY</constant></entry>
|
|
|
+ <entry>(boolean)</entry>
|
|
|
+ <entry>True se a coluna é parte da chave primária dessa tabela.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>PRIMARY_POSITION</constant></entry>
|
|
|
+ <entry>(integer)</entry>
|
|
|
+ <entry>Posição ordinal (baseada em 1) da coluna na chave primária.</entry>
|
|
|
+ </row>
|
|
|
+ <row>
|
|
|
+ <entry><constant>IDENTITY</constant></entry>
|
|
|
+ <entry>(boolean)</entry>
|
|
|
+ <entry>True se a coluna usa um valor autogerado.</entry>
|
|
|
+ </row>
|
|
|
+ </tbody>
|
|
|
+ </tgroup>
|
|
|
+ </table>
|
|
|
+
|
|
|
+ <note>
|
|
|
+ <title>Como o Campo de Metadados IDENTITY Relaciona-se com SGBDRs Específicos</title>
|
|
|
+ <para>
|
|
|
+ O campo de metadados IDENTITY foi escolhido como um termo 'idiomático' para
|
|
|
+ representar uma relação de chaves substitutas. Este campo pode ser
|
|
|
+ vulgarmente conhecido pelos seguintes valores: --
|
|
|
+ </para>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <constant>IDENTITY</constant> - DB2, MSSQL
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <constant>AUTO_INCREMENT</constant> - MySQL
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <constant>SERIAL</constant> - PostgreSQL
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <constant>SEQUENCE</constant> - Oracle
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </note>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Se não houver nenhum tabela que se encaixe com o nome da tabela e nome de esquema opcional
|
|
|
+ especificado, então <methodname>describeTable()</methodname> retorna uma matriz vazia.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.closing">
|
|
|
+
|
|
|
+ <title>Fechando uma Conexão</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Normalmente não é necessário fechar uma conexão de dados. <acronym>PHP</acronym>
|
|
|
+ limpa automaticamente todos os recursos ao final de uma requisição.
|
|
|
+ Extensões de Banco de Dados são projetadas para fechar a conexão assim que a
|
|
|
+ referência para o objeto do recurso é eliminada.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ No entanto, se você tem um script de longa duração <acronym>PHP</acronym> que inicia muitas
|
|
|
+ conexões de banco de dados, talvez seja necessário encerrar a conexão, para evitar
|
|
|
+ um esgotamento da capacidade de seu servidor <acronym>SGBDR</acronym>. Você pode usar o
|
|
|
+ método <methodname>closeConnection()</methodname> da classe adaptadora fechar explicitamente
|
|
|
+ a conexão de dados subjacente.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Desde a versão 1.7.2, você pode verificar se está conectado ao
|
|
|
+ servidor <acronym>SGBDR</acronym> com o método <methodname>isConnected()</methodname>.
|
|
|
+ Isso significa que um recurso de conexão foi iniciado e não foi fechado. Essa
|
|
|
+ função não é atualmente capaz de testar, por exemplo, um fechamento do lado servidor
|
|
|
+ da conexão. Ela é usada internamente para fechar a conexão. Isso permite que você feche a
|
|
|
+ conexão várias vezes sem erros. Já era o caso antes de 1.7.2 para adaptadores
|
|
|
+ <acronym>PDO</acronym>, mas não para os outros.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.closing.example">
|
|
|
+ <title>Fechando uma Conexão com o Banco de Dados</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db->closeConnection();
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <note>
|
|
|
+ <title>Zend_Db Suporta Conexões Persistentes?</title>
|
|
|
+ <para>
|
|
|
+ Sim, a persistência é suportada através da adição da
|
|
|
+ propriedade <property> persistent</property> definida como true na
|
|
|
+ configuração (não em driver_configuration) de um adaptador
|
|
|
+ em <classname>Zend_Db</classname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.connecting.persistence.example">
|
|
|
+ <title>Usando a Propriedade Persitence com o Adaptador Oracle</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$db = Zend_Db::factory('Oracle', matriz(
|
|
|
+ 'host' => '127.0.0.1',
|
|
|
+ 'username' => 'webuser',
|
|
|
+ 'password' => 'xxxxxxxx',
|
|
|
+ 'dbname' => 'test',
|
|
|
+ 'persistent' => true
|
|
|
+));
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Please note that using persistent connections can cause an
|
|
|
+ excess of idle connections on the <acronym>SGBDR</acronym> server, which causes
|
|
|
+ more problems than any performance gain you might achieve by
|
|
|
+ reducing the overhead of making connections.
|
|
|
+
|
|
|
+ Por favor, note que o uso de conexões persistentes pode causar um
|
|
|
+ excesso de conexões inativas no servidor <acronym>SGBDR</acronym>, o que leva a
|
|
|
+ mais problemas do que qualquer ganho de desempenho que você possa obter por
|
|
|
+ reduzir a sobrecarga de fazer conexões.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Conexões de banco de dados tem estado. Isto é, alguns objetos no
|
|
|
+ servidor <acronym>SGBDR</acronym> existem no escopo de sessão.
|
|
|
+ Exemplos são bloqueios, variáveis de usuário,
|
|
|
+ tabelas temporárias, e informações sobre as consultas mais
|
|
|
+ recentemente executadas, tais como linhas afetadas e o último
|
|
|
+ valor gerado de id. Se você usa conexões persistentes, a sua
|
|
|
+ aplicação pode acessar dados inválidos ou privilegiadas que foram
|
|
|
+ criado em uma solicitação <acronym>PHP</acronym> anterior.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Atualmente, apenas Oracle, DB2, e os adaptadores <acronym>PDO</acronym> (onde
|
|
|
+ especificado pelo <acronym>PHP</acronym>) suportam persistência em
|
|
|
+ <classname>Zend_Db</classname>.
|
|
|
+ </para>
|
|
|
+ </note>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.other-statements">
|
|
|
+
|
|
|
+ <title>Rodando Outras Declarações de Banco de Dados</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Pode haver casos em que você precisa acessar o objeto de conexão
|
|
|
+ diretamente, como provido pela extensão de banco de dados <acronym>PHP</acronym>. Algumas
|
|
|
+ dessas extensões podem oferecer recursos que não são cobertos por
|
|
|
+ métodos de <classname>Zend_Db_Adapter_Abstract</classname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Por exemplo, todas as declarações <acronym>SQL</acronym> rodadas por <classname>Zend_Db</classname>
|
|
|
+ são preparadas, então executado. No entanto, algumas funções de banco de dados são incompatíveis com
|
|
|
+ declarações preparadas. Instruções DDL como CREATE e ALTER não podem
|
|
|
+ ser preparadas no MySQL. Além disso, declarações <acronym>SQL</acronym> não se beneficiam do
|
|
|
+ <ulink url="http://dev.mysql.com/doc/refman/5.1/en/query-cache-how.html">MySQL Query
|
|
|
+ Cache </ulink>, antes do MySQL 5.1.17.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ A maioria das extensões de banco de dados <acronym>PHP</acronym> fornecem um método para executar
|
|
|
+ declarações <acronym>SQL</acronym> sem prepará-los. Por exemplo, em
|
|
|
+ <acronym>PDO</acronym>, esse método é <methodname>exec()</methodname>. Você pode acessar
|
|
|
+ o objeto de conexão na extensão <acronym>PHP</acronym> diretamente usando
|
|
|
+ <methodname>getConnection()</methodname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.other-statements.example">
|
|
|
+ <title>Rodando uma Declaração Não Preparada em um Adaptador PDO</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$result = $db->getConnection()->exec('DROP TABLE bugs');
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ A maioria das extensões de banco de dados <acronym>PHP</acronym> fornecem um método para executar
|
|
|
+ declarações <acronym>SQL</acronym> sem prepará-los. Por exemplo, em
|
|
|
+ <acronym>PDO</acronym>, esse método é <methodname>exec()</methodname>. Você pode acessar
|
|
|
+ o objeto de conexão na extensão <acronym>PHP</acronym> diretamente usando
|
|
|
+ <methodname>getConnection()</methodname>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ In future versions of <classname>Zend_Db</classname>, there will be opportunities to
|
|
|
+ add method entry points for functionality that is common to
|
|
|
+ the supported <acronym>PHP</acronym> database extensions. This will not affect
|
|
|
+ backward compatibility.
|
|
|
+
|
|
|
+ Em versões futuras de <classname>Zend_Db</classname>, haverá oportunidades de
|
|
|
+ adicionar pontos de entrada de método para funcionalidades que são comuns às
|
|
|
+ extensões de banco de dados <acronym>PHP</acronym> suportadas . Isso não afetará
|
|
|
+ compatibilidade com versões anteriores.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.server-version">
|
|
|
+ <title>Recuperanco a Versão do Servidor</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Desde a versão 1.7.2, você pode recuperar a versão do servidor no estilo de sintaxe <acronym>PHP</acronym>
|
|
|
+ para ser capaz de usar <methodname>version_compare()</methodname>. Se a
|
|
|
+ informação não estiver disponível, você receberá <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <example id="zend.db.adapter.server-version.example">
|
|
|
+ <title>Verificando a versão do servidor antes de rodar uma consulta</title>
|
|
|
+ <programlisting language="php"><![CDATA[
|
|
|
+$version = $db->getServerVersion();
|
|
|
+if (!is_null($version)) {
|
|
|
+ if (version_compare($version, '5.0.0', '>=')) {
|
|
|
+ // faz alguma coisa
|
|
|
+ } else {
|
|
|
+ // faz alguma outra coisa
|
|
|
+ }
|
|
|
+} else {
|
|
|
+ // impossível ler a versão do servidor
|
|
|
+}
|
|
|
+]]></programlisting>
|
|
|
+ </example>
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+ <sect2 id="zend.db.adapter.adapter-notes">
|
|
|
+
|
|
|
+ <title>Notas sobre Adaptadores Específicos</title>
|
|
|
+
|
|
|
+ <para>
|
|
|
+ Esta seção lista diferenças entre as classes adaptadoras sobre as quais
|
|
|
+ você deve ficar atento.
|
|
|
+ </para>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.ibm-db2">
|
|
|
+ <title>IBM DB2</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique esse adaptador para o método <methodname>factory()</methodname> com
|
|
|
+ o nome 'Db2'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa a extensão <acronym>PHP</acronym> ibm_db2.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ IBM DB2 suporta tanto seqüências quanto chaves de autoincremento.
|
|
|
+ Portanto os argumentos para
|
|
|
+ <methodname>lastInsertId()</methodname> são opcionais. Se você não fornecer
|
|
|
+ argumentos, o adaptador retorna o último valor
|
|
|
+ gerado para uma chave de autoincremento. Se você fornecer
|
|
|
+ argumentos, o adaptador retorna o último valor gerado
|
|
|
+ pela seqüência nomeada de acordo com a convenção
|
|
|
+ '<emphasis>table</emphasis>_<emphasis>column</emphasis>_seq'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.mysqli">
|
|
|
+ <title>MySQLi</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique esse adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome 'Mysqli'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador utiliza a extensão <acronym>PHP</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ O MySQL não suporta sequências, assim
|
|
|
+ <methodname>lastInsertId()</methodname> ignora seus argumentos e
|
|
|
+ sempre retorna o último valor gerado para uma
|
|
|
+ chave de autoincremento. O método <methodname>lastSequenceId()</methodname>
|
|
|
+ retorna <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.oracle">
|
|
|
+ <title>Oracle</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique esse adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome de 'Oracle'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Esse adaptador usa a extensão <acronym>PHP</acronym> oci8.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Oracle não suporta chaves de autoincremento, assim você
|
|
|
+ deve especificar o nome de uma sequência de
|
|
|
+ <methodname>lastInsertId()</methodname> ou
|
|
|
+ <methodname>lastSequenceId()</methodname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ A extensão da Oracle não suporta parâmetros
|
|
|
+ posicionais. Você deve usar parâmetros nomeados.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Atualmente, a opção <constant>Zend_Db::CASE_FOLDING</constant>
|
|
|
+ não é suportada pelo adaptador Oracle. Para utilizar essa
|
|
|
+ opção com a Oracle, você deve usar o adaptador <acronym>PDO</acronym> OCI.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Por padrão, os campos LOB são devolvidos como objetos OCI-Lob. Você pode
|
|
|
+ recuperá-los como string para todas as solicitações, utilizando as opções do driver
|
|
|
+ '<property>lob_as_string</property>' ou para uma solicitação particular, usando
|
|
|
+ <methodname>setLobAsString(boolean)</methodname> no adaptador ou na
|
|
|
+ declaração.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.sqlsrv">
|
|
|
+ <title>Microsoft SQL Server</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique esse adaptador para o método <methodname>factory()</methodname> com
|
|
|
+ o nome 'Sqlsrv'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Esse adaptador usa a extensão <acronym>PHP</acronym> sqlsrv.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Microsoft <acronym>SQL</acronym> Server não suporta sequências, assim
|
|
|
+ <methodname>lastInsertId()</methodname> ignora o argumento de chave primária e
|
|
|
+ retorna o último valor gerado para uma chave de autoincremento se um nome de tabela
|
|
|
+ for especificado ou o último id retornado por uma consulta de inserção. O
|
|
|
+ método <methodname>lastSequenceId()</methodname> retorna
|
|
|
+ <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <classname>Zend_Db_Adapter_Sqlsrv</classname> configur
|
|
|
+ <constant>QUOTED_IDENTIFIER ON</constant> imediatamente após conectar-se
|
|
|
+ a um servidor <acronym>SQL</acronym>. Isso faz com que o driver utilize o
|
|
|
+ o símbolo delimitador de identificador da <acronym>SQL</acronym> padrão
|
|
|
+ (<emphasis> "</emphasis>) em vez dos colchetes que a sintaxe do
|
|
|
+ <acronym>SQL</acronym> Server usa para delimitar identificadores.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Você pode especificar <property>driver_options</property> como uma chave na matriz de opções.
|
|
|
+ O valor pode ser uma coisa qualquer coisa daqui <ulink
|
|
|
+ url="http://msdn.microsoft.com/en-us/library/cc296161(SQL.90).aspx">http://msdn.microsoft.com/en-us/library/cc296161(SQL.90).aspx</ulink>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Você pode usar <methodname>setTransactionIsolationLevel()</methodname> para definir
|
|
|
+ nível de isolamento para a conexão atual. O valor pode ser
|
|
|
+ <constant>SQLSRV_TXN_READ_UNCOMMITTED</constant>,
|
|
|
+ <constant>SQLSRV_TXN_READ_COMMITTED</constant>,
|
|
|
+ <constant>SQLSRV_TXN_REPEATABLE_READ</constant>,
|
|
|
+ <constant>SQLSRV_TXN_SNAPSHOT</constant> ou
|
|
|
+ <constant>SQLSRV_TXN_SERIALIZABLE</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ As of Zend Framework 1.9, the minimal supported build of the
|
|
|
+ <acronym>PHP</acronym> <acronym>SQL</acronym> Server extension from
|
|
|
+ Microsoft is 1.0.1924.0. and the <acronym>MSSQL</acronym> Server Native
|
|
|
+ Client version 9.00.3042.00.
|
|
|
+
|
|
|
+ A partir de Zend Framework 1.9, a distribuição mínima suportada da
|
|
|
+ extesnão <acronym>PHP</acronym> para <acronym>SQL</acronym> Server
|
|
|
+ da Microsoft é a 1.0.1924.0. e o <acronym>MSSQL</acronym> Server Native
|
|
|
+ Client versão 9.00.3042.00.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-ibm">
|
|
|
+ <title>PDO para IBM DB2 e Informix Dynamic Server (IDS)</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique esse adaptador o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Ibm</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Esse adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_ibm.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Você deve usar pelo menos a versão da extensão PDO_IBM 1.2.2.
|
|
|
+ Se você tiver uma versão anterior desta extensão, você
|
|
|
+ deve atualizar a extensão PDO_IBM a partir da <acronym>PECL</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-mssql">
|
|
|
+ <title>PDO Microsoft SQL Server</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique este adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Mssql</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Esse adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_dblib.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Microsoft <acronym>SQL</acronym> Server não suporta sequências, assim
|
|
|
+ <methodname>lastInsertId()</methodname> ignora seus argumentos e
|
|
|
+ sempre retorna o último valor gerado para uma
|
|
|
+ chave de autoincremento. O método <methodname>lastSequenceId()</methodname>
|
|
|
+ retorna <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ If you are working with unicode strings in an encoding other than UCS-2
|
|
|
+ (such as UTF-8), you may have to perform a conversion in your application
|
|
|
+ code or store the data in a binary column. Please refer to <ulink
|
|
|
+ url="http://support.microsoft.com/kb/232580">Microsoft's Knowledge
|
|
|
+ Base</ulink> for more information.
|
|
|
+
|
|
|
+ Se você está trabalhando com strings Unicode em uma codificação diferente de UCS-2
|
|
|
+ (tal como UTF-8), você pode ter que realizar uma conversão no código de sua
|
|
|
+ aplicação ou armazenar os dados em uma coluna binária. Por favor, consulte a <ulink
|
|
|
+ url = "http://support.microsoft.com/kb/232580"> Base de Conhecimento da Microsoft</ulink> para mais informações.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ <classname>Zend_Db_Adapter_Pdo_Mssql</classname> configura
|
|
|
+ <constant>QUOTED_IDENTIFIER ON</constant> imediatamente depois de conectar-se a um
|
|
|
+ banco de dados <acronym>SQL</acronym> Server. Isso faz com que o driver utilize o
|
|
|
+ símbolo delimitador de identificador da <acronym>SQL</acronym> padrão ( ")
|
|
|
+ em vez dos colchetes que a sintaxe <acronym>SQL</acronym> Server
|
|
|
+ utiliza para delimitar identificadores.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Você pode especificar <property>pdoType</property> como uma chave na
|
|
|
+ matriz de opções. O valor pode ser "mssql" (o padrão),
|
|
|
+ "dblib", "FreeTDS", ou "Sybase". Essa opção afeta
|
|
|
+ o prefixo <acronym>DSN</acronym> que o adaptador usa quando constrói a string
|
|
|
+ <acronym>DSN</acronym>. Tanto "FreeTDS" quanto "sybase" implicam um prefixo
|
|
|
+ de "sybase:", que é usado para o conjunto de bibliotecas
|
|
|
+ <ulink url="http://www.freetds.org/">FreeTDS</ulink>.
|
|
|
+ Veja também
|
|
|
+ <ulink url="http://www.php.net/manual/en/ref.pdo-dblib.connection.php">
|
|
|
+ http://www.php.net/manual/en/ref.pdo-dblib.connection.php </ulink>
|
|
|
+ Para obter mais informações sobre os prefixos <acronym>DSN</acronym> utilizados neste driver.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-mysql">
|
|
|
+ <title>PDO MySQL</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique este adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Mysql</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_mysql.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ MySQL não suporta sequencias, assim
|
|
|
+ <methodname>lastInsertId()</methodname> ignora seus argumentos e
|
|
|
+ sempre retorna o último valor gerado para uma
|
|
|
+ chave de autoincremento. O método <methodname>lastSequenceId()</methodname>
|
|
|
+ retorna <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-oci">
|
|
|
+ <title>PDO Oracle</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique este adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Oci</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_oci.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Oracle não suporta chaves de autoincremento, assim você
|
|
|
+ deve especificar o nome de uma sequencia para
|
|
|
+ <methodname>lastInsertId()</methodname> ou
|
|
|
+ <methodname>lastSequenceId()</methodname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-pgsql">
|
|
|
+ <title>PDO PostgreSQL</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique este adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Pgsql</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_pgsql.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ PostgreSQL supporta tanto sequencias quanto chaves de
|
|
|
+ autoincremento. Portanto os argumentos para
|
|
|
+ <methodname>lastInsertId()</methodname> são opcionais. Se você não
|
|
|
+ fornecer argumentos, o adaptador retorna o último valor
|
|
|
+ gerado para uma chave de autoincremento. Se você fornecer
|
|
|
+ argumentos, o adaptador retorna o último valor gerado
|
|
|
+ pela sequencia nomeado de acordo com a convenção
|
|
|
+ '<emphasis>table</emphasis>_<emphasis>column</emphasis>_seq'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.pdo-sqlite">
|
|
|
+ <title>PDO SQLite</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Especifique este adaptador para o método <methodname>factory()</methodname>
|
|
|
+ com o nome '<classname>Pdo_Sqlite</classname>'.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa as extensões <acronym>PHP</acronym> pdo e pdo_sqlite.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ SQLite não suporta sequencias, assim
|
|
|
+ <methodname>lastInsertId()</methodname> ignora seus argumentos e
|
|
|
+ sempre retorna o último valor gerado para uma
|
|
|
+ chave de autoincremento. O método <methodname>lastSequenceId()</methodname>
|
|
|
+ retorna <constant>NULL</constant>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Para conectar-se com um banco de dados SQLite2, especifique
|
|
|
+ <command>'sqlite2' => true</command> na matriz de
|
|
|
+ parâmetros quando criar uma instância do adaptador
|
|
|
+ <classname>Pdo_Sqlite</classname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Para cpnectar-se com um banco de dados SQLite em memória,
|
|
|
+ especifique <command>'dbname' => ':memory:'</command> na
|
|
|
+ matriz de parâmetros quando criar uma instância do
|
|
|
+ adaptador <classname>Pdo_Sqlite</classname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Versões antigas do driver SQLite para <acronym>PHP</acronym> parecem não
|
|
|
+ suportar os comandos PRAGMA necessários para garantir que
|
|
|
+ nomes de coluna curtos sejam usados em conjuntos de resultados. Se você
|
|
|
+ tem problemas que seus conjuntos de resultados são retornados com
|
|
|
+ chaves da forma "tablename.columnname" quando você faz uma
|
|
|
+ consulta com junção, então você deve atualizar para a versão
|
|
|
+ atual do <acronym>PHP</acronym>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ <sect3 id="zend.db.adapter.adapter-notes.firebird">
|
|
|
+ <title>Firebird/Interbase</title>
|
|
|
+ <itemizedlist>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Este adaptador usa a extensão <acronym>PHP</acronym> php_interbase.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Firebird/Interbase não suporta chaves de autoincremento,
|
|
|
+ portanto, você deve especificar o nome de uma sequência para
|
|
|
+ <methodname>lastInsertId()</methodname> ou
|
|
|
+ <methodname>lastSequenceId()</methodname>.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ <listitem>
|
|
|
+ <para>
|
|
|
+ Atualmente, a opção <constant>Zend_Db::CASE_FOLDING</constant>
|
|
|
+ não é suportada pelo adaptador Firebird/InterBase.
|
|
|
+ Identificadores não citadas são automaticamente devolvidos em
|
|
|
+ maiúsculas.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+
|
|
|
+ <listitem>
|
|
|
+ <para>O nome do adaptador é <classname>ZendX_Db_Adapter_Firebird</classname>.</para>
|
|
|
+ <para>
|
|
|
+ Lembre-se de usar o parâmetro adapterNamespace com o valor
|
|
|
+ <classname>ZendX_Db_Adapter</classname>.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Recomendamos a atualização de <filename>gds32.dll</filename> (ou
|
|
|
+ equivalente Linux) empacotado junto com PHP, para a mesma versão do servidor. Para
|
|
|
+ Firebird o equivalente de <filename>gds32.dll</filename> é
|
|
|
+ <filename>fbclient.dll</filename>.
|
|
|
+ </para>
|
|
|
+ <para>
|
|
|
+ Por padrão todos os identificadores (nomes de tabela, campos) são devolvidos em caixa
|
|
|
+ alta.
|
|
|
+ </para>
|
|
|
+ </listitem>
|
|
|
+ </itemizedlist>
|
|
|
+ </sect3>
|
|
|
+
|
|
|
+ </sect2>
|
|
|
+
|
|
|
+</sect1>
|
|
|
+<!--
|
|
|
+vim:se ts=4 sw=4 et:
|
|
|
+-->
|
flaviogomesdasilvalisboa