PageRenderTime 55ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/Db/Table/Abstract.php

https://bitbucket.org/goldie/zend-framework1
PHP | 1534 lines | 775 code | 163 blank | 596 comment | 129 complexity | 35b7d18db279adf7571f3dc39812424c MD5 | raw file
  1. <?php
  2. /**
  3. * Zend Framework
  4. *
  5. * LICENSE
  6. *
  7. * This source file is subject to the new BSD license that is bundled
  8. * with this package in the file LICENSE.txt.
  9. * It is also available through the world-wide-web at this URL:
  10. * http://framework.zend.com/license/new-bsd
  11. * If you did not receive a copy of the license and are unable to
  12. * obtain it through the world-wide-web, please send an email
  13. * to license@zend.com so we can send you a copy immediately.
  14. *
  15. * @category Zend
  16. * @package Zend_Db
  17. * @subpackage Table
  18. * @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
  19. * @license http://framework.zend.com/license/new-bsd New BSD License
  20. * @version $Id: Abstract.php 24148 2011-06-21 15:14:00Z yoshida@zend.co.jp $
  21. */
  22. /**
  23. * @see Zend_Db_Adapter_Abstract
  24. */
  25. require_once 'Zend/Db/Adapter/Abstract.php';
  26. /**
  27. * @see Zend_Db_Adapter_Abstract
  28. */
  29. require_once 'Zend/Db/Select.php';
  30. /**
  31. * @see Zend_Db
  32. */
  33. require_once 'Zend/Db.php';
  34. /**
  35. * Class for SQL table interface.
  36. *
  37. * @category Zend
  38. * @package Zend_Db
  39. * @subpackage Table
  40. * @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
  41. * @license http://framework.zend.com/license/new-bsd New BSD License
  42. */
  43. abstract class Zend_Db_Table_Abstract
  44. {
  45. const ADAPTER = 'db';
  46. const DEFINITION = 'definition';
  47. const DEFINITION_CONFIG_NAME = 'definitionConfigName';
  48. const SCHEMA = 'schema';
  49. const NAME = 'name';
  50. const PRIMARY = 'primary';
  51. const COLS = 'cols';
  52. const METADATA = 'metadata';
  53. const METADATA_CACHE = 'metadataCache';
  54. const METADATA_CACHE_IN_CLASS = 'metadataCacheInClass';
  55. const ROW_CLASS = 'rowClass';
  56. const ROWSET_CLASS = 'rowsetClass';
  57. const REFERENCE_MAP = 'referenceMap';
  58. const DEPENDENT_TABLES = 'dependentTables';
  59. const SEQUENCE = 'sequence';
  60. const COLUMNS = 'columns';
  61. const REF_TABLE_CLASS = 'refTableClass';
  62. const REF_COLUMNS = 'refColumns';
  63. const ON_DELETE = 'onDelete';
  64. const ON_UPDATE = 'onUpdate';
  65. const CASCADE = 'cascade';
  66. const RESTRICT = 'restrict';
  67. const SET_NULL = 'setNull';
  68. const DEFAULT_NONE = 'defaultNone';
  69. const DEFAULT_CLASS = 'defaultClass';
  70. const DEFAULT_DB = 'defaultDb';
  71. const SELECT_WITH_FROM_PART = true;
  72. const SELECT_WITHOUT_FROM_PART = false;
  73. /**
  74. * Default Zend_Db_Adapter_Abstract object.
  75. *
  76. * @var Zend_Db_Adapter_Abstract
  77. */
  78. protected static $_defaultDb;
  79. /**
  80. * Optional Zend_Db_Table_Definition object
  81. *
  82. * @var unknown_type
  83. */
  84. protected $_definition = null;
  85. /**
  86. * Optional definition config name used in concrete implementation
  87. *
  88. * @var string
  89. */
  90. protected $_definitionConfigName = null;
  91. /**
  92. * Default cache for information provided by the adapter's describeTable() method.
  93. *
  94. * @var Zend_Cache_Core
  95. */
  96. protected static $_defaultMetadataCache = null;
  97. /**
  98. * Zend_Db_Adapter_Abstract object.
  99. *
  100. * @var Zend_Db_Adapter_Abstract
  101. */
  102. protected $_db;
  103. /**
  104. * The schema name (default null means current schema)
  105. *
  106. * @var array
  107. */
  108. protected $_schema = null;
  109. /**
  110. * The table name.
  111. *
  112. * @var string
  113. */
  114. protected $_name = null;
  115. /**
  116. * The table column names derived from Zend_Db_Adapter_Abstract::describeTable().
  117. *
  118. * @var array
  119. */
  120. protected $_cols;
  121. /**
  122. * The primary key column or columns.
  123. * A compound key should be declared as an array.
  124. * You may declare a single-column primary key
  125. * as a string.
  126. *
  127. * @var mixed
  128. */
  129. protected $_primary = null;
  130. /**
  131. * If your primary key is a compound key, and one of the columns uses
  132. * an auto-increment or sequence-generated value, set _identity
  133. * to the ordinal index in the $_primary array for that column.
  134. * Note this index is the position of the column in the primary key,
  135. * not the position of the column in the table. The primary key
  136. * array is 1-based.
  137. *
  138. * @var integer
  139. */
  140. protected $_identity = 1;
  141. /**
  142. * Define the logic for new values in the primary key.
  143. * May be a string, boolean true, or boolean false.
  144. *
  145. * @var mixed
  146. */
  147. protected $_sequence = true;
  148. /**
  149. * Information provided by the adapter's describeTable() method.
  150. *
  151. * @var array
  152. */
  153. protected $_metadata = array();
  154. /**
  155. * Cache for information provided by the adapter's describeTable() method.
  156. *
  157. * @var Zend_Cache_Core
  158. */
  159. protected $_metadataCache = null;
  160. /**
  161. * Flag: whether or not to cache metadata in the class
  162. * @var bool
  163. */
  164. protected $_metadataCacheInClass = true;
  165. /**
  166. * Classname for row
  167. *
  168. * @var string
  169. */
  170. protected $_rowClass = 'Zend_Db_Table_Row';
  171. /**
  172. * Classname for rowset
  173. *
  174. * @var string
  175. */
  176. protected $_rowsetClass = 'Zend_Db_Table_Rowset';
  177. /**
  178. * Associative array map of declarative referential integrity rules.
  179. * This array has one entry per foreign key in the current table.
  180. * Each key is a mnemonic name for one reference rule.
  181. *
  182. * Each value is also an associative array, with the following keys:
  183. * - columns = array of names of column(s) in the child table.
  184. * - refTableClass = class name of the parent table.
  185. * - refColumns = array of names of column(s) in the parent table,
  186. * in the same order as those in the 'columns' entry.
  187. * - onDelete = "cascade" means that a delete in the parent table also
  188. * causes a delete of referencing rows in the child table.
  189. * - onUpdate = "cascade" means that an update of primary key values in
  190. * the parent table also causes an update of referencing
  191. * rows in the child table.
  192. *
  193. * @var array
  194. */
  195. protected $_referenceMap = array();
  196. /**
  197. * Simple array of class names of tables that are "children" of the current
  198. * table, in other words tables that contain a foreign key to this one.
  199. * Array elements are not table names; they are class names of classes that
  200. * extend Zend_Db_Table_Abstract.
  201. *
  202. * @var array
  203. */
  204. protected $_dependentTables = array();
  205. protected $_defaultSource = self::DEFAULT_NONE;
  206. protected $_defaultValues = array();
  207. /**
  208. * Constructor.
  209. *
  210. * Supported params for $config are:
  211. * - db = user-supplied instance of database connector,
  212. * or key name of registry instance.
  213. * - name = table name.
  214. * - primary = string or array of primary key(s).
  215. * - rowClass = row class name.
  216. * - rowsetClass = rowset class name.
  217. * - referenceMap = array structure to declare relationship
  218. * to parent tables.
  219. * - dependentTables = array of child tables.
  220. * - metadataCache = cache for information from adapter describeTable().
  221. *
  222. * @param mixed $config Array of user-specified config options, or just the Db Adapter.
  223. * @return void
  224. */
  225. public function __construct($config = array())
  226. {
  227. /**
  228. * Allow a scalar argument to be the Adapter object or Registry key.
  229. */
  230. if (!is_array($config)) {
  231. $config = array(self::ADAPTER => $config);
  232. }
  233. if ($config) {
  234. $this->setOptions($config);
  235. }
  236. $this->_setup();
  237. $this->init();
  238. }
  239. /**
  240. * setOptions()
  241. *
  242. * @param array $options
  243. * @return Zend_Db_Table_Abstract
  244. */
  245. public function setOptions(Array $options)
  246. {
  247. foreach ($options as $key => $value) {
  248. switch ($key) {
  249. case self::ADAPTER:
  250. $this->_setAdapter($value);
  251. break;
  252. case self::DEFINITION:
  253. $this->setDefinition($value);
  254. break;
  255. case self::DEFINITION_CONFIG_NAME:
  256. $this->setDefinitionConfigName($value);
  257. break;
  258. case self::SCHEMA:
  259. $this->_schema = (string) $value;
  260. break;
  261. case self::NAME:
  262. $this->_name = (string) $value;
  263. break;
  264. case self::PRIMARY:
  265. $this->_primary = (array) $value;
  266. break;
  267. case self::ROW_CLASS:
  268. $this->setRowClass($value);
  269. break;
  270. case self::ROWSET_CLASS:
  271. $this->setRowsetClass($value);
  272. break;
  273. case self::REFERENCE_MAP:
  274. $this->setReferences($value);
  275. break;
  276. case self::DEPENDENT_TABLES:
  277. $this->setDependentTables($value);
  278. break;
  279. case self::METADATA_CACHE:
  280. $this->_setMetadataCache($value);
  281. break;
  282. case self::METADATA_CACHE_IN_CLASS:
  283. $this->setMetadataCacheInClass($value);
  284. break;
  285. case self::SEQUENCE:
  286. $this->_setSequence($value);
  287. break;
  288. default:
  289. // ignore unrecognized configuration directive
  290. break;
  291. }
  292. }
  293. return $this;
  294. }
  295. /**
  296. * setDefinition()
  297. *
  298. * @param Zend_Db_Table_Definition $definition
  299. * @return Zend_Db_Table_Abstract
  300. */
  301. public function setDefinition(Zend_Db_Table_Definition $definition)
  302. {
  303. $this->_definition = $definition;
  304. return $this;
  305. }
  306. /**
  307. * getDefinition()
  308. *
  309. * @return Zend_Db_Table_Definition|null
  310. */
  311. public function getDefinition()
  312. {
  313. return $this->_definition;
  314. }
  315. /**
  316. * setDefinitionConfigName()
  317. *
  318. * @param string $definition
  319. * @return Zend_Db_Table_Abstract
  320. */
  321. public function setDefinitionConfigName($definitionConfigName)
  322. {
  323. $this->_definitionConfigName = $definitionConfigName;
  324. return $this;
  325. }
  326. /**
  327. * getDefinitionConfigName()
  328. *
  329. * @return string
  330. */
  331. public function getDefinitionConfigName()
  332. {
  333. return $this->_definitionConfigName;
  334. }
  335. /**
  336. * @param string $classname
  337. * @return Zend_Db_Table_Abstract Provides a fluent interface
  338. */
  339. public function setRowClass($classname)
  340. {
  341. $this->_rowClass = (string) $classname;
  342. return $this;
  343. }
  344. /**
  345. * @return string
  346. */
  347. public function getRowClass()
  348. {
  349. return $this->_rowClass;
  350. }
  351. /**
  352. * @param string $classname
  353. * @return Zend_Db_Table_Abstract Provides a fluent interface
  354. */
  355. public function setRowsetClass($classname)
  356. {
  357. $this->_rowsetClass = (string) $classname;
  358. return $this;
  359. }
  360. /**
  361. * @return string
  362. */
  363. public function getRowsetClass()
  364. {
  365. return $this->_rowsetClass;
  366. }
  367. /**
  368. * Add a reference to the reference map
  369. *
  370. * @param string $ruleKey
  371. * @param string|array $columns
  372. * @param string $refTableClass
  373. * @param string|array $refColumns
  374. * @param string $onDelete
  375. * @param string $onUpdate
  376. * @return Zend_Db_Table_Abstract
  377. */
  378. public function addReference($ruleKey, $columns, $refTableClass, $refColumns,
  379. $onDelete = null, $onUpdate = null)
  380. {
  381. $reference = array(self::COLUMNS => (array) $columns,
  382. self::REF_TABLE_CLASS => $refTableClass,
  383. self::REF_COLUMNS => (array) $refColumns);
  384. if (!empty($onDelete)) {
  385. $reference[self::ON_DELETE] = $onDelete;
  386. }
  387. if (!empty($onUpdate)) {
  388. $reference[self::ON_UPDATE] = $onUpdate;
  389. }
  390. $this->_referenceMap[$ruleKey] = $reference;
  391. return $this;
  392. }
  393. /**
  394. * @param array $referenceMap
  395. * @return Zend_Db_Table_Abstract Provides a fluent interface
  396. */
  397. public function setReferences(array $referenceMap)
  398. {
  399. $this->_referenceMap = $referenceMap;
  400. return $this;
  401. }
  402. /**
  403. * @param string $tableClassname
  404. * @param string $ruleKey OPTIONAL
  405. * @return array
  406. * @throws Zend_Db_Table_Exception
  407. */
  408. public function getReference($tableClassname, $ruleKey = null)
  409. {
  410. $thisClass = get_class($this);
  411. if ($thisClass === 'Zend_Db_Table') {
  412. $thisClass = $this->_definitionConfigName;
  413. }
  414. $refMap = $this->_getReferenceMapNormalized();
  415. if ($ruleKey !== null) {
  416. if (!isset($refMap[$ruleKey])) {
  417. require_once "Zend/Db/Table/Exception.php";
  418. throw new Zend_Db_Table_Exception("No reference rule \"$ruleKey\" from table $thisClass to table $tableClassname");
  419. }
  420. if ($refMap[$ruleKey][self::REF_TABLE_CLASS] != $tableClassname) {
  421. require_once "Zend/Db/Table/Exception.php";
  422. throw new Zend_Db_Table_Exception("Reference rule \"$ruleKey\" does not reference table $tableClassname");
  423. }
  424. return $refMap[$ruleKey];
  425. }
  426. foreach ($refMap as $reference) {
  427. if ($reference[self::REF_TABLE_CLASS] == $tableClassname) {
  428. return $reference;
  429. }
  430. }
  431. require_once "Zend/Db/Table/Exception.php";
  432. throw new Zend_Db_Table_Exception("No reference from table $thisClass to table $tableClassname");
  433. }
  434. /**
  435. * @param array $dependentTables
  436. * @return Zend_Db_Table_Abstract Provides a fluent interface
  437. */
  438. public function setDependentTables(array $dependentTables)
  439. {
  440. $this->_dependentTables = $dependentTables;
  441. return $this;
  442. }
  443. /**
  444. * @return array
  445. */
  446. public function getDependentTables()
  447. {
  448. return $this->_dependentTables;
  449. }
  450. /**
  451. * set the defaultSource property - this tells the table class where to find default values
  452. *
  453. * @param string $defaultSource
  454. * @return Zend_Db_Table_Abstract
  455. */
  456. public function setDefaultSource($defaultSource = self::DEFAULT_NONE)
  457. {
  458. if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
  459. $defaultSource = self::DEFAULT_NONE;
  460. }
  461. $this->_defaultSource = $defaultSource;
  462. return $this;
  463. }
  464. /**
  465. * returns the default source flag that determines where defaultSources come from
  466. *
  467. * @return unknown
  468. */
  469. public function getDefaultSource()
  470. {
  471. return $this->_defaultSource;
  472. }
  473. /**
  474. * set the default values for the table class
  475. *
  476. * @param array $defaultValues
  477. * @return Zend_Db_Table_Abstract
  478. */
  479. public function setDefaultValues(Array $defaultValues)
  480. {
  481. foreach ($defaultValues as $defaultName => $defaultValue) {
  482. if (array_key_exists($defaultName, $this->_metadata)) {
  483. $this->_defaultValues[$defaultName] = $defaultValue;
  484. }
  485. }
  486. return $this;
  487. }
  488. public function getDefaultValues()
  489. {
  490. return $this->_defaultValues;
  491. }
  492. /**
  493. * Sets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.
  494. *
  495. * @param mixed $db Either an Adapter object, or a string naming a Registry key
  496. * @return void
  497. */
  498. public static function setDefaultAdapter($db = null)
  499. {
  500. self::$_defaultDb = self::_setupAdapter($db);
  501. }
  502. /**
  503. * Gets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.
  504. *
  505. * @return Zend_Db_Adapter_Abstract or null
  506. */
  507. public static function getDefaultAdapter()
  508. {
  509. return self::$_defaultDb;
  510. }
  511. /**
  512. * @param mixed $db Either an Adapter object, or a string naming a Registry key
  513. * @return Zend_Db_Table_Abstract Provides a fluent interface
  514. */
  515. protected function _setAdapter($db)
  516. {
  517. $this->_db = self::_setupAdapter($db);
  518. return $this;
  519. }
  520. /**
  521. * Gets the Zend_Db_Adapter_Abstract for this particular Zend_Db_Table object.
  522. *
  523. * @return Zend_Db_Adapter_Abstract
  524. */
  525. public function getAdapter()
  526. {
  527. return $this->_db;
  528. }
  529. /**
  530. * @param mixed $db Either an Adapter object, or a string naming a Registry key
  531. * @return Zend_Db_Adapter_Abstract
  532. * @throws Zend_Db_Table_Exception
  533. */
  534. protected static function _setupAdapter($db)
  535. {
  536. if ($db === null) {
  537. return null;
  538. }
  539. if (is_string($db)) {
  540. require_once 'Zend/Registry.php';
  541. $db = Zend_Registry::get($db);
  542. }
  543. if (!$db instanceof Zend_Db_Adapter_Abstract) {
  544. require_once 'Zend/Db/Table/Exception.php';
  545. throw new Zend_Db_Table_Exception('Argument must be of type Zend_Db_Adapter_Abstract, or a Registry key where a Zend_Db_Adapter_Abstract object is stored');
  546. }
  547. return $db;
  548. }
  549. /**
  550. * Sets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
  551. *
  552. * If $defaultMetadataCache is null, then no metadata cache is used by default.
  553. *
  554. * @param mixed $metadataCache Either a Cache object, or a string naming a Registry key
  555. * @return void
  556. */
  557. public static function setDefaultMetadataCache($metadataCache = null)
  558. {
  559. self::$_defaultMetadataCache = self::_setupMetadataCache($metadataCache);
  560. }
  561. /**
  562. * Gets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
  563. *
  564. * @return Zend_Cache_Core or null
  565. */
  566. public static function getDefaultMetadataCache()
  567. {
  568. return self::$_defaultMetadataCache;
  569. }
  570. /**
  571. * Sets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
  572. *
  573. * If $metadataCache is null, then no metadata cache is used. Since there is no opportunity to reload metadata
  574. * after instantiation, this method need not be public, particularly because that it would have no effect
  575. * results in unnecessary API complexity. To configure the metadata cache, use the metadataCache configuration
  576. * option for the class constructor upon instantiation.
  577. *
  578. * @param mixed $metadataCache Either a Cache object, or a string naming a Registry key
  579. * @return Zend_Db_Table_Abstract Provides a fluent interface
  580. */
  581. protected function _setMetadataCache($metadataCache)
  582. {
  583. $this->_metadataCache = self::_setupMetadataCache($metadataCache);
  584. return $this;
  585. }
  586. /**
  587. * Gets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().
  588. *
  589. * @return Zend_Cache_Core or null
  590. */
  591. public function getMetadataCache()
  592. {
  593. return $this->_metadataCache;
  594. }
  595. /**
  596. * Indicate whether metadata should be cached in the class for the duration
  597. * of the instance
  598. *
  599. * @param bool $flag
  600. * @return Zend_Db_Table_Abstract
  601. */
  602. public function setMetadataCacheInClass($flag)
  603. {
  604. $this->_metadataCacheInClass = (bool) $flag;
  605. return $this;
  606. }
  607. /**
  608. * Retrieve flag indicating if metadata should be cached for duration of
  609. * instance
  610. *
  611. * @return bool
  612. */
  613. public function metadataCacheInClass()
  614. {
  615. return $this->_metadataCacheInClass;
  616. }
  617. /**
  618. * @param mixed $metadataCache Either a Cache object, or a string naming a Registry key
  619. * @return Zend_Cache_Core
  620. * @throws Zend_Db_Table_Exception
  621. */
  622. protected static function _setupMetadataCache($metadataCache)
  623. {
  624. if ($metadataCache === null) {
  625. return null;
  626. }
  627. if (is_string($metadataCache)) {
  628. require_once 'Zend/Registry.php';
  629. $metadataCache = Zend_Registry::get($metadataCache);
  630. }
  631. if (!$metadataCache instanceof Zend_Cache_Core) {
  632. require_once 'Zend/Db/Table/Exception.php';
  633. throw new Zend_Db_Table_Exception('Argument must be of type Zend_Cache_Core, or a Registry key where a Zend_Cache_Core object is stored');
  634. }
  635. return $metadataCache;
  636. }
  637. /**
  638. * Sets the sequence member, which defines the behavior for generating
  639. * primary key values in new rows.
  640. * - If this is a string, then the string names the sequence object.
  641. * - If this is boolean true, then the key uses an auto-incrementing
  642. * or identity mechanism.
  643. * - If this is boolean false, then the key is user-defined.
  644. * Use this for natural keys, for example.
  645. *
  646. * @param mixed $sequence
  647. * @return Zend_Db_Table_Adapter_Abstract Provides a fluent interface
  648. */
  649. protected function _setSequence($sequence)
  650. {
  651. $this->_sequence = $sequence;
  652. return $this;
  653. }
  654. /**
  655. * Turnkey for initialization of a table object.
  656. * Calls other protected methods for individual tasks, to make it easier
  657. * for a subclass to override part of the setup logic.
  658. *
  659. * @return void
  660. */
  661. protected function _setup()
  662. {
  663. $this->_setupDatabaseAdapter();
  664. $this->_setupTableName();
  665. }
  666. /**
  667. * Initialize database adapter.
  668. *
  669. * @return void
  670. * @throws Zend_Db_Table_Exception
  671. */
  672. protected function _setupDatabaseAdapter()
  673. {
  674. if (! $this->_db) {
  675. $this->_db = self::getDefaultAdapter();
  676. if (!$this->_db instanceof Zend_Db_Adapter_Abstract) {
  677. require_once 'Zend/Db/Table/Exception.php';
  678. throw new Zend_Db_Table_Exception('No adapter found for ' . get_class($this));
  679. }
  680. }
  681. }
  682. /**
  683. * Initialize table and schema names.
  684. *
  685. * If the table name is not set in the class definition,
  686. * use the class name itself as the table name.
  687. *
  688. * A schema name provided with the table name (e.g., "schema.table") overrides
  689. * any existing value for $this->_schema.
  690. *
  691. * @return void
  692. */
  693. protected function _setupTableName()
  694. {
  695. if (! $this->_name) {
  696. $this->_name = get_class($this);
  697. } else if (strpos($this->_name, '.')) {
  698. list($this->_schema, $this->_name) = explode('.', $this->_name);
  699. }
  700. }
  701. /**
  702. * Initializes metadata.
  703. *
  704. * If metadata cannot be loaded from cache, adapter's describeTable() method is called to discover metadata
  705. * information. Returns true if and only if the metadata are loaded from cache.
  706. *
  707. * @return boolean
  708. * @throws Zend_Db_Table_Exception
  709. */
  710. protected function _setupMetadata()
  711. {
  712. if ($this->metadataCacheInClass() && (count($this->_metadata) > 0)) {
  713. return true;
  714. }
  715. // Assume that metadata will be loaded from cache
  716. $isMetadataFromCache = true;
  717. // If $this has no metadata cache but the class has a default metadata cache
  718. if (null === $this->_metadataCache && null !== self::$_defaultMetadataCache) {
  719. // Make $this use the default metadata cache of the class
  720. $this->_setMetadataCache(self::$_defaultMetadataCache);
  721. }
  722. // If $this has a metadata cache
  723. if (null !== $this->_metadataCache) {
  724. // Define the cache identifier where the metadata are saved
  725. //get db configuration
  726. $dbConfig = $this->_db->getConfig();
  727. $port = isset($dbConfig['options']['port'])
  728. ? ':'.$dbConfig['options']['port']
  729. : (isset($dbConfig['port'])
  730. ? ':'.$dbConfig['port']
  731. : null);
  732. $host = isset($dbConfig['options']['host'])
  733. ? ':'.$dbConfig['options']['host']
  734. : (isset($dbConfig['host'])
  735. ? ':'.$dbConfig['host']
  736. : null);
  737. // Define the cache identifier where the metadata are saved
  738. $cacheId = md5( // port:host/dbname:schema.table (based on availabilty)
  739. $port . $host . '/'. $dbConfig['dbname'] . ':'
  740. . $this->_schema. '.' . $this->_name
  741. );
  742. }
  743. // If $this has no metadata cache or metadata cache misses
  744. if (null === $this->_metadataCache || !($metadata = $this->_metadataCache->load($cacheId))) {
  745. // Metadata are not loaded from cache
  746. $isMetadataFromCache = false;
  747. // Fetch metadata from the adapter's describeTable() method
  748. $metadata = $this->_db->describeTable($this->_name, $this->_schema);
  749. // If $this has a metadata cache, then cache the metadata
  750. if (null !== $this->_metadataCache && !$this->_metadataCache->save($metadata, $cacheId)) {
  751. trigger_error('Failed saving metadata to metadataCache', E_USER_NOTICE);
  752. }
  753. }
  754. // Assign the metadata to $this
  755. $this->_metadata = $metadata;
  756. // Return whether the metadata were loaded from cache
  757. return $isMetadataFromCache;
  758. }
  759. /**
  760. * Retrieve table columns
  761. *
  762. * @return array
  763. */
  764. protected function _getCols()
  765. {
  766. if (null === $this->_cols) {
  767. $this->_setupMetadata();
  768. $this->_cols = array_keys($this->_metadata);
  769. }
  770. return $this->_cols;
  771. }
  772. /**
  773. * Initialize primary key from metadata.
  774. * If $_primary is not defined, discover primary keys
  775. * from the information returned by describeTable().
  776. *
  777. * @return void
  778. * @throws Zend_Db_Table_Exception
  779. */
  780. protected function _setupPrimaryKey()
  781. {
  782. if (!$this->_primary) {
  783. $this->_setupMetadata();
  784. $this->_primary = array();
  785. foreach ($this->_metadata as $col) {
  786. if ($col['PRIMARY']) {
  787. $this->_primary[ $col['PRIMARY_POSITION'] ] = $col['COLUMN_NAME'];
  788. if ($col['IDENTITY']) {
  789. $this->_identity = $col['PRIMARY_POSITION'];
  790. }
  791. }
  792. }
  793. // if no primary key was specified and none was found in the metadata
  794. // then throw an exception.
  795. if (empty($this->_primary)) {
  796. require_once 'Zend/Db/Table/Exception.php';
  797. throw new Zend_Db_Table_Exception('A table must have a primary key, but none was found');
  798. }
  799. } else if (!is_array($this->_primary)) {
  800. $this->_primary = array(1 => $this->_primary);
  801. } else if (isset($this->_primary[0])) {
  802. array_unshift($this->_primary, null);
  803. unset($this->_primary[0]);
  804. }
  805. $cols = $this->_getCols();
  806. if (! array_intersect((array) $this->_primary, $cols) == (array) $this->_primary) {
  807. require_once 'Zend/Db/Table/Exception.php';
  808. throw new Zend_Db_Table_Exception("Primary key column(s) ("
  809. . implode(',', (array) $this->_primary)
  810. . ") are not columns in this table ("
  811. . implode(',', $cols)
  812. . ")");
  813. }
  814. $primary = (array) $this->_primary;
  815. $pkIdentity = $primary[(int) $this->_identity];
  816. /**
  817. * Special case for PostgreSQL: a SERIAL key implicitly uses a sequence
  818. * object whose name is "<table>_<column>_seq".
  819. */
  820. if ($this->_sequence === true && $this->_db instanceof Zend_Db_Adapter_Pdo_Pgsql) {
  821. $this->_sequence = $this->_db->quoteIdentifier("{$this->_name}_{$pkIdentity}_seq");
  822. if ($this->_schema) {
  823. $this->_sequence = $this->_db->quoteIdentifier($this->_schema) . '.' . $this->_sequence;
  824. }
  825. }
  826. }
  827. /**
  828. * Returns a normalized version of the reference map
  829. *
  830. * @return array
  831. */
  832. protected function _getReferenceMapNormalized()
  833. {
  834. $referenceMapNormalized = array();
  835. foreach ($this->_referenceMap as $rule => $map) {
  836. $referenceMapNormalized[$rule] = array();
  837. foreach ($map as $key => $value) {
  838. switch ($key) {
  839. // normalize COLUMNS and REF_COLUMNS to arrays
  840. case self::COLUMNS:
  841. case self::REF_COLUMNS:
  842. if (!is_array($value)) {
  843. $referenceMapNormalized[$rule][$key] = array($value);
  844. } else {
  845. $referenceMapNormalized[$rule][$key] = $value;
  846. }
  847. break;
  848. // other values are copied as-is
  849. default:
  850. $referenceMapNormalized[$rule][$key] = $value;
  851. break;
  852. }
  853. }
  854. }
  855. return $referenceMapNormalized;
  856. }
  857. /**
  858. * Initialize object
  859. *
  860. * Called from {@link __construct()} as final step of object instantiation.
  861. *
  862. * @return void
  863. */
  864. public function init()
  865. {
  866. }
  867. /**
  868. * Returns table information.
  869. *
  870. * You can elect to return only a part of this information by supplying its key name,
  871. * otherwise all information is returned as an array.
  872. *
  873. * @param string $key The specific info part to return OPTIONAL
  874. * @return mixed
  875. * @throws Zend_Db_Table_Exception
  876. */
  877. public function info($key = null)
  878. {
  879. $this->_setupPrimaryKey();
  880. $info = array(
  881. self::SCHEMA => $this->_schema,
  882. self::NAME => $this->_name,
  883. self::COLS => $this->_getCols(),
  884. self::PRIMARY => (array) $this->_primary,
  885. self::METADATA => $this->_metadata,
  886. self::ROW_CLASS => $this->getRowClass(),
  887. self::ROWSET_CLASS => $this->getRowsetClass(),
  888. self::REFERENCE_MAP => $this->_referenceMap,
  889. self::DEPENDENT_TABLES => $this->_dependentTables,
  890. self::SEQUENCE => $this->_sequence
  891. );
  892. if ($key === null) {
  893. return $info;
  894. }
  895. if (!array_key_exists($key, $info)) {
  896. require_once 'Zend/Db/Table/Exception.php';
  897. throw new Zend_Db_Table_Exception('There is no table information for the key "' . $key . '"');
  898. }
  899. return $info[$key];
  900. }
  901. /**
  902. * Returns an instance of a Zend_Db_Table_Select object.
  903. *
  904. * @param bool $withFromPart Whether or not to include the from part of the select based on the table
  905. * @return Zend_Db_Table_Select
  906. */
  907. public function select($withFromPart = self::SELECT_WITHOUT_FROM_PART)
  908. {
  909. require_once 'Zend/Db/Table/Select.php';
  910. $select = new Zend_Db_Table_Select($this);
  911. if ($withFromPart == self::SELECT_WITH_FROM_PART) {
  912. $select->from($this->info(self::NAME), Zend_Db_Table_Select::SQL_WILDCARD, $this->info(self::SCHEMA));
  913. }
  914. return $select;
  915. }
  916. /**
  917. * Inserts a new row.
  918. *
  919. * @param array $data Column-value pairs.
  920. * @return mixed The primary key of the row inserted.
  921. */
  922. public function insert(array $data)
  923. {
  924. $this->_setupPrimaryKey();
  925. /**
  926. * Zend_Db_Table assumes that if you have a compound primary key
  927. * and one of the columns in the key uses a sequence,
  928. * it's the _first_ column in the compound key.
  929. */
  930. $primary = (array) $this->_primary;
  931. $pkIdentity = $primary[(int)$this->_identity];
  932. /**
  933. * If this table uses a database sequence object and the data does not
  934. * specify a value, then get the next ID from the sequence and add it
  935. * to the row. We assume that only the first column in a compound
  936. * primary key takes a value from a sequence.
  937. */
  938. if (is_string($this->_sequence) && !isset($data[$pkIdentity])) {
  939. $data[$pkIdentity] = $this->_db->nextSequenceId($this->_sequence);
  940. $pkSuppliedBySequence = true;
  941. }
  942. /**
  943. * If the primary key can be generated automatically, and no value was
  944. * specified in the user-supplied data, then omit it from the tuple.
  945. *
  946. * Note: this checks for sensible values in the supplied primary key
  947. * position of the data. The following values are considered empty:
  948. * null, false, true, '', array()
  949. */
  950. if (!isset($pkSuppliedBySequence) && array_key_exists($pkIdentity, $data)) {
  951. if ($data[$pkIdentity] === null // null
  952. || $data[$pkIdentity] === '' // empty string
  953. || is_bool($data[$pkIdentity]) // boolean
  954. || (is_array($data[$pkIdentity]) && empty($data[$pkIdentity]))) { // empty array
  955. unset($data[$pkIdentity]);
  956. }
  957. }
  958. /**
  959. * INSERT the new row.
  960. */
  961. $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
  962. $this->_db->insert($tableSpec, $data);
  963. /**
  964. * Fetch the most recent ID generated by an auto-increment
  965. * or IDENTITY column, unless the user has specified a value,
  966. * overriding the auto-increment mechanism.
  967. */
  968. if ($this->_sequence === true && !isset($data[$pkIdentity])) {
  969. $data[$pkIdentity] = $this->_db->lastInsertId();
  970. }
  971. /**
  972. * Return the primary key value if the PK is a single column,
  973. * else return an associative array of the PK column/value pairs.
  974. */
  975. $pkData = array_intersect_key($data, array_flip($primary));
  976. if (count($primary) == 1) {
  977. reset($pkData);
  978. return current($pkData);
  979. }
  980. return $pkData;
  981. }
  982. /**
  983. * Check if the provided column is an identity of the table
  984. *
  985. * @param string $column
  986. * @throws Zend_Db_Table_Exception
  987. * @return boolean
  988. */
  989. public function isIdentity($column)
  990. {
  991. $this->_setupPrimaryKey();
  992. if (!isset($this->_metadata[$column])) {
  993. /**
  994. * @see Zend_Db_Table_Exception
  995. */
  996. require_once 'Zend/Db/Table/Exception.php';
  997. throw new Zend_Db_Table_Exception('Column "' . $column . '" not found in table.');
  998. }
  999. return (bool) $this->_metadata[$column]['IDENTITY'];
  1000. }
  1001. /**
  1002. * Updates existing rows.
  1003. *
  1004. * @param array $data Column-value pairs.
  1005. * @param array|string $where An SQL WHERE clause, or an array of SQL WHERE clauses.
  1006. * @return int The number of rows updated.
  1007. */
  1008. public function update(array $data, $where)
  1009. {
  1010. $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
  1011. return $this->_db->update($tableSpec, $data, $where);
  1012. }
  1013. /**
  1014. * Called by a row object for the parent table's class during save() method.
  1015. *
  1016. * @param string $parentTableClassname
  1017. * @param array $oldPrimaryKey
  1018. * @param array $newPrimaryKey
  1019. * @return int
  1020. */
  1021. public function _cascadeUpdate($parentTableClassname, array $oldPrimaryKey, array $newPrimaryKey)
  1022. {
  1023. $this->_setupMetadata();
  1024. $rowsAffected = 0;
  1025. foreach ($this->_getReferenceMapNormalized() as $map) {
  1026. if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_UPDATE])) {
  1027. switch ($map[self::ON_UPDATE]) {
  1028. case self::CASCADE:
  1029. $newRefs = array();
  1030. $where = array();
  1031. for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
  1032. $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
  1033. $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
  1034. if (array_key_exists($refCol, $newPrimaryKey)) {
  1035. $newRefs[$col] = $newPrimaryKey[$refCol];
  1036. }
  1037. $type = $this->_metadata[$col]['DATA_TYPE'];
  1038. $where[] = $this->_db->quoteInto(
  1039. $this->_db->quoteIdentifier($col, true) . ' = ?',
  1040. $oldPrimaryKey[$refCol], $type);
  1041. }
  1042. $rowsAffected += $this->update($newRefs, $where);
  1043. break;
  1044. default:
  1045. // no action
  1046. break;
  1047. }
  1048. }
  1049. }
  1050. return $rowsAffected;
  1051. }
  1052. /**
  1053. * Deletes existing rows.
  1054. *
  1055. * @param array|string $where SQL WHERE clause(s).
  1056. * @return int The number of rows deleted.
  1057. */
  1058. public function delete($where)
  1059. {
  1060. $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
  1061. return $this->_db->delete($tableSpec, $where);
  1062. }
  1063. /**
  1064. * Called by parent table's class during delete() method.
  1065. *
  1066. * @param string $parentTableClassname
  1067. * @param array $primaryKey
  1068. * @return int Number of affected rows
  1069. */
  1070. public function _cascadeDelete($parentTableClassname, array $primaryKey)
  1071. {
  1072. $this->_setupMetadata();
  1073. $rowsAffected = 0;
  1074. foreach ($this->_getReferenceMapNormalized() as $map) {
  1075. if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_DELETE])) {
  1076. switch ($map[self::ON_DELETE]) {
  1077. case self::CASCADE:
  1078. $where = array();
  1079. for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
  1080. $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
  1081. $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
  1082. $type = $this->_metadata[$col]['DATA_TYPE'];
  1083. $where[] = $this->_db->quoteInto(
  1084. $this->_db->quoteIdentifier($col, true) . ' = ?',
  1085. $primaryKey[$refCol], $type);
  1086. }
  1087. $rowsAffected += $this->delete($where);
  1088. break;
  1089. default:
  1090. // no action
  1091. break;
  1092. }
  1093. }
  1094. }
  1095. return $rowsAffected;
  1096. }
  1097. /**
  1098. * Fetches rows by primary key. The argument specifies one or more primary
  1099. * key value(s). To find multiple rows by primary key, the argument must
  1100. * be an array.
  1101. *
  1102. * This method accepts a variable number of arguments. If the table has a
  1103. * multi-column primary key, the number of arguments must be the same as
  1104. * the number of columns in the primary key. To find multiple rows in a
  1105. * table with a multi-column primary key, each argument must be an array
  1106. * with the same number of elements.
  1107. *
  1108. * The find() method always returns a Rowset object, even if only one row
  1109. * was found.
  1110. *
  1111. * @param mixed $key The value(s) of the primary keys.
  1112. * @return Zend_Db_Table_Rowset_Abstract Row(s) matching the criteria.
  1113. * @throws Zend_Db_Table_Exception
  1114. */
  1115. public function find()
  1116. {
  1117. $this->_setupPrimaryKey();
  1118. $args = func_get_args();
  1119. $keyNames = array_values((array) $this->_primary);
  1120. if (count($args) < count($keyNames)) {
  1121. require_once 'Zend/Db/Table/Exception.php';
  1122. throw new Zend_Db_Table_Exception("Too few columns for the primary key");
  1123. }
  1124. if (count($args) > count($keyNames)) {
  1125. require_once 'Zend/Db/Table/Exception.php';
  1126. throw new Zend_Db_Table_Exception("Too many columns for the primary key");
  1127. }
  1128. $whereList = array();
  1129. $numberTerms = 0;
  1130. foreach ($args as $keyPosition => $keyValues) {
  1131. $keyValuesCount = count($keyValues);
  1132. // Coerce the values to an array.
  1133. // Don't simply typecast to array, because the values
  1134. // might be Zend_Db_Expr objects.
  1135. if (!is_array($keyValues)) {
  1136. $keyValues = array($keyValues);
  1137. }
  1138. if ($numberTerms == 0) {
  1139. $numberTerms = $keyValuesCount;
  1140. } else if ($keyValuesCount != $numberTerms) {
  1141. require_once 'Zend/Db/Table/Exception.php';
  1142. throw new Zend_Db_Table_Exception("Missing value(s) for the primary key");
  1143. }
  1144. $keyValues = array_values($keyValues);
  1145. for ($i = 0; $i < $keyValuesCount; ++$i) {
  1146. if (!isset($whereList[$i])) {
  1147. $whereList[$i] = array();
  1148. }
  1149. $whereList[$i][$keyPosition] = $keyValues[$i];
  1150. }
  1151. }
  1152. $whereClause = null;
  1153. if (count($whereList)) {
  1154. $whereOrTerms = array();
  1155. $tableName = $this->_db->quoteTableAs($this->_name, null, true);
  1156. foreach ($whereList as $keyValueSets) {
  1157. $whereAndTerms = array();
  1158. foreach ($keyValueSets as $keyPosition => $keyValue) {
  1159. $type = $this->_metadata[$keyNames[$keyPosition]]['DATA_TYPE'];
  1160. $columnName = $this->_db->quoteIdentifier($keyNames[$keyPosition], true);
  1161. $whereAndTerms[] = $this->_db->quoteInto(
  1162. $tableName . '.' . $columnName . ' = ?',
  1163. $keyValue, $type);
  1164. }
  1165. $whereOrTerms[] = '(' . implode(' AND ', $whereAndTerms) . ')';
  1166. }
  1167. $whereClause = '(' . implode(' OR ', $whereOrTerms) . ')';
  1168. }
  1169. // issue ZF-5775 (empty where clause should return empty rowset)
  1170. if ($whereClause == null) {
  1171. $rowsetClass = $this->getRowsetClass();
  1172. if (!class_exists($rowsetClass)) {
  1173. require_once 'Zend/Loader.php';
  1174. Zend_Loader::loadClass($rowsetClass);
  1175. }
  1176. return new $rowsetClass(array('table' => $this, 'rowClass' => $this->getRowClass(), 'stored' => true));
  1177. }
  1178. return $this->fetchAll($whereClause);
  1179. }
  1180. /**
  1181. * Fetches all rows.
  1182. *
  1183. * Honors the Zend_Db_Adapter fetch mode.
  1184. *
  1185. * @param string|array|Zend_Db_Table_Select $where OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
  1186. * @param string|array $order OPTIONAL An SQL ORDER clause.
  1187. * @param int $count OPTIONAL An SQL LIMIT count.
  1188. * @param int $offset OPTIONAL An SQL LIMIT offset.
  1189. * @return Zend_Db_Table_Rowset_Abstract The row results per the Zend_Db_Adapter fetch mode.
  1190. */
  1191. public function fetchAll($where = null, $order = null, $count = null, $offset = null)
  1192. {
  1193. if (!($where instanceof Zend_Db_Table_Select)) {
  1194. $select = $this->select();
  1195. if ($where !== null) {
  1196. $this->_where($select, $where);
  1197. }
  1198. if ($order !== null) {
  1199. $this->_order($select, $order);
  1200. }
  1201. if ($count !== null || $offset !== null) {
  1202. $select->limit($count, $offset);
  1203. }
  1204. } else {
  1205. $select = $where;
  1206. }
  1207. $rows = $this->_fetch($select);
  1208. $data = array(
  1209. 'table' => $this,
  1210. 'data' => $rows,
  1211. 'readOnly' => $select->isReadOnly(),
  1212. 'rowClass' => $this->getRowClass(),
  1213. 'stored' => true
  1214. );
  1215. $rowsetClass = $this->getRowsetClass();
  1216. if (!class_exists($rowsetClass)) {
  1217. require_once 'Zend/Loader.php';
  1218. Zend_Loader::loadClass($rowsetClass);
  1219. }
  1220. return new $rowsetClass($data);
  1221. }
  1222. /**
  1223. * Fetches one row in an object of type Zend_Db_Table_Row_Abstract,
  1224. * or returns null if no row matches the specified criteria.
  1225. *
  1226. * @param string|array|Zend_Db_Table_Select $where OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
  1227. * @param string|array $order OPTIONAL An SQL ORDER clause.
  1228. * @param int $offset OPTIONAL An SQL OFFSET value.
  1229. * @return Zend_Db_Table_Row_Abstract|null The row results per the
  1230. * Zend_Db_Adapter fetch mode, or null if no row found.
  1231. */
  1232. public function fetchRow($where = null, $order = null, $offset = null)
  1233. {
  1234. if (!($where instanceof Zend_Db_Table_Select)) {
  1235. $select = $this->select();
  1236. if ($where !== null) {
  1237. $this->_where($select, $where);
  1238. }
  1239. if ($order !== null) {
  1240. $this->_order($select, $order);
  1241. }
  1242. $select->limit(1, ((is_numeric($offset)) ? (int) $offset : null));
  1243. } else {
  1244. $select = $where->limit(1, $where->getPart(Zend_Db_Select::LIMIT_OFFSET));
  1245. }
  1246. $rows = $this->_fetch($select);
  1247. if (count($rows) == 0) {
  1248. return null;
  1249. }
  1250. $data = array(
  1251. 'table' => $this,
  1252. 'data' => $rows[0],
  1253. 'readOnly' => $select->isReadOnly(),
  1254. 'stored' => true
  1255. );
  1256. $rowClass = $this->getRowClass();
  1257. if (!class_exists($rowClass)) {
  1258. require_once 'Zend/Loader.php';
  1259. Zend_Loader::loadClass($rowClass);
  1260. }
  1261. return new $rowClass($data);
  1262. }
  1263. /**
  1264. * Fetches a new blank row (not from the database).
  1265. *
  1266. * @return Zend_Db_Table_Row_Abstract
  1267. * @deprecated since 0.9.3 - use createRow() instead.
  1268. */
  1269. public function fetchNew()
  1270. {
  1271. return $this->createRow();
  1272. }
  1273. /**
  1274. * Fetches a new blank row (not from the database).
  1275. *
  1276. * @param array $data OPTIONAL data to populate in the new row.
  1277. * @param string $defaultSource OPTIONAL flag to force default values into new row
  1278. * @return Zend_Db_Table_Row_Abstract
  1279. */
  1280. public function createRow(array $data = array(), $defaultSource = null)
  1281. {
  1282. $cols = $this->_getCols();
  1283. $defaults = array_combine($cols, array_fill(0, count($cols), null));
  1284. // nothing provided at call-time, take the class value
  1285. if ($defaultSource == null) {
  1286. $defaultSource = $this->_defaultSource;
  1287. }
  1288. if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
  1289. $defaultSource = self::DEFAULT_NONE;
  1290. }
  1291. if ($defaultSource == self::DEFAULT_DB) {
  1292. foreach ($this->_metadata as $metadataName => $metadata) {
  1293. if (($metadata['DEFAULT'] != null) &&
  1294. ($metadata['NULLABLE'] !== true || ($metadata['NULLABLE'] === true && isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === true)) &&
  1295. (!(isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === false))) {
  1296. $defaults[$metadataName] = $metadata['DEFAULT'];
  1297. }
  1298. }
  1299. } elseif ($defaultSource == self::DEFAULT_CLASS && $this->_defaultValues) {
  1300. foreach ($this->_defaultValues as $defaultName => $defaultValue) {
  1301. if (array_key_exists($defaultName, $defaults)) {
  1302. $defaults[$defaultName] = $defaultValue;
  1303. }
  1304. }
  1305. }
  1306. $config = array(
  1307. 'table' => $this,
  1308. 'data' => $defaults,
  1309. 'readOnly' => false,
  1310. 'stored' => false
  1311. );
  1312. $rowClass = $this->getRowClass();
  1313. if (!class_exists($rowClass)) {
  1314. require_once 'Zend/Loader.php';
  1315. Zend_Loader::loadClass($rowClass);
  1316. }
  1317. $row = new $rowClass($config);
  1318. $row->setFromArray($data);
  1319. return $row;
  1320. }
  1321. /**
  1322. * Generate WHERE clause from user-supplied string or array
  1323. *
  1324. * @param string|array $where OPTIONAL An SQL WHERE clause.
  1325. * @return Zend_Db_Table_Select
  1326. */
  1327. protected function _where(Zend_Db_Table_Select $select, $where)
  1328. {
  1329. $where = (array) $where;
  1330. foreach ($where as $key => $val) {
  1331. // is $key an int?
  1332. if (is_int($key)) {
  1333. // $val is the full condition
  1334. $select->where($val);
  1335. } else {
  1336. // $key is the condition with placeholder,
  1337. // and $val is quoted into the condition
  1338. $select->where($key, $val);
  1339. }
  1340. }
  1341. return $select;
  1342. }
  1343. /**
  1344. * Generate ORDER clause from user-supplied string or array
  1345. *
  1346. * @param string|array $order OPTIONAL An SQL ORDER clause.
  1347. * @return Zend_Db_Table_Select
  1348. */
  1349. protected function _order(Zend_Db_Table_Select $select, $order)
  1350. {
  1351. if (!is_array($order)) {
  1352. $order = array($order);
  1353. }
  1354. foreach ($order as $val) {
  1355. $select->order($val);
  1356. }
  1357. return $select;
  1358. }
  1359. /**
  1360. * Support method for fetching rows.
  1361. *
  1362. * @param Zend_Db_Table_Select $select query options.
  1363. * @return array An array containing the row results in FETCH_ASSOC mode.
  1364. */
  1365. protected function _fetch(Zend_Db_Table_Select $select)
  1366. {
  1367. $stmt = $this->_db->query($select);
  1368. $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
  1369. return $data;
  1370. }
  1371. }