See Also:

Doctrine_Record_Filter

Generator instance responsible for constructing this table

See Also:

Doctrine_Record_Generator

See Also:

Doctrine_Record_Generator

See Also:

constants

See Also:

Doctrine_Template

Array of unique sets of fields. These values are validated on save

the constructor

Throws:

if there are no opened connections

Parameters:

name - the name of the component

conn - the connection associated with this table

initDefinition - whether to init the in-memory schema

Adds a check constraint to the table in-memory definition.

This method adds a CHECK constraint to the schema definition. It does not add the constraint to the physical table in the db; @see export().

Parameters:

name - if string used as name for the constraint. Otherwise it is indexed numerically.

Adds a foreignKey to the table in-memory definition.

This method adds a foreign key to the schema definition. It does not add the key to the physical table in the db; @see export().

Parameters:

definition - definition of the foreign key

Adds a generate to the table instance.

Adds an index to this table in-memory definition.

This method adds an INDEX to the schema definition. It does not add the index to the physical table in the db; @see export().

Parameters:

index - index name

definition - keys are type, fields

Adds a named query in the query registry.

This methods register a query object with a name to use in the future.

See Also:

createNamedQuery()

Parameters:

query - key name to use for storage

query - DQL string or object

Adds a record to the first level cache (identity map).

This method is used internally to cache records, ensuring that only one object that represents a sql record exists in all scopes.

Parameters:

record - record to be added

Returns:

true if record was not present in the map

Todo:

Better name? registerRecord?

Adds a template to this table.

Parameters:

template - template name

impl - behavior to attach

applyInheritance

Parameters:

query - where part to be modified

Returns:

query where part with column aggregation inheritance added

Adds a relation to the table.

This method defines a relation on this table, that will be present on every record belonging to this component.

Parameters:

args - first value is a string, name of related component; second value is array, options for the relation.

type - Doctrine_Relation::ONE or Doctrine_Relation::MANY

See Also:

Doctrine_Relation::_$definition

Todo:

Name proposal: addRelation

Adds default query parts to the selects executed on this table.

This method binds given value to given query part. Every query created by this table will have this part set by default.

Returns:

this object

Binds query parts to this component.

See Also:

bindQueryPart()

Parameters:

queryParts - an array of pre-bound query parts

Returns:

this object

Clears the first level cache (identityMap).

This method ensures that records are reloaded from the db.

Todo:

what about a more descriptive name? clearIdentityMap?

Construct template method.

This method provides concrete Table classes with the possibility to hook into the constructor procedure. It is called after the Doctrine_Table construction process is finished.

Implements Countable interface.

Returns:

number of records in the table

Creates a new record.

This method create a new instance of the model defined by this table. The class of this record is the subclass of Doctrine_Record defined by this component. The record is not created in the database until you call @save().

Parameters:

an - array where keys are field names and values representing field values. Can contain also related components;

See Also:

Doctrine_Record::fromArray()

Returns:

the created record object

Creates a named query from one in the query registry.

This method clones a new query object from a previously registered one.

See Also:

addNamedQuery()

Parameters:

queryKey - query key name

Creates a query on this table.

This method returns a new Doctrine_Query object and adds the component name of this table as the query 'from' part. $table = Doctrine_Core::getTable('User'); $table->createQuery('myuser') ->where('myuser.Phonenumber = ?', '5551234');

Parameters:

alias - name for component aliasing

Retrieves an enum index.

See Also:

enumValue()

Parameters:

value - value of the enum considered

Returns:

can be string if native enums are used.

Retrieves an enum value.

This method finds a enum string value. If ATTR_USE_NATIVE_ENUM is set on the connection, index and value are the same thing.

Parameters:

index - numeric index of the enum

Finds result of a named query.

This method fetches data using the provided $queryKey to choose a named query in the query registry.

Parameters:

queryKey - the query key

params - prepared statement params (if any)

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Throws:

if no query for given queryKey is found

Fetches one record with a named query.

This method uses the provided $queryKey to clone and execute the associated named query in the query registry.

Parameters:

queryKey - the query key

params - prepared statement params (if any)

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Throws:

if no query for given queryKey is found

Exports this table to database based on the schema definition.

This method create a physical table in the database, using the definition that comes from the component Doctrine_Record instance.

Throws:

if some error other than Doctrine_Core::ERR_ALREADY_EXISTS occurred during the create table operation

Returns:

whether or not the export operation was successful false if table already existed in the database

Finds a record by its identifier.

$table->find(11); $table->find(11, Doctrine_Core::HYDRATE_RECORD); $table->find('namedQueryForYearArchive', array(2009), Doctrine_Core::HYDRATE_ARRAY);

Parameters:

name - Database Row ID or Query Name defined previously as a NamedQuery

params - This argument is the hydration mode (Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD) if first param is a Database Row ID. Otherwise this argument expect an array of query params.

hydrationMode - Optional Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD if first argument is a NamedQuery

Returns:

Doctrine_Collection, array, Doctrine_Record or false if no result

Retrieves all the records stored in this table.

Parameters:

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Find records basing on a field.

Parameters:

column - field for the WHERE clause

value - prepared statement parameter

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Finds records in this table with a given DQL where clause.

Parameters:

dql - DQL WHERE clause

params - preparated statement parameters

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Finds records in this table with a given SQL where clause.

Parameters:

dql - DQL WHERE clause to use

params - query parameters (a la PDO)

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Todo:

This actually takes DQL, not SQL, but it requires column names instead of field names. This should be fixed to use raw SQL instead.

Finds the first record that satisfy the clause.

Parameters:

column - field for the WHERE clause

value - prepared statement parameter

hydrationMode - Doctrine_Core::HYDRATE_ARRAY or Doctrine_Core::HYDRATE_RECORD

Retrieves a bound query part.

See Also:

bindQueryPart()

Parameters:

queryPart - field interested

Returns:

value of the bind

Get the classname to return. Most often this is just the options['name'].

Check the subclasses option and the inheritanceMap for each subclass to see if all the maps in a subclass is met. If this is the case return that subclass name. If no subclasses match or if there are no subclasses defined return the name of the class for this tables record.

Todo:

this function could use reflection to check the first time it runs if the subclassing option is not set.

Returns:

The name of the class to create

Deprecated.

Returns:

the number of columns in this table

Retrieves a column definition from this table schema.

Returns:

column definition; @see $_columns

Returns a column name for a column alias.

If the actual name for the alias cannot be found this method returns the given alias.

Parameters:

alias - column alias

Returns:

column name

Returns an array containing all the column names.

Returns:

numeric array

Gets the owner of a column.

The owner of a column is the name of the component in a hierarchy that defines the column.

Parameters:

columnName - the column name

Returns:

the name of the owning/defining component

Retrieves all columns of the table.

See Also:

$_columns;

Returns:

keys are column names and values are definition

Gets the subclass of Doctrine_Record that belongs to this table.

Returns the connection associated with this table (if any).

Returns:

the connection object

Returns internal data.

This method is used by Doctrine_Record instances when retrieving data from database.

Retrieves the default value (if any) for a given column.

Parameters:

fieldName - column name

Returns:

default value as set in definition

Retrieves the definition of a field.

This method retrieves the definition of the column, basing of $fieldName which can be a column name or a field name (alias).

Returns:

false on failure

Retrieves the enum values for a given field.

Returns an exportable representation of this object.

This method produces a array representation of the table schema, where keys are tableName, columns (@see $_columns) and options. The options subarray contains 'primary' and 'foreignKeys'.

Parameters:

parseForeignKeys - whether to include foreign keys definition in the options

Gets the maximum length of a field. For integer fields, length is bytes occupied. For decimal fields, it is the total number of cyphers

Returns a column alias for a column name.

If no alias can be found the column name is returned.

Parameters:

columnName - column name

Returns:

column alias

Returns an array containing all the field names.

Returns:

numeric array

Gets the names of all validators being applied on a field.

Returns:

names of validators

getFilters

Returns:

$filters

Gets generator instance for a passed name.

Returns:

$generator

Gets all the generators for this table.

Returns:

$generators

Returns the definition of the identifier key.

Returns:

can be array if a multi-column primary key is used.

Returns an array with all the identifier column names.

Returns:

numeric array

Retrieves the type of primary key.

This method finds out if the primary key is multifield.

See Also:

constants

Retrieves an index definition.

This method returns a given index definition: @see addIndex().

Parameters:

index - index name; @see addIndex()

Returns:

array on success, FALSE on failure

getMethodOwner

Returns the value of a given option.

See Also:

for available options

Parameters:

name - the name of the option

Returns:

the value of given option

Retrieves all options of this table and the associated values.

Returns:

all options and their values

Get the table orderby statement

Parameters:

alias - The alias to use

columnNames - Whether or not to use column names instead of field names

Returns:

$orderByStatement

Get the parent generator responsible for this table instance

Parameters:

database - row id

Throws:

Doctrine_Find_Exception

Returns:

a Doctrine_Query object

Returns a new record.

This method checks if a internal record exists in identityMap, if does not exist it creates a new one.

Gets the record instance for this table.

The Doctrine_Table instance always holds at least one instance of a model so that it can be reused for several things, but primarily it is first used to instantiate all the internal in memory schema definition.

Returns:

Empty instance of the record

Retrieves a relation object for this component.

Parameters:

alias - relation alias; @see hasRelation()

Retrieves the relation parser associated with this table.

Returns:

relation parser object

Retrieves all relation objects defined on this table.

Gets the internal record repository.

Gets the table name in the db.

Retrieves a particular template by class name.

This method retrieves a behavior/template object attached to the table. For Doctrine_Template_* classes, the base name can be used.

Parameters:

template - name of the behavior

Throws:

if the given template is not set on this table

Retrieves all templates (behaviors) attached to this table.

Returns:

an array containing all templates

Gets associated tree. This method returns the associated Tree object (if any exists). Normally implemented by NestedSet behavior.

Returns:

false if not a tree

Retrieves the type of a field.

Returns:

false on failure

Retrieves the type of a column.

Returns:

false if column is not found

Gets the array of unique fields sets.

See Also:

$_uniques;

Returns:

numeric array

Finds out whether the table definition contains a given column.

Finds out whether this table has default values for columns.

Finds out whether the table definition has a given field.

This method returns true if @see hasColumn() returns true or if an alias named $fieldName exists.

Checks if a generator name exists.

Binds One-to-Many / Many-to-Many aggregate relation

Parameters:

componentName - the name of the related component

options - relation options

See Also:

Doctrine_Relation::_$definition

Returns:

this object

Binds One-to-One aggregate relation

Parameters:

componentName - the name of the related component

options - relation options

See Also:

Doctrine_Relation::_$definition

Returns:

this object

Tests if a relation exists.

This method queries the table definition to find out if a relation is defined for this component. Alias defined with foreignAlias are not recognized as there's only one Doctrine_Relation object on the owning side.

Parameters:

alias - the relation alias to search for.

Returns:

true if the relation exists. Otherwise false.

Checks if the table has a given template.

Parameters:

template - name of template; @see getTemplate()

Initializes the in-memory table definition.

Initializes the primary key.

Called in the construction process, builds the identifier definition copying in the schema the list of the fields which constitutes the primary key.

Check whether this table was created by a record generator or not

Checks whether a field is in the primary key.

Checks if $fieldName is part of the table identifier, which defines the one-column or multi-column primary key.

Parameters:

fieldName - The field name

Returns:

TRUE if the field is part of the table identifier/primary key field(s),

Checks whether a field identifier is of type autoincrement.

This method checks if the primary key is a AUTOINCREMENT column or if the table uses a natural key.

Returns:

TRUE if the identifier is autoincrement FALSE otherwise

Checks whether a field identifier is a composite key.

Returns:

TRUE if the identifier is a composite key, FALSE otherwise

Checks whether a column is inherited from a component further up in the hierarchy.

Parameters:

The - column name

Returns:

TRUE if column is inherited, FALSE otherwise.

Determines if table acts as tree.

Returns:

if tree return true, otherwise returns false

Performs special data preparation.

This method returns a representation of a field data, depending on the type of the given column.

1. It unserializes array and object typed columns 2. Uncompresses gzip typed columns 3. Initializes special null object pointer for null values (for fast column existence checking purposes)

example: $field = 'name'; $value = null; $table->prepareValue($field, $value); // Doctrine_Null

Throws:

if unserialization of array/object typed column fails or

if uncompression of gzip typed column fails *

Parameters:

field - the name of the field

value - field value

typeHint - Type hint used to pass in the type of the value to prepare if it is already known. This enables the method to skip the type determination. Used i.e. during hydration.

Returns:

prepared value

Process an order by statement to be prefixed with the passed alias and field names converted to column names if the 3rd argument is true.

Parameters:

alias - The alias to prefix columns with

orderBy - The order by to process

columnNames - Whether or not to convert field names to column names

Returns:

$orderBy

Removes a field name from the table schema information.

Returns:

true if the field is found and removed. False otherwise.

Removes a record from the identity map.

This method deletes from the cache the given record; can be used to force reloading of an object from database.

Parameters:

record - record to remove from cache

Returns:

true if the record was found and removed, false if the record wasn't found.

Adds a column to the schema.

This method does not alter the database table; @see export();

See Also:

$_columns;

Parameters:

name - column physical name

type - type of data

length - maximum length

prepend - Whether to prepend or append the new column to the column list. By default the column gets appended.

Throws:

if trying use wrongly typed parameter

Set an individual column option

Customize the array of options for a column or multiple columns. First argument can be a single field/column name or an array of them. The second argument is an array of options.

[php] public function setTableDefinition() { parent::setTableDefinition(); $this->setColumnOptions('username', array( 'unique' => true )); }

Set multiple column definitions at once

Sets the default connection for this table.

This method assign the connection which this table will use to create queries.

Params:

Doctrine_Connection a connection object

Returns:

this object; fluent interface

Doctrine uses this function internally. Users are strongly discouraged to use this function.

Parameters:

data - internal data

Set the generator responsible for creating this table

setMethodOwner

Sets an option for the table.

This method sets an option and returns this object in order to allow flexible method chaining.

See Also:

for available options

Parameters:

name - the name of the option to set

value - the value of the option

Returns:

this object

Sets all the options.

This method sets options of the table that are specified in the argument. It has no effect on other options.

Parameters:

options - keys are option names

sets the table name in the schema definition.

Defines a n-uple of fields that must be unique for every record.

This method Will automatically add UNIQUE index definition and validate the values on save. The UNIQUE index is not created in the database until you use @see export().

Parameters:

fields - values are fieldnames

options - array of options for unique validator

createUniqueIndex - Whether or not to create a unique index in the database

unshiftFilter

Returns:

this object (provides a fluent interface)

Validates a given field using table ATTR_VALIDATE rules.

See Also:

Doctrine_Core::ATTR_VALIDATE

Parameters:

record - record to consider; if it does not exists, it is created

Returns:

$errorStack

Validates all the unique indexes.

This methods validates 'unique' sets of fields for the given Doctrine_Record instance. Pushes error to the record error stack if they are generated.