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