Zend_Db ve alakalı sınıflar Zend Framework için basit SQL veritabanı arayüzü sağlamaktadır. Zend_Db_Adapter PHP uygulamalarınızı ilişkisel veri tabanı yönetim sistemlerine(RDBMS) bağlamak için kullanılan temel sınıftır. Farklı RDBMS'ler için farklı bağdaştırıcı sınıfları mevcut. Zend_Db sağlayıcıya özel PHP eklentileri ile genel arayüz arasında köprü oluşturarak , az bir emek ile PHP uygulamalarınızı bir kere yazıp farklı RDBMS'ler ile yerleştirilmesine yardım eder. Bağdaştırıcı sınıfının arayüzü PHP Data Objects eklentisinin arayüzüne benzer. Zend_Db takip eden RDPMS markaları için PDO sürücüsü bağdaştırıcı sınıfları sağlamaktadır: MySQL Microsoft SQL Server Oracle PostgreSQL SQLite Ek olarak , Zend_Db takip eden RDBMS markaları için PHP veritabanı eklentilerini kullanan bağdaştırıcı sınıfları sağlamaktadır: MySQL, mysqli PHP eklentisini kullanarak Oracle, oci8 PHP eklentisini kullanarak IBM DB2, ibm_db2 PHP eklentisini kullanarak Her Zend_Db bağdaştırıcısı PHP eklentisi kullanmaktadır. Zend_Db bağdaştırıcısını kullanabilmek için karşılık gelen PHP eklentisi PHP ortamınızda aktif durumda olmalıdır. Örneğin , PDO Zend_Db bağdaştırıcılarından herhangi birini kullandığınızda , PDO eklentisini ve kullandığınız marka RDBMS'in PDO sürücüsünü aktif hale getirmelisiniz. Bu kısım veritabanı bağdaştırıcısı instance'ı oluşturulmasını açıklar. Bu PHP uygulamanızdan RDBMS sunucunuza bağlantı yapmaya benzer. Bir bağdaştırıcının constructor'ını kullanarak bir bağdaştırıcının instance'ını oluşturabilirsiniz. Bağdaştırıcı constructor'ı bağlantıyı tanımlamak için paremetreler dizisi olan bir argüman almaktadır. '127.0.0.1', 'username' => 'webuser', 'password' => 'xxxxxxxx', 'dbname' => 'test' ));]]> Direk olarak Bağdaştırıcı constructor'ı kullanmaya alternatif olarak bağdaştırıcının statik metodunu Zend_Db::factory() kullanarak bağdaştırıcı instance'ı olşturulabilir.Bu metod istem sırasında Bağdaştırıcı sınıf dosyasını Zend_Loader::loadClass() kullanarak dinamik olarak yükler. İlk argüman Bağdaştırıcı sınıfının esas adını adlandıran string argümandır. Örneğin 'Pdo_Mysql' string'i Zend_Db_Adapter_Pdo_Mysql sınıfını karşılamaktadır. İkinci argüman aynı Bağdaştırıcı constructor'ına verilen paremetreler dizisi gibidir. '127.0.0.1', 'username' => 'webuser', 'password' => 'xxxxxxxx', 'dbname' => 'test' ));]]> Zend_Db_Adapter_Abstract sınıfını genişleten bir sınıf oluşturup , sınıf adını "Zend_Db_Adapter" paket öneki ile isimlendirmediyseniz bağdaştırınızı yüklemek için factory metodunu kullanamazsınız. Bağdaştırıcı sınıfını kendinizi yüklemeli ve instance'ını contructor'ı ile oluşturmalısınız. Aşağıdaki liste Zend_Db Bağdaştırıcı sınıfı tarafından tanımlanan genel paremetreleri açıklamaktadır. host: Veritabanı sunucusunun hostname'ini veya IP adresini barındıran string.Eğer veritabanı , PHP uygulaması ile aynı host'da çalışıyorsa 'localhost' veya '12.0.0.1' kullanabilirsiniz. username: RDBMS sunucusuna oturum açmayı sağlayan hesap tanımlayıcısı. password: RDBMS sunucuna oturum açmak için zorunlu olan hesap şifresi. dbname: RDBMS sunucusundaki veritabanı instance adı. port: Bazı RDBMS sunucuları yönetici tarafından belirlenen port numarasından ağ trafiği kabul edebilir. Port parametresi PHP uygulamanızın RDBMS sunucusunda tanımlı olan port numarası ile eşleşmesi için port numarasını belirlemeye yarar. options: Bu paremetre tüm Zend_Db_Adapter sınıflarına genel olan seçeneklerin birleşmeli dizisidir. driver_options: Bu parametre verilen veritabanı eklentisine ilişkin ek seçenekler birleşmeli dizisidir. Bu parametrenin bir tipik kullanımı ise PDO sürücüsünün özniteliklerini(attribute) vermektir. Bu seçeneği Zend_Db::CASE_FOLDING. sabiti ile belirtebilirsiniz. Bu , PDO ve IBM DB veritabanı sürücülerindeki sorgu sonuç setlerindeki string anahtarlarının küçük , büyük harf durumunu ayarlamaya yarayan ATTR_CASE özniteliğine karşılık gelmektedir. Bu seçeneğin aldığı değerler Zend_Db::CASE_NATURAL (varsayılan), Zend_Db::CASE_UPPER, ve Zend_Db::CASE_LOWER. Zend_Db::CASE_UPPER ); $params = array( 'host' => '127.0.0.1', 'username' => 'webuser', 'password' => 'xxxxxxxx', 'dbname' => 'test', 'options' => $options ); $db = Zend_Db::factory('Db2', $params);]]> Bu seçeneği Zend_Db::AUTO_QUOTE_IDENTIFIERS sabiti le belirtebilirsiniz. Eğer değer true ise , tablo isimleri , sütun isimleri , hatta alias'lar gibi tanımlayacılar Bağdaştırıcı nesnesi tarafından oluşturulan SQL sözdiziminde sınırlandırılır. Bu SQL kelimeleri veya özel karakter içeren tanımlayıcılar kullanmayı kolaylaştırır. Eğer değer false ise tanımlayıcılar otomatik olarak sınırlandırılmaz. Eğer tanımlayıcıları sınırlamanız gerekiyorsa quoteIdentifier() metodunu kullanarak kendiniz yapmalısınız. false ); $params = array( 'host' => '127.0.0.1', 'username' => 'webuser', 'password' => 'xxxxxxxx', 'dbname' => 'test', 'options' => $options ); $db = Zend_Db::factory('Pdo_Mysql', $params);]]> true ); $params = array( '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);]]> Bağdaştırıcı sınıfının instance'ı oluşturulurken RDBMS sunucusuna bağlantı hemen sağlanmaz. Bağdaştırıcı bağlantı paremetrelerini saklar ve ilk sorguyu çalıştırdığınız zaman fiili bağlantıyı gerçekleştirir. Bu Bağdaştırıcı nesnesi oluşturmanın hızlı ve ucuz olmasını sağlar. Eğer uygulamanız mevcut isteğe cevap verdiği zaman veritabanı sorguları çalıştırmanız gerektiğinden emin değilseniz bile Bağdaştırıcı sınıfı instance'ı oluşturabilirsiniz. Eğer Bağdaştırıcıyı RDBMS'e bağlanmaya zorlamanız gerekiyorsa , getConnection() metodunu kullanın. Bu metod kendi PHP veritabanı eklentisinde daha önce gösterildiği gibi bağlantı için nesne döndürür. Örneğin PDO sürücüleri için herhangi bir Bağdaştırıcı sınıfını kullandığınızda , getConnection() metodu kendine özgü veritabanına canlı bağlantı başlattıktan sonra PDO nesnesini döndürür. Geçersiz hesap bilgileri sunulması veya diğer RDBMS sunucusuna bağlantı problemleri sonucunda exception yakalamak için bağlanmaya zorlamak faydalı olabilir. Veritabanında ilk sorgu çalıştırıldığı zamandan ziyade bu exeption'lar bağlantı yapılana kadar ortaya çıkmaz, eğer exeptionları bir yerde idare ediyorsanız uygulama kodunuzu basitleştirmenize yardım edebilir. getConnection(); } catch (Zend_Db_Adapter_Exception $e) { // muhtemelen geçersiz oturum bilgisi ,veya belki de RDBMS çalışmıyor } catch (Zend_Exception $e) { // muhtemelen factory() belirli Bağdaştırıcı sınıfını yükleyemedi }]]> Zend_Db sınıfları için belgelerde sınıfların ve metodların kullanımını tasvir etmek için birtakım basit tablolar kullanıyoruz. Bu örnek tablolar bir yazılım geliştirme projesinde hataların takibi için bilgi depolayabilir. Veritabanı dört tablodan oluşuyor: accounts hata izleme veritabanında her kullanıcının bilgisini tutuyor. products hata raporlanabilecek herbir ürün hakkında bilgi tutuyor. bugs Hatalar hakkında bilgi tutuyor , hatanın şuanki durumu , hatayı raporlayan kişi , hatayı düzeltmek için atanmış kişi , düzeltmeyi doğrulamak için atanmış kişi. bugs_products Hatalar ile ürünler arasındaki ilişkiyi tutuyor. Bu çoktan çoğa (many-to-many) ilişkiselliği sağlar , çünkü verilen hata birden çok ürün ile ilgili olabilir , ve tabiki verilen ürünün birden çok hatası olabilir. Takip eden SQL veri tanımlama dili sözde kodu(pseudocode) örnek veritabanındaki tabloları açıklamaktadır. Bu örnek tablolar Zend_Db için otomatikleştirilmiş birim testleri(unit test) tarafından yaygınca kullanılmıştır. Ayrıca dikkat ederseniz bugs tablosu accounts tablosunu kaynak gösteren birçok foreign key içeriyor. Bu foreign key'lerin herbiri verilen hata için accounts tablosundaki farklı bir satırı kaynak gösterebilir. Aşağıdaki şema örnek veritabanının fiziksel veri modelini tasvir etmektedir. Bu bölüm SELECT sorguları çalıştırabileceğiniz ve sorgu sonuçlarına erişebileceğiniz Bağdaştırıcı sınıfı metodlarını açıklamaktadır. You can run a SQL SELECT query and retrieve its results in one step using the fetchAll() method. The first argument to this method is a string containing a SELECT statement. Alternatively, the first argument can be an object of class Zend_Db_Select. The Adapter automatically converts this object to a string representation of the SELECT statement. The second argument to fetchAll() is an array of values to substitute for parameter placeholders in the SQL statement. fetchAll($sql, 2);]]> By default, fetchAll() returns an array of rows, each of which is an associative array. The keys of the associative array are the columns or column aliases named in the select query. You can specify a different style of fetching results using the setFetchMode() method. The modes supported are identified by constants: Zend_Db::FETCH_ASSOC: return data in an array of associative arrays. The array keys are column names, as strings. This is the default fetch mode for Zend_Db_Adapter classes. Note that if your select-list contains more than one column with the same name, for example if they are from two different tables in a JOIN, there can be only one entry in the associative array for a given name. If you use the FETCH_ASSOC mode, you should specify column aliases in your SELECT query to ensure that the names result in unique array keys. By default, these strings are returned as they are returned by the database driver. This is typically the spelling of the column in the RDBMS server. You can specify the case for these strings, using the Zend_Db::CASE_FOLDING option. Specify this when instantiating the Adapter. See . Zend_Db::FETCH_NUM: return data in an array of arrays. The arrays are indexed by integers, corresponding to the position of the respective field in the select-list of the query. Zend_Db::FETCH_BOTH: return data in an array of arrays. The array keys are both strings as used in the FETCH_ASSOC mode, and integers as used in the FETCH_NUM mode. Note that the number of elements in the array is double that which would be in the array if you used iether FETCH_ASSOC or FETCH_NUM. Zend_Db::FETCH_COLUMN: return data in an array of values. The value in each array is the value returned by one column of the result set. By default, this is the first column, indexed by 0. Zend_Db::FETCH_OBJ: return data in an array of objects. The default class is the PHP built-in class stdClass. Columns of the result set are available as public properties of the object. setFetchMode(Zend_Db::FETCH_OBJ); $result = $db->fetchAll('SELECT * FROM bugs WHERE bug_id = ?', 2); // $result is an array of objects echo $result[0]->bug_description;]]> The fetchAssoc() method returns data in an array of associative arrays, regardless of what value you have set for the fetch mode. setFetchMode(Zend_Db::FETCH_OBJ); $result = $db->fetchAssoc('SELECT * FROM bugs WHERE bug_id = ?', 2); // $result is an array of associative arrays, in spite of the fetch mode echo $result[0]['bug_description'];]]> The fetchCol() method returns data in an array of values, regardless of the value you have set for the fetch mode. This only returns the first column returned by the query. Any other columns returned by the query are discarded. If you need to return a column other than the first, see . setFetchMode(Zend_Db::FETCH_OBJ); $result = $db->fetchCol('SELECT bug_description, bug_id FROM bugs WHERE bug_id = ?', 2); // contains bug_description; bug_id is not returned echo $result[0];]]> The fetchPairs() method returns data in an array of key-value pairs, as an associative array with a single entry per row. The key of this associative array is taken from the first column returned by the SELECT query. The value is taken from the second column returned by the SELECT query. Any other columns returned by the query are discarded. You should design the SELECT query so that the first column returned has unique values. If there are duplicates values in the first column, entries in the associative array will be overwritten. setFetchMode(Zend_Db::FETCH_OBJ); $result = $db->fetchPairs('SELECT bug_id, bug_status FROM bugs'); echo $result[2];]]> The fetchRow() method returns data using the current fetch mode, but it returns only the first row fetched from the result set. setFetchMode(Zend_Db::FETCH_OBJ); $result = $db->fetchRow('SELECT * FROM bugs WHERE bug_id = 2'); // note that $result is a single object, not an array of objects echo $result->bug_description;]]> The fetchOne() method is like a combination of fetchRow() with fetchCol(), in that it returns data only for the first row fetched from the result set, and it returns only the value of the first column in that row. Therefore it returns only a single scalar value, not an array or an object. fetchOne('SELECT bug_status FROM bugs WHERE bug_id = 2'); // this is a single string value echo $result;]]> You can use the Adapter class to write new data or change existing data in your database. This section describes methods to do these operations. You can add new rows to a table in your database using the insert() method. The first argument is a string that names the table, and the second argument is an associative array, mapping column names to data values. '2007-03-22', 'bug_description' => 'Something wrong', 'bug_status' => 'NEW' ); $db->insert('bugs', $data);]]> Columns you exclude from the array of data are not specified to the database. Therefore, they follow the same rules that an SQL INSERT statement follows: if the column has a DEFAULT clause, the column takes that value in the row created, otherwise the column is left in a NULL state. By default, the values in your data array are inserted using parameters. This reduces risk of some types of security issues. You don't need to apply escaping or quoting to values in the data array. You might need values in the data array to be treated as SQL expressions, in which case they should not be quoted. By default, all data values passed as strings are treated as string literals. To specify that the value is an SQL expression and therefore should not be quoted, pass the value in the data array as an object of type Zend_Db_Expr instead of a plain string. new Zend_Db_Expr('CURDATE()'), 'bug_description' => 'Something wrong', 'bug_status' => 'NEW' ); $db->insert('bugs', $data);]]> Some RDBMS brands support auto-incrementing primary keys. A table defined this way generates a primary key value automatically during an INSERT of a new row. The return value of the insert() method is not the last inserted ID, because the table might not have an auto-incremented column. Instead, the return value is the number of rows affected (usually 1). If your table is defined with an auto-incrementing primary key, you can call the lastInsertId() method after the insert. This method returns the last value generated in the scope of the current database connection. insert('bugs', $data); // return the last value generated by an auto-increment column $id = $db->lastInsertId();]]> Some RDBMS brands support a sequence object, which generates unique values to serve as primary key values. To support sequences, the lastInsertId() method accepts two optional string arguments. These arguments name the table and the column, assuming you have followed the convention that a sequence is named using the table and column names for which the sequence generates values, and a suffix "_seq". This is based on the convention used by PostgreSQL when naming sequences for SERIAL columns. For example, a table "bugs" with primary key column "bug_id" would use a sequence named "bugs_bug_id_seq". insert('bugs', $data); // return the last value generated by sequence 'bugs_bug_id_seq'. $id = $db->lastInsertId('bugs', 'bug_id'); // alternatively, return the last value generated by sequence 'bugs_seq'. $id = $db->lastInsertId('bugs');]]> If the name of your sequence object does not follow this naming convention, use the lastSequenceId() method instead. This method takes a single string argument, naming the sequence literally. insert('bugs', $data); // return the last value generated by sequence 'bugs_id_gen'. $id = $db->lastSequenceId('bugs_id_gen');]]> For RDBMS brands that don't support sequences, including MySQL, Microsoft SQL Server, and SQLite, the arguments to the lastInsertId() method are ignored, and the value returned is the most recent value generated for any table by INSERT operations during the current connection. For these RDBMS brands, the lastSequenceId() method always returns null. Sometimes this query returns the most recent primary key value inserted into the table. However, this technique is not safe to use in an environment where multiple clients are inserting records to the database. It is possible, and therefore is bound to happen eventually, that another client inserts another row in the instant between the insert performed by your client application and your query for the MAX(id) value. Thus the value returned does not identify the row you inserted, it identifies the row inserted by some other client. There is no way to know when this has happened. Using a strong transaction isolation mode such as "repeatable read" can mitigate this risk, but some RDBMS brands don't support the transaction isolation required for this, or else your application may use a lower transaction isolation mode by design. Furthermore, using an expression like "MAX(id)+1" to generate a new value for a primary key is not safe, because two clients could do this query simultaneously, and then both use the same calculated value for their next INSERT operation. All RDBMS brands provide mechanisms to generate unique values, and to return the last value generated. These mechanisms necessarily work outside of the scope of transaction isolation, so there is no chance of two clients generating the same value, and there is no chance that the value generated by another client could be reported to your client's connection as the last value generated. You can update rows in a database table using the update() method of an Adapter. This method takes three arguments: the first is the name of the table; the second is an associative array mapping columns to change to new values to assign to these columns. The values in the data array are treated as string literals. See for information on using SQL expressions in the data array. The third argument is a string containing an SQL expression that is used as criteria for the rows to change. The values and identifiers in this argument are not quoted or escaped. You are responsible for ensuring that any dynamic content is interpolated into this string safely. See for methods to help you do this. The return value is the number of rows affected by the update operation. '2007-03-23', 'bug_status' => 'FIXED' ); $n = $db->update('bugs', $data, 'bug_id = 2');]]> If you omit the third argument, then all rows in the database table are updated with the values specified in the data array. If you provide an array of strings as the third argument, these strings are joined together as terms in an expression separated by AND operators. '2007-03-23', 'bug_status' => 'FIXED' ); $where[] = "reported_by = 'goofy'"; $where[] = "bug_status = 'OPEN'"; $n = $db->update('bugs', $data, $where); // Resulting SQL is: // UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED' // WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')]]> You can delete rows from a database table using the delete() method. This method takes two arguments: the first is a string naming the table. The second argument is a string containing an SQL expression that is used as criteria for the rows to delete. The values and identifiers in this argument are not quoted or escaped. You are responsible for ensuring that any dynamic content is interpolated into this string safely. See for methods to help you do this. The return value is the number of rows affected by the delete operation. delete('bugs', 'bug_id = 3');]]> If you omit the second argument, the result is that all rows in the database table are deleted. If you provide an array of strings as the second argument, these strings are joined together as terms in an expression separated by AND operators. When you form SQL queries, often it is the case that you need to include the values of PHP variables in SQL expressions. This is risky, because if the value in a PHP string contains certain symbols, such as the quote symbol, it could result in invalid SQL. For example, notice the imbalanced quote characters in the following query: Even worse is the risk that such code mistakes might be exploited deliberately by a person who is trying to manipulate the function of your web application. If they can specify the value of a PHP variable through the use of an HTTP parameter or other mechanism, they might be able to make your SQL queries do things that you didn't intend them to do, such as return data to which the person should not have privilege to read. This is a serious and widespread technique for violating application security, known as "SQL Injection" (see http://en.wikipedia.org/wiki/SQL_Injection). The Zend_Db Adapter class provides convenient functions to help you reduce vulnerabilities to SQL Injection attacks in your PHP code. The solution is to escape special characters such as quotes in PHP values before they are interpolated into your SQL strings. This protects against both accidental and deliberate manipulation of SQL strings by PHP variables that contain special characters. The quote() method accepts a single argument, a scalar string value. It returns the value with special characters escaped in a manner appropriate for the RDBMS you are using, and surrounded by string value delimiters. The standard SQL string value delimiter is the single-quote ('). 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']]> Note that the return value of quote() includes the quote delimiters around the string. This is different from some functions that escape special characters but do not add the quote delimiters, for example mysql_real_escape_string(). Values may need to be quoted or not quoted according to the SQL datatype context in which they are used. For instance, in some RDBMS brands, an integer value must not be quoted as a string if it is compared to an integer-type column or expression. In other words, the following is an error in some SQL implementations, assuming intColumn has a SQL datatype of INTEGER You can use the optional second argument to the quote() method to apply quoting selectively for the SQL datatype you specify. quoteType($value, 'INTEGER'); ]]> Each Zend_Db_Adapter class has encoded the names of numeric SQL datatypes for the respective brand of RDBMS. You can also use the constants Zend_Db::INT_TYPE, Zend_Db::BIGINT_TYPE, and Zend_Db::FLOAT_TYPE to write code in a more RDBMS-independent way. Zend_Db_Table specifies SQL types to quote() automatically when generating SQL queries that reference a table's key columns. The most typical usage of quoting is to interpolate a PHP variable into a SQL expression or statement. You can use the quoteInto() method to do this in one step. This method takes two arguments: the first argument is a string containing a placeholder symbol (?), and the second argument is a value or PHP variable that should be substituted for that placeholder. The placeholder symbol is the same symbol used by many RDBMS brands for positional parameters, but the quoteInto() method only emulates query parameters. The method simply interpolates the value into the string, escapes special characters, and applies quotes around it. True query parameters maintain the separation between the SQL string and the parameters as the statement is parsed in the RDBMS server. quoteInto("SELECT * FROM bugs WHERE reported_by = ?", "O'Reilly"); echo $sql; // SELECT * FROM bugs WHERE reported_by = 'O\'Reilly']]> You can use the optional third parameter of quoteInto() to specify the SQL datatype. Numeric datatypes are not quoted, and other types are quoted. quoteInto("SELECT * FROM bugs WHERE bug_id = ?", '1234', 'INTEGER'); echo $sql; // SELECT * FROM bugs WHERE reported_by = 1234]]> Values are not the only part of SQL syntax that might need to be variable. If you use PHP variables to name tables, columns, or other identifiers in your SQL statements, you might need to quote these strings too. By default, SQL identifiers have syntax rules like PHP and most other programming languages. For example, identifiers should not contain spaces, certain punctuation or special characters, or international characters. Also certain words are reserved for SQL syntax, and should not be used as identifiers. However, SQL has a feature called delimited identifiers, which allows broader choices for the spelling of identifiers. If you enclose a SQL identifier in the proper types of quotes, you can use identifiers with spellings that would be invalid without the quotes. Delimited identifiers can contain spaces, punctuation, or international characters. You can also use SQL reserved words if you enclose them in identifier delimiters. The quoteIdentifier() method works like quote(), but it applies the identifier delimiter characters to the string according to the type of Adapter you use. For example, standard SQL uses double-quotes (") for identifier delimiters, and most RDBMS brands use that symbol. MySQL uses back-quotes (`) by default. The quoteIdentifier() method also escapes special characters within the string argument. quoteIdentifier("order"); $sql = "SELECT * FROM $tableName"; echo $sql // SELECT * FROM "order"]]> SQL delimited identifiers are case-sensitive, unlike unquoted identifiers. Therefore, if you use delimited identifiers, you must use the spelling of the identifier exactly as it is stored in your schema, including the case of the letters. In most cases where SQL is generated within Zend_Db classes, the default is that all identifiers are delimited automatically. You can change this behavior with the option Zend_Db::AUTO_QUOTE_IDENTIFIERS. Specify this when instantiating the Adapter. See . Databases define transactions as logical units of work that can be committed or rolled back as a single change, even if they operate on multiple tables. All queries to a database are executed within the context of a transaction, even if the database driver manages them implicitly. This is called auto-commit mode, in which the database driver creates a transaction for every statement you execute, and commits that transaction after your SQL statement has been executed. By default, all Zend_Db Adapter classes operate in auto-commit mode. Alternatively, you can specify the beginning and resolution of a transaction, and thus control how many SQL queries are included in a single group that is committed (or rolled back) as a single operation. Use the beginTransaction() method to initiate a transaction. Subsequent SQL statements are executed in the context of the same transaction until you resolve it explicitly. To resolve the transaction, use either the commit() or rollBack() methods. The commit() method marks changes made during your transaction as committed, which means the effects of these changes are shown in queries run in other transactions. The rollBack() method does the opposite: it discards the changes made during your transaction. The changes are effectively undone, and the state of the data returns to how it was before you began your transaction. However, rolling back your transaction has no effect on changes made by other transactions running concurrently. After you resolve this transaction, Zend_Db_Adapter returns to auto-commit mode until you call beginTransaction() again. beginTransaction(); try { // Attempt to execute one or more queries: $db->query(...); $db->query(...); $db->query(...); // If all succeed, commit the transaction and all changes // are committed at once. $db->commit(); } catch (Exception $e) { // If any of the queries failed and threw an exception, // we want to roll back the whole transaction, reversing // changes made in the transaction, even those that succeeded. // Thus all changes are committed together, or none are. $db->rollBack(); echo $e->getMessage(); }]]> The listTables() method returns an array of strings, naming all tables in the current database. The describeTable() method returns an associative array of metadata about a table. Specify the name of the table as a string in the first argument to this method. The second argument is optional, and names the schema in which the table exists. The keys of the associative array returned are the column names of the table. The value corresponding to each column is also an associative array, with the following keys and values: Key Type Description SCHEMA_NAME (string) Name of the database schema in which this table exists. TABLE_NAME (string) Name of the table to which this column belongs. COLUMN_NAME (string) Name of the column. COLUMN_POSITION (integer) Ordinal position of the column in the table. DATA_TYPE (string) RDBMS name of the datatype of the column. DEFAULT (string) Default value for the column, if any. NULLABLE (boolean) True if the column accepts SQL NULLs, false if the column has a NOT NULL constraint. LENGTH (integer) Length or size of the column as reported by the RDBMS. SCALE (integer) Scale of SQL NUMERIC or DECIMAL type. PRECISION (integer) Precision of SQL NUMERIC or DECIMAL type. UNSIGNED (boolean) True if an integer-based type is reported as UNSIGNED. PRIMARY (boolean) True if the column is part of the primary key of this table. PRIMARY_POSITION (integer) Ordinal position (1-based) of the column in the primary key. IDENTITY (boolean) True if the column uses an auto-generated value. If no table exists matching the table name and optional schema name specified, then describeTable() returns an empty array. Normally it is not necessary to close a database connection. PHP automatically cleans up all resources and the end of a request. Database extensions are designed to close the connection as the reference to the resource object is cleaned up. However, if you have a long-duration PHP script that initiates many database connections, you might need to close the connection, to avoid exhausting the capacity of your RDBMS server. You can use the Adapter's closeConnection() method to explicitly close the underlying database connection. closeConnection();]]> The usage of persistent connections is not supported or encouraged in Zend_Db. Using persistent connections can cause an excess of idle connections on the RDBMS server, which causes more problems than any performance gain you might achieve by reducing the overhead of making connections. Database connections have state. That is, some objects in the RDBMS server exist in session scope. Examples are locks, user variables, temporary tables, and information about the most recently executed query, such as rows affected, and last generated id value. If you use persistent connections, your application could access invalid or privileged data that were created in a previous PHP request. There might be cases in which you need to access the connection object directly, as provided by the PHP database extension. Some of these extensions may offer features that are not surfaced by methods of Zend_Db_Adapter_Abstract. For example, all SQL statements run by Zend_Db are prepared, then executed. However, some database features are incompatible with prepared statements. DDL statements like CREATE and ALTER cannot be prepared in MySQL. Also, SQL statements don't benefit from the MySQL Query Cache, prior to MySQL 5.1.17. Most PHP database extensions provide a method to execute SQL statements without preparing them. For example, in PDO, this method is exec(). You can access the connection object in the PHP extension directly using getConnection(). getConnection()->exec('DROP TABLE bugs');]]> Similarly, you can access other methods or properties that are specific to PHP database extensions. Be aware, though, that by doing this you might constrain your application to the interface provided by the extension for a specific brand of RDBMS. In future versions of Zend_Db, there will be opportunities to add method entry points for functionality that is common to the supported PHP database extensions. This will not affect backward compatibility. This section lists differences between the Adapter classes of which you should be aware. Specify this Adapter to the factory() method with the name 'Db2'. This Adapter uses the PHP extension ibm_db2. IBM DB2 supports both sequences and auto-incrementing keys. Therefore the arguments to lastInsertId() are optional. If you give no arguments, the Adapter returns the last value generated for an auto-increment key. If you give arguments, the Adapter returns the last value generated by the sequence named according to the convention 'table_column_seq'. Specify this Adapter to the factory() method with the name 'Mysqli'. This Adapter utilizes the PHP extension mysqli. MySQL does not support sequences, so lastInsertId() ignores its arguments and always returns the last value generated for an auto-increment key. The lastSequenceId() method returns null. Specify this Adapter to the factory() method with the name 'Oracle'. This Adapter uses the PHP extension oci8. Oracle does not support auto-incrementing keys, so you should specify the name of a sequence to lastInsertId() or lastSequenceId(). The Oracle extension does not support positional parameters. You must use named parameters. Currently the Zend_Db::CASE_FOLDING option is not supported by the Oracle adapter. To use this option with Oracle, you must use the PDO OCI adapter. Specify this Adapter to the factory() method with the name 'Pdo_Mssql'. This Adapter uses the PHP extensions pdo and pdo_mssql. Microsoft SQL Server does not support sequences, so lastInsertId() ignores its arguments and always returns the last value generated for an auto-increment key. The lastSequenceId() method returns null. Zend_Db_Adapter_Pdo_Mssql sets QUOTED_IDENTIFIER ON immediately after connecting to a SQL Server database. This makes the driver use the standard SQL identifier delimiter symbol (") instead of the proprietary square-brackets syntax SQL Server uses for delimiting identifiers. You can specify pdoType as a key in the options array. The value can be "mssql" (the default), "dblib", "freetds", or "sybase". This option affects the DSN prefix the adapter uses when constructing the DSN string. Both "freetds" and "sybase" imply a prefix of "sybase:", which is used for the FreeTDS set of libraries. See also http://www.php.net/manual/en/ref.pdo-dblib.connection.php for more information on the DSN prefixes used in this driver. Specify this Adapter to the factory() method with the name 'Pdo_Mysql'. This Adapter uses the PHP extensions pdo and pdo_mysql. MySQL does not support sequences, so lastInsertId() ignores its arguments and always returns the last value generated for an auto-increment key. The lastSequenceId() method returns null. Specify this Adapter to the factory() method with the name 'Pdo_Oci'. This Adapter uses the PHP extensions pdo and pdo_oci. Oracle does not support auto-incrementing keys, so you should specify the name of a sequence to lastInsertId() or lastSequenceId(). Specify this Adapter to the factory() method with the name 'Pdo_Pgsql'. This Adapter uses the PHP extensions pdo and pdo_pgsql. PostgreSQL supports both sequences and auto-incrementing keys. Therefore the arguments to lastInsertId() are optional. If you give no arguments, the Adapter returns the last value generated for an auto-increment key. If you give arguments, the Adapter returns the last value generated by the sequence named according to the convention 'table_column_seq'. Specify this Adapter to the factory() method with the name 'Pdo_Sqlite'. This Adapter uses the PHP extensions pdo and pdo_sqlite. SQLite does not support sequences, so lastInsertId() ignores its arguments and always returns the last value generated for an auto-increment key. The lastSequenceId() method returns null. To connect to an SQLite2 database, specify 'dsnprefix'=>'sqlite2' in the array of parameters when creating an instance of the Pdo_Sqlite Adapter. To connect to an in-memory SQLite database, specify 'dbname'=>':memory:' in the array of parameters when creating an instance of the Pdo_Sqlite Adapter. Older versions of the SQLite driver for PHP do not seem to support the PRAGMA commands necessary to ensure that short column names are used in result sets. If you have problems that your result sets are returned with keys of the form "tablename.columnname" when you do a join query, then you should upgrade to the current version of PHP.