Zend_Db_Table_Abstract Class Reference

Inheritance diagram for Zend_Db_Table_Abstract:

Public Member Functions
	__construct ($config=array())
	setOptions (Array $options)
	setDefinition (Zend_Db_Table_Definition $definition)
	getDefinition ()
	setDefinitionConfigName ($definitionConfigName)
	getDefinitionConfigName ()
	setRowClass ($classname)
	getRowClass ()
	setRowsetClass ($classname)
	getRowsetClass ()
	addReference ($ruleKey, $columns, $refTableClass, $refColumns, $onDelete=null, $onUpdate=null)
	setReferences (array $referenceMap)
	getReference ($tableClassname, $ruleKey=null)
	setDependentTables (array $dependentTables)
	getDependentTables ()
	setDefaultSource ($defaultSource=self::DEFAULT_NONE)
	getDefaultSource ()
	setDefaultValues (Array $defaultValues)
	getDefaultValues ()
	getAdapter ()
	getMetadataCache ()
	setMetadataCacheInClass ($flag)
	metadataCacheInClass ()
	init ()
	info ($key=null)
	select ($withFromPart=self::SELECT_WITHOUT_FROM_PART)
	insert (array $data)
	isIdentity ($column)
	update (array $data, $where)
	_cascadeUpdate ($parentTableClassname, array $oldPrimaryKey, array $newPrimaryKey)
	delete ($where)
	_cascadeDelete ($parentTableClassname, array $primaryKey)
	find ()
	fetchAll ($where=null, $order=null, $count=null, $offset=null)
	fetchRow ($where=null, $order=null, $offset=null)
	fetchNew ()
	createRow (array $data=array(), $defaultSource=null)

Static Public Member Functions
static	setDefaultAdapter ($db=null)
static	getDefaultAdapter ()
static	setDefaultMetadataCache ($metadataCache=null)
static	getDefaultMetadataCache ()
static	getTableFromString ($tableName, Zend_Db_Table_Abstract $referenceTable=null)

Data Fields
const	ADAPTER = 'db'
const	DEFINITION = 'definition'
const	DEFINITION_CONFIG_NAME = 'definitionConfigName'
const	SCHEMA = 'schema'
const	NAME = 'name'
const	PRIMARY = 'primary'
const	COLS = 'cols'
const	METADATA = 'metadata'
const	METADATA_CACHE = 'metadataCache'
const	METADATA_CACHE_IN_CLASS = 'metadataCacheInClass'
const	ROW_CLASS = 'rowClass'
const	ROWSET_CLASS = 'rowsetClass'
const	REFERENCE_MAP = 'referenceMap'
const	DEPENDENT_TABLES = 'dependentTables'
const	SEQUENCE = 'sequence'
const	COLUMNS = 'columns'
const	REF_TABLE_CLASS = 'refTableClass'
const	REF_COLUMNS = 'refColumns'
const	ON_DELETE = 'onDelete'
const	ON_UPDATE = 'onUpdate'
const	CASCADE = 'cascade'
const	CASCADE_RECURSE = 'cascadeRecurse'
const	RESTRICT = 'restrict'
const	SET_NULL = 'setNull'
const	DEFAULT_NONE = 'defaultNone'
const	DEFAULT_CLASS = 'defaultClass'
const	DEFAULT_DB = 'defaultDb'
const	SELECT_WITH_FROM_PART = true
const	SELECT_WITHOUT_FROM_PART = false

Protected Member Functions
	_setAdapter ($db)
	_setMetadataCache ($metadataCache)
	_setSequence ($sequence)
	_setup ()
	_setupDatabaseAdapter ()
	_setupTableName ()
	_setupMetadata ()
	_getCols ()
	_setupPrimaryKey ()
	_getReferenceMapNormalized ()
	_where (Zend_Db_Table_Select $select, $where)
	_order (Zend_Db_Table_Select $select, $order)
	_fetch (Zend_Db_Table_Select $select)

Static Protected Member Functions
static	_setupAdapter ($db)
static	_setupMetadataCache ($metadataCache)

Protected Attributes
	$_definition = null
	$_definitionConfigName = null
	$_db
	$_schema = null
	$_name = null
	$_cols
	$_primary = null
	$_identity = 1
	$_sequence = true
	$_metadata = array()
	$_metadataCache = null
	$_metadataCacheInClass = true
	$_rowClass = 'Zend_Db_Table_Row'
	$_rowsetClass = 'Zend_Db_Table_Rowset'
	$_referenceMap = array()
	$_dependentTables = array()
	$_defaultSource = self::DEFAULT_NONE
	$_defaultValues = array()

Static Protected Attributes
static	$_defaultDb
static	$_defaultMetadataCache = null

Detailed Description

Definition at line 47 of file Abstract.php.

Constructor & Destructor Documentation

__construct()

__construct

(

$config = array()

)

Constructor.

Supported params for $config are:

• db = user-supplied instance of database connector, or key name of registry instance.
• name = table name.
• primary = string or array of primary key(s).
• rowClass = row class name.
• rowsetClass = rowset class name.
• referenceMap = array structure to declare relationship to parent tables.
• dependentTables = array of child tables.
• metadataCache = cache for information from adapter describeTable().

Parameters

mixed

$config

Array of user-specified config options, or just the Db Adapter.

Returns

void

Allow a scalar argument to be the Adapter object or Registry key.

Definition at line 256 of file Abstract.php.

    {
        if (!is_array($config)) {
            $config = array(self::ADAPTER => $config);
        }

        if ($config) {
            $this->setOptions($config);
        }

        $this->_setup();
        $this->init();
    }

Member Function Documentation

_cascadeDelete()

_cascadeDelete	(		$parentTableClassname,
		array	$primaryKey
	)

Called by parent table's class during delete() method.

Parameters

string	$parentTableClassname
array	$primaryKey

Returns

int Number of affected rows

Execute cascading deletes against dependent tables

Definition at line 1213 of file Abstract.php.

    {
        // setup metadata
        $this->_setupMetadata();

        // get this class name
        $thisClass = get_class($this);
        if ($thisClass === 'Zend_Db_Table') {
            $thisClass = $this->_definitionConfigName;
        }

        $rowsAffected = 0;

        foreach ($this->_getReferenceMapNormalized() as $map) {
            if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_DELETE])) {

                $where = array();

                // CASCADE or CASCADE_RECURSE
                if (in_array($map[self::ON_DELETE], array(self::CASCADE, self::CASCADE_RECURSE))) {
                    for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
                        $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
                        $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
                        $type = $this->_metadata[$col]['DATA_TYPE'];
                        $where[] = $this->_db->quoteInto(
                            $this->_db->quoteIdentifier($col, true) . ' = ?',
                            $primaryKey[$refCol], $type);
                    }
                }

                // CASCADE_RECURSE
                if ($map[self::ON_DELETE] == self::CASCADE_RECURSE) {

                    $depTables = $this->getDependentTables();
                    if (!empty($depTables)) {
                        foreach ($depTables as $tableClass) {
                            $t = self::getTableFromString($tableClass, $this);
                            foreach ($this->fetchAll($where) as $depRow) {
                                $rowsAffected += $t->_cascadeDelete($thisClass, $depRow->getPrimaryKey());
                            }
                        }
                    }
                }

                // CASCADE or CASCADE_RECURSE
                if (in_array($map[self::ON_DELETE], array(self::CASCADE, self::CASCADE_RECURSE))) {
                    $rowsAffected += $this->delete($where);
                }

            }
        }
        return $rowsAffected;
    }

_cascadeUpdate()

_cascadeUpdate	(		$parentTableClassname,
		array	$oldPrimaryKey,
		array	$newPrimaryKey
	)

Called by a row object for the parent table's class during save() method.

Parameters

string	$parentTableClassname
array	$oldPrimaryKey
array	$newPrimaryKey

Returns

int

Definition at line 1144 of file Abstract.php.

    {
        $this->_setupMetadata();
        $rowsAffected = 0;
        foreach ($this->_getReferenceMapNormalized() as $map) {
            if ($map[self::REF_TABLE_CLASS] == $parentTableClassname && isset($map[self::ON_UPDATE])) {
                switch ($map[self::ON_UPDATE]) {
                    case self::CASCADE:
                        $newRefs = array();
                        $where = array();
                        for ($i = 0; $i < count($map[self::COLUMNS]); ++$i) {
                            $col = $this->_db->foldCase($map[self::COLUMNS][$i]);
                            $refCol = $this->_db->foldCase($map[self::REF_COLUMNS][$i]);
                            if (array_key_exists($refCol, $newPrimaryKey)) {
                                $newRefs[$col] = $newPrimaryKey[$refCol];
                            }
                            $type = $this->_metadata[$col]['DATA_TYPE'];
                            $where[] = $this->_db->quoteInto(
                                $this->_db->quoteIdentifier($col, true) . ' = ?',
                                $oldPrimaryKey[$refCol], $type);
                        }
                        $rowsAffected += $this->update($newRefs, $where);
                        break;
                    default:
                        // no action
                        break;
                }
            }
        }
        return $rowsAffected;
    }

_fetch()

_fetch ( Zend_Db_Table_Select  $select )

protected

Support method for fetching rows.

Parameters

Zend_Db_Table_Select

$select

query options.

Returns

array An array containing the row results in FETCH_ASSOC mode.

Definition at line 1591 of file Abstract.php.

    {
        $stmt = $this->_db->query($select);
        $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
        return $data;
    }

_getCols()

_getCols ( )

protected

Retrieve table columns

Returns

array

Definition at line 855 of file Abstract.php.

    {
        if (null === $this->_cols) {
            $this->_setupMetadata();
            $this->_cols = array_keys($this->_metadata);
        }
        return $this->_cols;
    }

_getReferenceMapNormalized()

_getReferenceMapNormalized ( )

protected

Returns a normalized version of the reference map

Returns

array

Definition at line 928 of file Abstract.php.

    {
        $referenceMapNormalized = array();

        foreach ($this->_referenceMap as $rule => $map) {

            $referenceMapNormalized[$rule] = array();

            foreach ($map as $key => $value) {
                switch ($key) {

                    // normalize COLUMNS and REF_COLUMNS to arrays
                    case self::COLUMNS:
                    case self::REF_COLUMNS:
                        if (!is_array($value)) {
                            $referenceMapNormalized[$rule][$key] = array($value);
                        } else {
                            $referenceMapNormalized[$rule][$key] = $value;
                        }
                        break;

                    // other values are copied as-is
                    default:
                        $referenceMapNormalized[$rule][$key] = $value;
                        break;
                }
            }
        }

        return $referenceMapNormalized;
    }

_order()

_order ( Zend_Db_Table_Select  $select,   $order  )

protected

Generate ORDER clause from user-supplied string or array

Parameters

string | array

$order

OPTIONAL An SQL ORDER clause.

Returns

Zend_Db_Table_Select

Definition at line 1572 of file Abstract.php.

    {
        if (!is_array($order)) {
            $order = array($order);
        }

        foreach ($order as $val) {
            $select->order($val);
        }

        return $select;
    }

_setAdapter()

_setAdapter (   $db )

protected

Parameters

mixed

$db

Either an Adapter object, or a string naming a Registry key

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 580 of file Abstract.php.

    {
        $this->_db = self::_setupAdapter($db);
        return $this;
    }

_setMetadataCache()

_setMetadataCache (   $metadataCache )

protected

Sets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().

If $metadataCache is null, then no metadata cache is used. Since there is no opportunity to reload metadata after instantiation, this method need not be public, particularly because that it would have no effect results in unnecessary API complexity. To configure the metadata cache, use the metadataCache configuration option for the class constructor upon instantiation.

Parameters

mixed

$metadataCache

Either a Cache object, or a string naming a Registry key

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 651 of file Abstract.php.

    {
        $this->_metadataCache = self::_setupMetadataCache($metadataCache);
        return $this;
    }

_setSequence()

_setSequence (   $sequence )

protected

Sets the sequence member, which defines the behavior for generating primary key values in new rows.

• If this is a string, then the string names the sequence object.
• If this is boolean true, then the key uses an auto-incrementing or identity mechanism.
• If this is boolean false, then the key is user-defined. Use this for natural keys, for example.

Parameters

mixed

$sequence

Returns

Zend_Db_Table_Adapter_Abstract Provides a fluent interface

Definition at line 724 of file Abstract.php.

    {
        $this->_sequence = $sequence;

        return $this;
    }

_setup()

_setup ( )

protected

Turnkey for initialization of a table object. Calls other protected methods for individual tasks, to make it easier for a subclass to override part of the setup logic.

Returns

void

Definition at line 738 of file Abstract.php.

    {
        $this->_setupDatabaseAdapter();
        $this->_setupTableName();
    }

_setupAdapter()

static _setupAdapter (   $db )

staticprotected

Parameters

mixed

$db

Either an Adapter object, or a string naming a Registry key

Returns

Zend_Db_Adapter_Abstract

Exceptions

Zend_Db_Table_Exception

Definition at line 601 of file Abstract.php.

    {
        if ($db === null) {
            return null;
        }
        if (is_string($db)) {
            #require_once 'Zend/Registry.php';
            $db = Zend_Registry::get($db);
        }
        if (!$db instanceof Zend_Db_Adapter_Abstract) {
            #require_once 'Zend/Db/Table/Exception.php';
            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');
        }
        return $db;
    }

_setupDatabaseAdapter()

_setupDatabaseAdapter ( )

protected

Initialize database adapter.

Returns

void

Exceptions

Zend_Db_Table_Exception

Definition at line 750 of file Abstract.php.

    {
        if (! $this->_db) {
            $this->_db = self::getDefaultAdapter();
            if (!$this->_db instanceof Zend_Db_Adapter_Abstract) {
                #require_once 'Zend/Db/Table/Exception.php';
                throw new Zend_Db_Table_Exception('No adapter found for ' . get_class($this));
            }
        }
    }

_setupMetadata()

_setupMetadata ( )

protected

Initializes metadata.

If metadata cannot be loaded from cache, adapter's describeTable() method is called to discover metadata information. Returns true if and only if the metadata are loaded from cache.

Returns

boolean

Exceptions

Zend_Db_Table_Exception

Definition at line 790 of file Abstract.php.

    {
        if ($this->metadataCacheInClass() && (count($this->_metadata) > 0)) {
            return true;
        }

        // Assume that metadata will be loaded from cache
        $isMetadataFromCache = true;

        // If $this has no metadata cache but the class has a default metadata cache
        if (null === $this->_metadataCache && null !== self::$_defaultMetadataCache) {
            // Make $this use the default metadata cache of the class
            $this->_setMetadataCache(self::$_defaultMetadataCache);
        }

        // If $this has a metadata cache
        if (null !== $this->_metadataCache) {
            // Define the cache identifier where the metadata are saved

            //get db configuration
            $dbConfig = $this->_db->getConfig();

            $port = isset($dbConfig['options']['port'])
                  ? ':'.$dbConfig['options']['port']
                  : (isset($dbConfig['port'])
                  ? ':'.$dbConfig['port']
                  : null);

            $host = isset($dbConfig['options']['host'])
                  ? ':'.$dbConfig['options']['host']
                  : (isset($dbConfig['host'])
                  ? ':'.$dbConfig['host']
                  : null);

            // Define the cache identifier where the metadata are saved
            $cacheId = md5( // port:host/dbname:schema.table (based on availabilty)
                    $port . $host . '/'. $dbConfig['dbname'] . ':'
                  . $this->_schema. '.' . $this->_name
            );
        }

        // If $this has no metadata cache or metadata cache misses
        if (null === $this->_metadataCache || !($metadata = $this->_metadataCache->load($cacheId))) {
            // Metadata are not loaded from cache
            $isMetadataFromCache = false;
            // Fetch metadata from the adapter's describeTable() method
            $metadata = $this->_db->describeTable($this->_name, $this->_schema);
            // If $this has a metadata cache, then cache the metadata
            if (null !== $this->_metadataCache && !$this->_metadataCache->save($metadata, $cacheId)) {
                trigger_error('Failed saving metadata to metadataCache', E_USER_NOTICE);
            }
        }

        // Assign the metadata to $this
        $this->_metadata = $metadata;

        // Return whether the metadata were loaded from cache
        return $isMetadataFromCache;
    }

_setupMetadataCache()

static _setupMetadataCache (   $metadataCache )

staticprotected

Parameters

mixed

$metadataCache

Either a Cache object, or a string naming a Registry key

Returns

Zend_Cache_Core

Exceptions

Zend_Db_Table_Exception

Definition at line 696 of file Abstract.php.

    {
        if ($metadataCache === null) {
            return null;
        }
        if (is_string($metadataCache)) {
            #require_once 'Zend/Registry.php';
            $metadataCache = Zend_Registry::get($metadataCache);
        }
        if (!$metadataCache instanceof Zend_Cache_Core) {
            #require_once 'Zend/Db/Table/Exception.php';
            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');
        }
        return $metadataCache;
    }

_setupPrimaryKey()

_setupPrimaryKey ( )

protected

Initialize primary key from metadata. If $_primary is not defined, discover primary keys from the information returned by describeTable().

Returns

void

Exceptions

Zend_Db_Table_Exception

Special case for PostgreSQL: a SERIAL key implicitly uses a sequence object whose name is "<table>_<column>_seq".

Definition at line 872 of file Abstract.php.

    {
        if (!$this->_primary) {
            $this->_setupMetadata();
            $this->_primary = array();
            foreach ($this->_metadata as $col) {
                if ($col['PRIMARY']) {
                    $this->_primary[ $col['PRIMARY_POSITION'] ] = $col['COLUMN_NAME'];
                    if ($col['IDENTITY']) {
                        $this->_identity = $col['PRIMARY_POSITION'];
                    }
                }
            }
            // if no primary key was specified and none was found in the metadata
            // then throw an exception.
            if (empty($this->_primary)) {
                #require_once 'Zend/Db/Table/Exception.php';
                throw new Zend_Db_Table_Exception("A table must have a primary key, but none was found for table '{$this->_name}'");
            }
        } else if (!is_array($this->_primary)) {
            $this->_primary = array(1 => $this->_primary);
        } else if (isset($this->_primary[0])) {
            array_unshift($this->_primary, null);
            unset($this->_primary[0]);
        }

        $cols = $this->_getCols();
        if (! array_intersect((array) $this->_primary, $cols) == (array) $this->_primary) {
            #require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception("Primary key column(s) ("
                . implode(',', (array) $this->_primary)
                . ") are not columns in this table ("
                . implode(',', $cols)
                . ")");
        }

        $primary    = (array) $this->_primary;
        $pkIdentity = $primary[(int) $this->_identity];

        if ($this->_sequence === true && $this->_db instanceof Zend_Db_Adapter_Pdo_Pgsql) {
            $this->_sequence = $this->_db->quoteIdentifier("{$this->_name}_{$pkIdentity}_seq");
            if ($this->_schema) {
                $this->_sequence = $this->_db->quoteIdentifier($this->_schema) . '.' . $this->_sequence;
            }
        }
    }

_setupTableName()

_setupTableName ( )

protected

Initialize table and schema names.

If the table name is not set in the class definition, use the class name itself as the table name.

A schema name provided with the table name (e.g., "schema.table") overrides any existing value for $this->_schema.

Returns

void

Definition at line 772 of file Abstract.php.

    {
        if (! $this->_name) {
            $this->_name = get_class($this);
        } else if (strpos($this->_name, '.')) {
            list($this->_schema, $this->_name) = explode('.', $this->_name);
        }
    }

_where()

_where ( Zend_Db_Table_Select  $select,   $where  )

protected

Generate WHERE clause from user-supplied string or array

Parameters

string | array

$where

OPTIONAL An SQL WHERE clause.

Returns

Zend_Db_Table_Select

Definition at line 1547 of file Abstract.php.

    {
        $where = (array) $where;

        foreach ($where as $key => $val) {
            // is $key an int?
            if (is_int($key)) {
                // $val is the full condition
                $select->where($val);
            } else {
                // $key is the condition with placeholder,
                // and $val is quoted into the condition
                $select->where($key, $val);
            }
        }

        return $select;
    }

addReference()

addReference	(		$ruleKey,
			$columns,
			$refTableClass,
			$refColumns,
			$onDelete = null,
			$onUpdate = null
	)

Add a reference to the reference map

Parameters

string	$ruleKey
string | array	$columns
string	$refTableClass
string | array	$refColumns
string	$onDelete
string	$onUpdate

Returns

Zend_Db_Table_Abstract

Definition at line 424 of file Abstract.php.

    {
        $reference = array(self::COLUMNS         => (array) $columns,
                           self::REF_TABLE_CLASS => $refTableClass,
                           self::REF_COLUMNS     => (array) $refColumns);

        if (!empty($onDelete)) {
            $reference[self::ON_DELETE] = $onDelete;
        }

        if (!empty($onUpdate)) {
            $reference[self::ON_UPDATE] = $onUpdate;
        }

        $this->_referenceMap[$ruleKey] = $reference;

        return $this;
    }

createRow()

createRow	(	array	$data = array(),
			$defaultSource = null
	)

Fetches a new blank row (not from the database).

Parameters

array	$data	OPTIONAL data to populate in the new row.
string	$defaultSource	OPTIONAL flag to force default values into new row

Returns

Zend_Db_Table_Row_Abstract

Definition at line 1494 of file Abstract.php.

    {
        $cols     = $this->_getCols();
        $defaults = array_combine($cols, array_fill(0, count($cols), null));

        // nothing provided at call-time, take the class value
        if ($defaultSource == null) {
            $defaultSource = $this->_defaultSource;
        }

        if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
            $defaultSource = self::DEFAULT_NONE;
        }

        if ($defaultSource == self::DEFAULT_DB) {
            foreach ($this->_metadata as $metadataName => $metadata) {
                if (($metadata['DEFAULT'] != null) &&
                    ($metadata['NULLABLE'] !== true || ($metadata['NULLABLE'] === true && isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === true)) &&
                    (!(isset($this->_defaultValues[$metadataName]) && $this->_defaultValues[$metadataName] === false))) {
                    $defaults[$metadataName] = $metadata['DEFAULT'];
                }
            }
        } elseif ($defaultSource == self::DEFAULT_CLASS && $this->_defaultValues) {
            foreach ($this->_defaultValues as $defaultName => $defaultValue) {
                if (array_key_exists($defaultName, $defaults)) {
                    $defaults[$defaultName] = $defaultValue;
                }
            }
        }

        $config = array(
            'table'    => $this,
            'data'     => $defaults,
            'readOnly' => false,
            'stored'   => false
        );

        $rowClass = $this->getRowClass();
        if (!class_exists($rowClass)) {
            #require_once 'Zend/Loader.php';
            Zend_Loader::loadClass($rowClass);
        }
        $row = new $rowClass($config);
        $row->setFromArray($data);
        return $row;
    }

delete()

delete

(

$where

)

Deletes existing rows.

Parameters

array | string

$where

SQL WHERE clause(s).

Returns

int The number of rows deleted.

Execute cascading deletes against dependent tables

Definition at line 1182 of file Abstract.php.

    {
        $depTables = $this->getDependentTables();
        if (!empty($depTables)) {
            $resultSet = $this->fetchAll($where);
            if (count($resultSet) > 0 ) {
                foreach ($resultSet as $row) {
                    foreach ($depTables as $tableClass) {
                        $t = self::getTableFromString($tableClass, $this);
                        $t->_cascadeDelete(
                            get_class($this), $row->getPrimaryKey()
                        );
                    }
                }
            }
        }

        $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
        return $this->_db->delete($tableSpec, $where);
    }

fetchAll()

fetchAll	(		$where = null,
			$order = null,
			$count = null,
			$offset = null
	)

Fetches all rows.

Honors the Zend_Db_Adapter fetch mode.

Parameters

string | array | Zend_Db_Table_Select	$where	OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
string | array	$order	OPTIONAL An SQL ORDER clause.
int	$count	OPTIONAL An SQL LIMIT count.
int	$offset	OPTIONAL An SQL LIMIT offset.

Returns

Zend_Db_Table_Rowset_Abstract The row results per the Zend_Db_Adapter fetch mode.

Definition at line 1387 of file Abstract.php.

    {
        if (!($where instanceof Zend_Db_Table_Select)) {
            $select = $this->select();

            if ($where !== null) {
                $this->_where($select, $where);
            }

            if ($order !== null) {
                $this->_order($select, $order);
            }

            if ($count !== null || $offset !== null) {
                $select->limit($count, $offset);
            }

        } else {
            $select = $where;
        }

        $rows = $this->_fetch($select);

        $data  = array(
            'table'    => $this,
            'data'     => $rows,
            'readOnly' => $select->isReadOnly(),
            'rowClass' => $this->getRowClass(),
            'stored'   => true
        );

        $rowsetClass = $this->getRowsetClass();
        if (!class_exists($rowsetClass)) {
            #require_once 'Zend/Loader.php';
            Zend_Loader::loadClass($rowsetClass);
        }
        return new $rowsetClass($data);
    }

fetchNew()

fetchNew

(

)

Fetches a new blank row (not from the database).

Returns

Zend_Db_Table_Row_Abstract

Deprecated:

since 0.9.3 - use createRow() instead.

Definition at line 1482 of file Abstract.php.

    {
        return $this->createRow();
    }

fetchRow()

fetchRow	(		$where = null,
			$order = null,
			$offset = null
	)

Fetches one row in an object of type Zend_Db_Table_Row_Abstract, or returns null if no row matches the specified criteria.

Parameters

string | array | Zend_Db_Table_Select	$where	OPTIONAL An SQL WHERE clause or Zend_Db_Table_Select object.
string | array	$order	OPTIONAL An SQL ORDER clause.
int	$offset	OPTIONAL An SQL OFFSET value.

Returns

Zend_Db_Table_Row_Abstract|null The row results per the Zend_Db_Adapter fetch mode, or null if no row found.

Definition at line 1436 of file Abstract.php.

    {
        if (!($where instanceof Zend_Db_Table_Select)) {
            $select = $this->select();

            if ($where !== null) {
                $this->_where($select, $where);
            }

            if ($order !== null) {
                $this->_order($select, $order);
            }

            $select->limit(1, ((is_numeric($offset)) ? (int) $offset : null));

        } else {
            $select = $where->limit(1, $where->getPart(Zend_Db_Select::LIMIT_OFFSET));
        }

        $rows = $this->_fetch($select);

        if (count($rows) == 0) {
            return null;
        }

        $data = array(
            'table'   => $this,
            'data'     => $rows[0],
            'readOnly' => $select->isReadOnly(),
            'stored'  => true
        );

        $rowClass = $this->getRowClass();
        if (!class_exists($rowClass)) {
            #require_once 'Zend/Loader.php';
            Zend_Loader::loadClass($rowClass);
        }
        return new $rowClass($data);
    }

find()

find

(

)

Fetches rows by primary key. The argument specifies one or more primary key value(s). To find multiple rows by primary key, the argument must be an array.

This method accepts a variable number of arguments. If the table has a multi-column primary key, the number of arguments must be the same as the number of columns in the primary key. To find multiple rows in a table with a multi-column primary key, each argument must be an array with the same number of elements.

The find() method always returns a Rowset object, even if only one row was found.

Parameters

mixed

$key

The value(s) of the primary keys.

Returns

Zend_Db_Table_Rowset_Abstract Row(s) matching the criteria.

Exceptions

Zend_Db_Table_Exception

PHP 7.2 PATCH -->

PHP 7.2 PATCH <–

Definition at line 1288 of file Abstract.php.

    {
        $this->_setupPrimaryKey();
        $args = func_get_args();
        $keyNames = array_values((array) $this->_primary);

        if (count($args) < count($keyNames)) {
            #require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception("Too few columns for the primary key");
        }

        if (count($args) > count($keyNames)) {
            #require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception("Too many columns for the primary key");
        }

        $whereList = array();
        $numberTerms = 0;
        foreach ($args as $keyPosition => $keyValues) {
            if (is_array($keyValues) || $keyValues instanceof \Countable) {
                $keyValuesCount = count($keyValues);
            } else {
                if (null == $keyValues) {
                    $keyValuesCount = 0;
                } else {
                    $keyValuesCount = 1;
                }
            }
            #$keyValuesCount = count($keyValues);

            // Coerce the values to an array.
            // Don't simply typecast to array, because the values
            // might be Zend_Db_Expr objects.
            if (!is_array($keyValues)) {
                $keyValues = array($keyValues);
            }
            if ($numberTerms == 0) {
                $numberTerms = $keyValuesCount;
            } else if ($keyValuesCount != $numberTerms) {
                #require_once 'Zend/Db/Table/Exception.php';
                throw new Zend_Db_Table_Exception("Missing value(s) for the primary key");
            }
            $keyValues = array_values($keyValues);
            for ($i = 0; $i < $keyValuesCount; ++$i) {
                if (!isset($whereList[$i])) {
                    $whereList[$i] = array();
                }
                $whereList[$i][$keyPosition] = $keyValues[$i];
            }
        }

        $whereClause = null;
        if (count($whereList)) {
            $whereOrTerms = array();
            $tableName = $this->_db->quoteTableAs($this->_name, null, true);
            foreach ($whereList as $keyValueSets) {
                $whereAndTerms = array();
                foreach ($keyValueSets as $keyPosition => $keyValue) {
                    $type = $this->_metadata[$keyNames[$keyPosition]]['DATA_TYPE'];
                    $columnName = $this->_db->quoteIdentifier($keyNames[$keyPosition], true);
                    $whereAndTerms[] = $this->_db->quoteInto(
                        $tableName . '.' . $columnName . ' = ?',
                        $keyValue, $type);
                }
                $whereOrTerms[] = '(' . implode(' AND ', $whereAndTerms) . ')';
            }
            $whereClause = '(' . implode(' OR ', $whereOrTerms) . ')';
        }

        // issue ZF-5775 (empty where clause should return empty rowset)
        if ($whereClause == null) {
            $rowsetClass = $this->getRowsetClass();
            if (!class_exists($rowsetClass)) {
                #require_once 'Zend/Loader.php';
                Zend_Loader::loadClass($rowsetClass);
            }
            return new $rowsetClass(array('table' => $this, 'rowClass' => $this->getRowClass(), 'stored' => true));
        }

        return $this->fetchAll($whereClause);
    }

getAdapter()

getAdapter

(

)

Gets the Zend_Db_Adapter_Abstract for this particular Zend_Db_Table object.

Returns

Zend_Db_Adapter_Abstract

Definition at line 591 of file Abstract.php.

    {
        return $this->_db;
    }

getDefaultAdapter()

static getDefaultAdapter ( )

static

Gets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.

Returns

Zend_Db_Adapter_Abstract or null

Definition at line 571 of file Abstract.php.

    {
        return self::$_defaultDb;
    }

getDefaultMetadataCache()

static getDefaultMetadataCache ( )

static

Gets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().

Returns

Zend_Cache_Core or null

Definition at line 635 of file Abstract.php.

    {
        return self::$_defaultMetadataCache;
    }

getDefaultSource()

getDefaultSource

(

)

returns the default source flag that determines where defaultSources come from

Returns

unknown

Definition at line 528 of file Abstract.php.

    {
        return $this->_defaultSource;
    }

getDefaultValues()

getDefaultValues

(

)

Definition at line 549 of file Abstract.php.

    {
        return $this->_defaultValues;
    }

getDefinition()

getDefinition

(

)

getDefinition()

Returns

Zend_Db_Table_Definition|null

Definition at line 348 of file Abstract.php.

    {
        return $this->_definition;
    }

getDefinitionConfigName()

getDefinitionConfigName

(

)

getDefinitionConfigName()

Returns

string

Definition at line 370 of file Abstract.php.

    {
        return $this->_definitionConfigName;
    }

getDependentTables()

getDependentTables

(

)

Returns

array

Definition at line 502 of file Abstract.php.

    {
        return $this->_dependentTables;
    }

getMetadataCache()

getMetadataCache

(

)

Gets the metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().

Returns

Zend_Cache_Core or null

Definition at line 662 of file Abstract.php.

    {
        return $this->_metadataCache;
    }

getReference()

getReference	(		$tableClassname,
			$ruleKey = null
	)

Parameters

string	$tableClassname
string	$ruleKey	OPTIONAL

Returns

array

Exceptions

Zend_Db_Table_Exception

Definition at line 461 of file Abstract.php.

    {
        $thisClass = get_class($this);
        if ($thisClass === 'Zend_Db_Table') {
            $thisClass = $this->_definitionConfigName;
        }
        $refMap = $this->_getReferenceMapNormalized();
        if ($ruleKey !== null) {
            if (!isset($refMap[$ruleKey])) {
                #require_once "Zend/Db/Table/Exception.php";
                throw new Zend_Db_Table_Exception("No reference rule \"$ruleKey\" from table $thisClass to table $tableClassname");
            }
            if ($refMap[$ruleKey][self::REF_TABLE_CLASS] != $tableClassname) {
                #require_once "Zend/Db/Table/Exception.php";
                throw new Zend_Db_Table_Exception("Reference rule \"$ruleKey\" does not reference table $tableClassname");
            }
            return $refMap[$ruleKey];
        }
        foreach ($refMap as $reference) {
            if ($reference[self::REF_TABLE_CLASS] == $tableClassname) {
                return $reference;
            }
        }
        #require_once "Zend/Db/Table/Exception.php";
        throw new Zend_Db_Table_Exception("No reference from table $thisClass to table $tableClassname");
    }

getRowClass()

getRowClass

(

)

Returns

string

Definition at line 389 of file Abstract.php.

    {
        return $this->_rowClass;
    }

getRowsetClass()

getRowsetClass

(

)

Returns

string

Definition at line 408 of file Abstract.php.

    {
        return $this->_rowsetClass;
    }

getTableFromString()

static getTableFromString (   $tableName, Zend_Db_Table_Abstract  $referenceTable = null  )

static

Get table gateway object from string

Parameters

string	$tableName
Zend_Db_Table_Abstract	$referenceTable

Exceptions

Zend_Db_Table_Row_Exception

Returns

Zend_Db_Table_Abstract

Definition at line 1606 of file Abstract.php.

    {
        if ($referenceTable instanceof Zend_Db_Table_Abstract) {
            $tableDefinition = $referenceTable->getDefinition();

            if ($tableDefinition !== null && $tableDefinition->hasTableConfig($tableName)) {
                return new Zend_Db_Table($tableName, $tableDefinition);
            }
        }

        // assume the tableName is the class name
        if (!class_exists($tableName)) {
            try {
                #require_once 'Zend/Loader.php';
                Zend_Loader::loadClass($tableName);
            } catch (Zend_Exception $e) {
                #require_once 'Zend/Db/Table/Row/Exception.php';
                throw new Zend_Db_Table_Row_Exception($e->getMessage(), $e->getCode(), $e);
            }
        }

        $options = array();

        if ($referenceTable instanceof Zend_Db_Table_Abstract) {
            $options['db'] = $referenceTable->getAdapter();
        }

        if (isset($tableDefinition) && $tableDefinition !== null) {
            $options[Zend_Db_Table_Abstract::DEFINITION] = $tableDefinition;
        }

        return new $tableName($options);
    }

info()

info

(

$key = null

)

Returns table information.

You can elect to return only a part of this information by supplying its key name, otherwise all information is returned as an array.

Parameters

string

$key

The specific info part to return OPTIONAL

Returns

mixed

Exceptions

Zend_Db_Table_Exception

Definition at line 981 of file Abstract.php.

    {
        $this->_setupPrimaryKey();

        $info = array(
            self::SCHEMA           => $this->_schema,
            self::NAME             => $this->_name,
            self::COLS             => $this->_getCols(),
            self::PRIMARY          => (array) $this->_primary,
            self::METADATA         => $this->_metadata,
            self::ROW_CLASS        => $this->getRowClass(),
            self::ROWSET_CLASS     => $this->getRowsetClass(),
            self::REFERENCE_MAP    => $this->_referenceMap,
            self::DEPENDENT_TABLES => $this->_dependentTables,
            self::SEQUENCE         => $this->_sequence
        );

        if ($key === null) {
            return $info;
        }

        if (!array_key_exists($key, $info)) {
            #require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception('There is no table information for the key "' . $key . '"');
        }

        return $info[$key];
    }

init()

init

(

)

Initialize object

Called from __construct() as final step of object instantiation.

Returns

void

Definition at line 967 of file Abstract.php.

    {
    }

insert()

insert

(

array

$data

)

Inserts a new row.

Parameters

array

$data

Column-value pairs.

Returns

mixed The primary key of the row inserted.

Zend_Db_Table assumes that if you have a compound primary key and one of the columns in the key uses a sequence, it's the first column in the compound key.

If the primary key can be generated automatically, and no value was specified in the user-supplied data, then omit it from the tuple.

Note: this checks for sensible values in the supplied primary key position of the data. The following values are considered empty: null, false, true, '', array()

If this table uses a database sequence object and the data does not specify a value, then get the next ID from the sequence and add it to the row. We assume that only the first column in a compound primary key takes a value from a sequence.

INSERT the new row.

Fetch the most recent ID generated by an auto-increment or IDENTITY column, unless the user has specified a value, overriding the auto-increment mechanism.

Return the primary key value if the PK is a single column, else return an associative array of the PK column/value pairs.

Definition at line 1032 of file Abstract.php.

    {
        $this->_setupPrimaryKey();

        $primary = (array) $this->_primary;
        $pkIdentity = $primary[(int)$this->_identity];


        if (array_key_exists($pkIdentity, $data)) {
            if ($data[$pkIdentity] === null                                        // null
                || $data[$pkIdentity] === ''                                       // empty string
                || is_bool($data[$pkIdentity])                                     // boolean
                || (is_array($data[$pkIdentity]) && empty($data[$pkIdentity]))) {  // empty array
                unset($data[$pkIdentity]);
            }
        }

        if (is_string($this->_sequence) && !isset($data[$pkIdentity])) {
            $data[$pkIdentity] = $this->_db->nextSequenceId($this->_sequence);
        }

        $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
        $this->_db->insert($tableSpec, $data);

        if ($this->_sequence === true && !isset($data[$pkIdentity])) {
            $data[$pkIdentity] = $this->_db->lastInsertId();
        }

        $pkData = array_intersect_key($data, array_flip($primary));
        if (count($primary) == 1) {
            reset($pkData);
            return current($pkData);
        }

        return $pkData;
    }

isIdentity()

isIdentity

(

$column

)

Check if the provided column is an identity of the table

Parameters

string

$column

Exceptions

Zend_Db_Table_Exception

Returns

boolean

See also

Zend_Db_Table_Exception

Definition at line 1107 of file Abstract.php.

    {
        $this->_setupPrimaryKey();

        if (!isset($this->_metadata[$column])) {
            #require_once 'Zend/Db/Table/Exception.php';

            throw new Zend_Db_Table_Exception('Column "' . $column . '" not found in table.');
        }

        return (bool) $this->_metadata[$column]['IDENTITY'];
    }

metadataCacheInClass()

metadataCacheInClass

(

)

Retrieve flag indicating if metadata should be cached for duration of instance

Returns

bool

Definition at line 686 of file Abstract.php.

    {
        return $this->_metadataCacheInClass;
    }

select()

select

(

$withFromPart = self::SELECT_WITHOUT_FROM_PART

)

Returns an instance of a Zend_Db_Table_Select object.

Parameters

bool

$withFromPart

Whether or not to include the from part of the select based on the table

Returns

Zend_Db_Table_Select

Definition at line 1016 of file Abstract.php.

    {
        #require_once 'Zend/Db/Table/Select.php';
        $select = new Zend_Db_Table_Select($this);
        if ($withFromPart == self::SELECT_WITH_FROM_PART) {
            $select->from($this->info(self::NAME), Zend_Db_Table_Select::SQL_WILDCARD, $this->info(self::SCHEMA));
        }
        return $select;
    }

setDefaultAdapter()

static setDefaultAdapter (   $db = null )

static

Sets the default Zend_Db_Adapter_Abstract for all Zend_Db_Table objects.

Parameters

mixed

$db

Either an Adapter object, or a string naming a Registry key

Returns

void

Definition at line 561 of file Abstract.php.

    {
        self::$_defaultDb = self::_setupAdapter($db);
    }

setDefaultMetadataCache()

static setDefaultMetadataCache (   $metadataCache = null )

static

Sets the default metadata cache for information returned by Zend_Db_Adapter_Abstract::describeTable().

If $defaultMetadataCache is null, then no metadata cache is used by default.

Parameters

mixed

$metadataCache

Either a Cache object, or a string naming a Registry key

Returns

void

Definition at line 625 of file Abstract.php.

    {
        self::$_defaultMetadataCache = self::_setupMetadataCache($metadataCache);
    }

setDefaultSource()

setDefaultSource

(

$defaultSource = self::DEFAULT_NONE

)

set the defaultSource property - this tells the table class where to find default values

Parameters

string

$defaultSource

Returns

Zend_Db_Table_Abstract

Definition at line 513 of file Abstract.php.

    {
        if (!in_array($defaultSource, array(self::DEFAULT_CLASS, self::DEFAULT_DB, self::DEFAULT_NONE))) {
            $defaultSource = self::DEFAULT_NONE;
        }

        $this->_defaultSource = $defaultSource;
        return $this;
    }

setDefaultValues()

setDefaultValues

(

Array

$defaultValues

)

set the default values for the table class

Parameters

array

$defaultValues

Returns

Zend_Db_Table_Abstract

Definition at line 539 of file Abstract.php.

    {
        foreach ($defaultValues as $defaultName => $defaultValue) {
            if (array_key_exists($defaultName, $this->_metadata)) {
                $this->_defaultValues[$defaultName] = $defaultValue;
            }
        }
        return $this;
    }

setDefinition()

setDefinition

(

Zend_Db_Table_Definition

$definition

)

setDefinition()

Parameters

Zend_Db_Table_Definition

$definition

Returns

Zend_Db_Table_Abstract

Definition at line 337 of file Abstract.php.

    {
        $this->_definition = $definition;
        return $this;
    }

setDefinitionConfigName()

setDefinitionConfigName

(

$definitionConfigName

)

setDefinitionConfigName()

Parameters

string

$definition

Returns

Zend_Db_Table_Abstract

Definition at line 359 of file Abstract.php.

    {
        $this->_definitionConfigName = $definitionConfigName;
        return $this;
    }

setDependentTables()

setDependentTables

(

array

$dependentTables

)

Parameters

array

$dependentTables

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 492 of file Abstract.php.

    {
        $this->_dependentTables = $dependentTables;

        return $this;
    }

setMetadataCacheInClass()

setMetadataCacheInClass

(

$flag

)

Indicate whether metadata should be cached in the class for the duration of the instance

Parameters

bool

$flag

Returns

Zend_Db_Table_Abstract

Definition at line 674 of file Abstract.php.

    {
        $this->_metadataCacheInClass = (bool) $flag;
        return $this;
    }

setOptions()

setOptions

(

Array

$options

)

setOptions()

Parameters

array

$options

Returns

Zend_Db_Table_Abstract

Definition at line 279 of file Abstract.php.

    {
        foreach ($options as $key => $value) {
            switch ($key) {
                case self::ADAPTER:
                    $this->_setAdapter($value);
                    break;
                case self::DEFINITION:
                    $this->setDefinition($value);
                    break;
                case self::DEFINITION_CONFIG_NAME:
                    $this->setDefinitionConfigName($value);
                    break;
                case self::SCHEMA:
                    $this->_schema = (string) $value;
                    break;
                case self::NAME:
                    $this->_name = (string) $value;
                    break;
                case self::PRIMARY:
                    $this->_primary = (array) $value;
                    break;
                case self::ROW_CLASS:
                    $this->setRowClass($value);
                    break;
                case self::ROWSET_CLASS:
                    $this->setRowsetClass($value);
                    break;
                case self::REFERENCE_MAP:
                    $this->setReferences($value);
                    break;
                case self::DEPENDENT_TABLES:
                    $this->setDependentTables($value);
                    break;
                case self::METADATA_CACHE:
                    $this->_setMetadataCache($value);
                    break;
                case self::METADATA_CACHE_IN_CLASS:
                    $this->setMetadataCacheInClass($value);
                    break;
                case self::SEQUENCE:
                    $this->_setSequence($value);
                    break;
                default:
                    // ignore unrecognized configuration directive
                    break;
            }
        }

        return $this;
    }

setReferences()

setReferences

(

array

$referenceMap

)

Parameters

array

$referenceMap

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 448 of file Abstract.php.

    {
        $this->_referenceMap = $referenceMap;

        return $this;
    }

setRowClass()

setRowClass

(

$classname

)

Parameters

string

$classname

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 379 of file Abstract.php.

    {
        $this->_rowClass = (string) $classname;

        return $this;
    }

setRowsetClass()

setRowsetClass

(

$classname

)

Parameters

string

$classname

Returns

Zend_Db_Table_Abstract Provides a fluent interface

Definition at line 398 of file Abstract.php.

    {
        $this->_rowsetClass = (string) $classname;

        return $this;
    }

update()

update	(	array	$data,
			$where
	)

Updates existing rows.

Parameters

array	$data	Column-value pairs.
array | string	$where	An SQL WHERE clause, or an array of SQL WHERE clauses.

Returns

int The number of rows updated.

Definition at line 1130 of file Abstract.php.

    {
        $tableSpec = ($this->_schema ? $this->_schema . '.' : '') . $this->_name;
        return $this->_db->update($tableSpec, $data, $where);
    }

Field Documentation

$_cols

$_cols

protected

Definition at line 138 of file Abstract.php.

$_db

$_db

protected

Definition at line 117 of file Abstract.php.

$_defaultDb

$_defaultDb

staticprotected

Definition at line 89 of file Abstract.php.

$_defaultMetadataCache

$_defaultMetadataCache = null

staticprotected

Definition at line 110 of file Abstract.php.

$_defaultSource

$_defaultSource = self::DEFAULT_NONE

protected

Definition at line 235 of file Abstract.php.

$_defaultValues

$_defaultValues = array()

protected

Definition at line 236 of file Abstract.php.

$_definition

$_definition = null

protected

Definition at line 96 of file Abstract.php.

$_definitionConfigName

$_definitionConfigName = null

protected

Definition at line 103 of file Abstract.php.

$_dependentTables

$_dependentTables = array()

protected

Definition at line 232 of file Abstract.php.

$_identity

$_identity = 1

protected

Definition at line 160 of file Abstract.php.

$_metadata

$_metadata = array()

protected

Definition at line 175 of file Abstract.php.

$_metadataCache

$_metadataCache = null

protected

Definition at line 182 of file Abstract.php.

$_metadataCacheInClass

$_metadataCacheInClass = true

protected

Definition at line 188 of file Abstract.php.

$_name

$_name = null

protected

Definition at line 131 of file Abstract.php.

$_primary

$_primary = null

protected

Definition at line 148 of file Abstract.php.

$_referenceMap

$_referenceMap = array()

protected

Definition at line 222 of file Abstract.php.

$_rowClass

$_rowClass = 'Zend_Db_Table_Row'

protected

Definition at line 195 of file Abstract.php.

$_rowsetClass

$_rowsetClass = 'Zend_Db_Table_Rowset'

protected

Definition at line 202 of file Abstract.php.

$_schema

$_schema = null

protected

Definition at line 124 of file Abstract.php.

$_sequence

$_sequence = true

protected

Definition at line 168 of file Abstract.php.

ADAPTER

const ADAPTER = 'db'

Definition at line 50 of file Abstract.php.

CASCADE

const CASCADE = 'cascade'

Definition at line 72 of file Abstract.php.

CASCADE_RECURSE

const CASCADE_RECURSE = 'cascadeRecurse'

Definition at line 73 of file Abstract.php.

COLS

const COLS = 'cols'

Definition at line 56 of file Abstract.php.

COLUMNS

const COLUMNS = 'columns'

Definition at line 66 of file Abstract.php.

DEFAULT_CLASS

const DEFAULT_CLASS = 'defaultClass'

Definition at line 78 of file Abstract.php.

DEFAULT_DB

const DEFAULT_DB = 'defaultDb'

Definition at line 79 of file Abstract.php.

DEFAULT_NONE

const DEFAULT_NONE = 'defaultNone'

Definition at line 77 of file Abstract.php.

DEFINITION

const DEFINITION = 'definition'

Definition at line 51 of file Abstract.php.

DEFINITION_CONFIG_NAME

const DEFINITION_CONFIG_NAME = 'definitionConfigName'

Definition at line 52 of file Abstract.php.

DEPENDENT_TABLES

const DEPENDENT_TABLES = 'dependentTables'

Definition at line 63 of file Abstract.php.

METADATA

const METADATA = 'metadata'

Definition at line 57 of file Abstract.php.

METADATA_CACHE

const METADATA_CACHE = 'metadataCache'

Definition at line 58 of file Abstract.php.

METADATA_CACHE_IN_CLASS

const METADATA_CACHE_IN_CLASS = 'metadataCacheInClass'

Definition at line 59 of file Abstract.php.

NAME

const NAME = 'name'

Definition at line 54 of file Abstract.php.

ON_DELETE

const ON_DELETE = 'onDelete'

Definition at line 69 of file Abstract.php.

ON_UPDATE

const ON_UPDATE = 'onUpdate'

Definition at line 70 of file Abstract.php.

PRIMARY

const PRIMARY = 'primary'

Definition at line 55 of file Abstract.php.

REF_COLUMNS

const REF_COLUMNS = 'refColumns'

Definition at line 68 of file Abstract.php.

REF_TABLE_CLASS

const REF_TABLE_CLASS = 'refTableClass'

Definition at line 67 of file Abstract.php.

REFERENCE_MAP

const REFERENCE_MAP = 'referenceMap'

Definition at line 62 of file Abstract.php.

RESTRICT

const RESTRICT = 'restrict'

Definition at line 74 of file Abstract.php.

ROW_CLASS

const ROW_CLASS = 'rowClass'

Definition at line 60 of file Abstract.php.

ROWSET_CLASS

const ROWSET_CLASS = 'rowsetClass'

Definition at line 61 of file Abstract.php.

SCHEMA

const SCHEMA = 'schema'

Definition at line 53 of file Abstract.php.

SELECT_WITH_FROM_PART

const SELECT_WITH_FROM_PART = true

Definition at line 81 of file Abstract.php.

SELECT_WITHOUT_FROM_PART

const SELECT_WITHOUT_FROM_PART = false

Definition at line 82 of file Abstract.php.

SEQUENCE

const SEQUENCE = 'sequence'

Definition at line 64 of file Abstract.php.

SET_NULL

const SET_NULL = 'setNull'

Definition at line 75 of file Abstract.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Db/Table/Abstract.php