# Abstract class Phalcon\\Mvc\\Model
# Abstract class **Phalcon\\Mvc\\Model**
*implements*[*Phalcon\\Mvc\\EntityInterface*](#), [*Phalcon\\Mvc\\ModelInterface*](#), [*Phalcon\\Mvc\\Model\\ResultInterface*](#), `Phalcon\Di\InjectionAwareInterface`, Serializable
Phalcon\\Mvc\\Model connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. It‘s an implementation of the object-relational mapping (ORM). A model represents the information (data) of the application and the rules to manipulate that data. Models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, each table in your database will correspond to one model in your application. The bulk of your application's business logic will be concentrated in the models. Phalcon\\Mvc\\Model is the first ORM written in Zephir/C languages for PHP, giving to developers high performance when interacting with databases while is also easy to use.
```
<pre class="calibre14">```
<?php
$robot = new Robots();
$robot->type = 'mechanical';
$robot->name = 'Astro Boy';
$robot->year = 1952;
if ($robot->save() == false) {
echo "Umh, We can store robots: ";
foreach ($robot->getMessages() as $message) {
echo message;
}
} else {
echo "Great, a new robot was saved successfully!";
}
```
```
### Constants
*integer***OP\_NONE**
*integer***OP\_CREATE**
*integer***OP\_UPDATE**
*integer***OP\_DELETE**
*integer***DIRTY\_STATE\_PERSISTENT**
*integer***DIRTY\_STATE\_TRANSIENT**
*integer***DIRTY\_STATE\_DETACHED**
### Methods
final public **\_\_construct** (\[*unknown* $dependencyInjector\], \[*unknown* $modelsManager\])
Phalcon\\Mvc\\Model constructor
public **setDI** (*unknown* $dependencyInjector)
Sets the dependency injection container
public **getDI** ()
Returns the dependency injection container
protected **setEventsManager** (*unknown* $eventsManager)
Sets a custom events manager
protected **getEventsManager** ()
Returns the custom events manager
public **getModelsMetaData** ()
Returns the models meta-data service related to the entity instance
public **getModelsManager** ()
Returns the models manager related to the entity instance
public **setTransaction** (*unknown* $transaction)
Sets a transaction related to the Model instance
```
<pre class="calibre14">```
<?php
use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
try {
$txManager = new TxManager();
$transaction = $txManager->get();
$robot = new Robots();
$robot->setTransaction($transaction);
$robot->name = 'WALL・E';
$robot->created_at = date('Y-m-d');
if ($robot->save() == false) {
$transaction->rollback("Can't save robot");
}
$robotPart = new RobotParts();
$robotPart->setTransaction($transaction);
$robotPart->type = 'head';
if ($robotPart->save() == false) {
$transaction->rollback("Robot part cannot be saved");
}
$transaction->commit();
} catch (TxFailed $e) {
echo 'Failed, reason: ', $e->getMessage();
}
```
```
protected **setSource** (*unknown* $source)
Sets table name which model should be mapped
public **getSource** ()
Returns table name mapped in the model
protected **setSchema** (*unknown* $schema)
Sets schema name where table mapped is located
public **getSchema** ()
Returns schema name where table mapped is located
public **setConnectionService** (*unknown* $connectionService)
Sets the DependencyInjection connection service name
public **setReadConnectionService** (*unknown* $connectionService)
Sets the DependencyInjection connection service name used to read data
public **setWriteConnectionService** (*unknown* $connectionService)
Sets the DependencyInjection connection service name used to write data
public **getReadConnectionService** ()
Returns the DependencyInjection connection service name used to read data related the model
public **getWriteConnectionService** ()
Returns the DependencyInjection connection service name used to write data related to the model
public **setDirtyState** (*unknown* $dirtyState)
Sets the dirty state of the object using one of the DIRTY\_STATE\_\* constants
public **getDirtyState** ()
Returns one of the DIRTY\_STATE\_\* constants telling if the record exists in the database or not
public **getReadConnection** ()
Gets the connection used to read data for the model
public **getWriteConnection** ()
Gets the connection used to write data to the model
public <a class="calibre6 pcalibre1" href="">*Phalcon\\Mvc\\Model*</a>**assign** (*array* $data, \[*unknown* $dataColumnMap\], \[*array* $whiteList\])
Assigns values to a model from an array
```
<pre class="calibre14">```
<?php
$robot->assign(array(
'type' => 'mechanical',
'name' => 'Astro Boy',
'year' => 1952
));
//assign by db row, column map needed
$robot->assign($dbRow, array(
'db_type' => 'type',
'db_name' => 'name',
'db_year' => 'year'
));
//allow assign only name and year
$robot->assign($_POST, null, array('name', 'year');
```
```
public static <a class="calibre6 pcalibre1" href="">*Phalcon\\Mvc\\Model*</a>**cloneResultMap** (*Phalcon\\Mvc\\ModelInterface|Phalcon\\Mvc\\Model\\Row* $base, *array* $data, *array* $columnMap, \[*int* $dirtyState\], \[*boolean* $keepSnapshots\])
Assigns values to a model from an array returning a new model.
```
<pre class="calibre14">```
<?php
$robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
'type' => 'mechanical',
'name' => 'Astro Boy',
'year' => 1952
));
```
```
public static *mixed***cloneResultMapHydrate** (*array* $data, *array* $columnMap, *int* $hydrationMode)
Returns an hydrated result based on the data and the column map
public static [*Phalcon\\Mvc\\ModelInterface*](#)**cloneResult** ([*Phalcon\\Mvc\\ModelInterface*](#) $base, *array* $data, \[*int* $dirtyState\])
Assigns values to a model from an array returning a new model
```
<pre class="calibre14">```
<?php
$robot = Phalcon\Mvc\Model::cloneResult(new Robots(), array(
'type' => 'mechanical',
'name' => 'Astro Boy',
'year' => 1952
));
```
```
public static [*Phalcon\\Mvc\\Model\\ResultsetInterface*](#)**find** (\[*array* $parameters\])
Allows to query a set of records that match the specified conditions
```
<pre class="calibre14">```
<?php
//How many robots are there?
$robots = Robots::find();
echo "There are ", count($robots), "\n";
//How many mechanical robots are there?
$robots = Robots::find("type='mechanical'");
echo "There are ", count($robots), "\n";
//Get and print virtual robots ordered by name
$robots = Robots::find(array("type='virtual'", "order" => "name"));
foreach ($robots as $robot) {
echo $robot->name, "\n";
}
//Get first 100 virtual robots ordered by name
$robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
foreach ($robots as $robot) {
echo $robot->name, "\n";
}
```
```
public static <a class="calibre6 pcalibre1" href="">*Phalcon\\Mvc\\Model*</a>**findFirst** (\[*string|array* $parameters\])
Allows to query the first record that match the specified conditions
```
<pre class="calibre14">```
<?php
//What's the first robot in robots table?
$robot = Robots::findFirst();
echo "The robot name is ", $robot->name;
//What's the first mechanical robot in robots table?
$robot = Robots::findFirst("type='mechanical'");
echo "The first mechanical robot name is ", $robot->name;
//Get first virtual robot ordered by name
$robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
echo "The first virtual robot name is ", $robot->name;
```
```
public static **query** (\[*unknown* $dependencyInjector\])
Create a criteria for a specific model
protected *boolean*\*\*\_exists\*\* (`Phalcon\Mvc\Model\MetadataInterface` $metaData, [*Phalcon\\Db\\AdapterInterface*](#) $connection, \[*string|array* $table\])
Checks if the current record already exists or not
protected static [*Phalcon\\Mvc\\Model\\ResultsetInterface*](#)**\_groupResult** (*unknown* $functionName, *string* $alias, *array* $parameters)
Generate a PHQL SELECT statement for an aggregate
public static *mixed***count** (\[*array* $parameters\])
Allows to count how many records match the specified conditions
```
<pre class="calibre14">```
<?php
//How many robots are there?
$number = Robots::count();
echo "There are ", $number, "\n";
//How many mechanical robots are there?
$number = Robots::count("type='mechanical'");
echo "There are ", $number, " mechanical robots\n";
```
```
public static *mixed***sum** (\[*array* $parameters\])
Allows to calculate a summatory on a column that match the specified conditions
```
<pre class="calibre14">```
<?php
//How much are all robots?
$sum = Robots::sum(array('column' => 'price'));
echo "The total price of robots is ", $sum, "\n";
//How much are mechanical robots?
$sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
echo "The total price of mechanical robots is ", $sum, "\n";
```
```
public static *mixed***maximum** (\[*array* $parameters\])
Allows to get the maximum value of a column that match the specified conditions
```
<pre class="calibre14">```
<?php
//What is the maximum robot id?
$id = Robots::maximum(array('column' => 'id'));
echo "The maximum robot id is: ", $id, "\n";
//What is the maximum id of mechanical robots?
$sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
echo "The maximum robot id of mechanical robots is ", $id, "\n";
```
```
public static *mixed***minimum** (\[*array* $parameters\])
Allows to get the minimum value of a column that match the specified conditions
```
<pre class="calibre14">```
<?php
//What is the minimum robot id?
$id = Robots::minimum(array('column' => 'id'));
echo "The minimum robot id is: ", $id;
//What is the minimum id of mechanical robots?
$sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
echo "The minimum robot id of mechanical robots is ", $id;
```
```
public static *double***average** (\[*array* $parameters\])
Allows to calculate the average value on a column matching the specified conditions
```
<pre class="calibre14">```
<?php
//What's the average price of robots?
$average = Robots::average(array('column' => 'price'));
echo "The average price is ", $average, "\n";
//What's the average price of mechanical robots?
$average = Robots::average(array("type='mechanical'", 'column' => 'price'));
echo "The average price of mechanical robots is ", $average, "\n";
```
```
public **fireEvent** (*unknown* $eventName)
Fires an event, implicitly calls behaviors and listeners in the events manager are notified
public **fireEventCancel** (*unknown* $eventName)
Fires an event, implicitly calls behaviors and listeners in the events manager are notified This method stops if one of the callbacks/listeners returns boolean false
protected **\_cancelOperation** ()
Cancel the current operation
public **appendMessage** (*unknown* $message)
Appends a customized message on the validation process
```
<pre class="calibre14">```
<?php
use \Phalcon\Mvc\Model\Message as Message;
class Robots extends \Phalcon\Mvc\Model
{
public function beforeSave()
{
if ($this->name == 'Peter') {
$message = new Message("Sorry, but a robot cannot be named Peter");
$this->appendMessage($message);
}
}
}
```
```
protected **validate** (*unknown* $validator)
Executes validators on every validation call
```
<pre class="calibre14">```
<?php
use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
class Subscriptors extends \Phalcon\Mvc\Model
{
public function validation()
{
$this->validate(new ExclusionIn(array(
'field' => 'status',
'domain' => array('A', 'I')
)));
if ($this->validationHasFailed() == true) {
return false;
}
}
}
```
```
public **validationHasFailed** ()
Check whether validation process has generated any messages
```
<pre class="calibre14">```
<?php
use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
class Subscriptors extends \Phalcon\Mvc\Model
{
public function validation()
{
$this->validate(new ExclusionIn(array(
'field' => 'status',
'domain' => array('A', 'I')
)));
if ($this->validationHasFailed() == true) {
return false;
}
}
}
```
```
public **getMessages** (\[*unknown* $filter\])
Returns all the validation messages
```
<pre class="calibre14">```
<?php
$robot = new Robots();
$robot->type = 'mechanical';
$robot->name = 'Astro Boy';
$robot->year = 1952;
if ($robot->save() == false) {
echo "Umh, We can't store robots right now ";
foreach ($robot->getMessages() as $message) {
echo $message;
}
} else {
echo "Great, a new robot was saved successfully!";
}
```
```
protected **\_checkForeignKeysRestrict** ()
Reads “belongs to” relations and check the virtual foreign keys when inserting or updating records to verify that inserted/updated values are present in the related entity
protected **\_checkForeignKeysReverseCascade** ()
Reads both “hasMany” and “hasOne” relations and checks the virtual foreign keys (cascade) when deleting records
protected **\_checkForeignKeysReverseRestrict** ()
Reads both “hasMany” and “hasOne” relations and checks the virtual foreign keys (restrict) when deleting records
protected **\_preSave** (*unknown* $metaData, *unknown* $exists, *unknown* $identityField)
Executes internal hooks before save a record
protected **\_postSave** (*unknown* $success, *unknown* $exists)
Executes internal events after save a record
protected *boolean*\*\*\_doLowInsert\*\* (`Phalcon\Mvc\Model\MetadataInterface` $metaData, [*Phalcon\\Db\\AdapterInterface*](#) $connection, *string|array* $table, *boolean|string* $identityField)
Sends a pre-build INSERT SQL statement to the relational database system
protected *boolean*\*\*\_doLowUpdate\*\* ([*Phalcon\\Mvc\\Model\\MetaDataInterface*](#) $metaData, [*Phalcon\\Db\\AdapterInterface*](#) $connection, *string|array* $table)
Sends a pre-build UPDATE SQL statement to the relational database system
protected *boolean*\*\*\_preSaveRelatedRecords\*\* ([*Phalcon\\Db\\AdapterInterface*](#) $connection, *Phalcon\\Mvc\\ModelInterface\[\]* $related)
Saves related records that must be stored prior to save the master record
protected *boolean*\*\*\_postSaveRelatedRecords\*\* ([*Phalcon\\Db\\AdapterInterface*](#) $connection, *Phalcon\\Mvc\\ModelInterface\[\]* $related)
Save the related records assigned in the has-one/has-many relations
public *boolean***save** (\[*array* $data\], \[*array* $whiteList\])
Inserts or updates a model instance. Returning true on success or false otherwise.
```
<pre class="calibre14">```
<?php
//Creating a new robot
$robot = new Robots();
$robot->type = 'mechanical';
$robot->name = 'Astro Boy';
$robot->year = 1952;
$robot->save();
//Updating a robot name
$robot = Robots::findFirst("id=100");
$robot->name = "Biomass";
$robot->save();
```
```
public **create** (\[*unknown* $data\], \[*unknown* $whiteList\])
Inserts a model instance. If the instance already exists in the persistance it will throw an exception Returning true on success or false otherwise.
```
<pre class="calibre14">```
<?php
//Creating a new robot
$robot = new Robots();
$robot->type = 'mechanical';
$robot->name = 'Astro Boy';
$robot->year = 1952;
$robot->create();
//Passing an array to create
$robot = new Robots();
$robot->create(array(
'type' => 'mechanical',
'name' => 'Astroy Boy',
'year' => 1952
));
```
```
public **update** (\[*unknown* $data\], \[*unknown* $whiteList\])
Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception Returning true on success or false otherwise.
```
<pre class="calibre14">```
<?php
//Updating a robot name
$robot = Robots::findFirst("id=100");
$robot->name = "Biomass";
$robot->update();
```
```
public **delete** ()
Deletes a model instance. Returning true on success or false otherwise.
```
<pre class="calibre14">```
<?php
$robot = Robots::findFirst("id=100");
$robot->delete();
foreach (Robots::find("type = 'mechanical'") as $robot) {
$robot->delete();
}
```
```
public **getOperationMade** ()
Returns the type of the latest operation performed by the ORM Returns one of the OP\_\* class constants
public **refresh** ()
Refreshes the model attributes re-querying the record from the database
public **skipOperation** (*unknown* $skip)
Skips the current operation forcing a success state
public **readAttribute** (*unknown* $attribute)
Reads an attribute value by its name
```
<pre class="calibre14">```
<?php
echo $robot->readAttribute('name');
```
```
public **writeAttribute** (*unknown* $attribute, *unknown* $value)
Writes an attribute value by its name
```
<pre class="calibre14">```
<?php
$robot->writeAttribute('name', 'Rosey');
```
```
protected **skipAttributes** (*unknown* $attributes)
Sets a list of attributes that must be skipped from the generated INSERT/UPDATE statement
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributes(array('price'));
}
}
```
```
protected **skipAttributesOnCreate** (*unknown* $attributes)
Sets a list of attributes that must be skipped from the generated INSERT statement
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnCreate(array('created_at'));
}
}
```
```
protected **skipAttributesOnUpdate** (*unknown* $attributes)
Sets a list of attributes that must be skipped from the generated UPDATE statement
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnUpdate(array('modified_in'));
}
}
```
```
protected **allowEmptyStringValues** (*unknown* $attributes)
Sets a list of attributes that must be skipped from the generated UPDATE statement
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->allowEmptyStringValues(array('name'));
}
}
```
```
protected **hasOne** (*unknown* $fields, *unknown* $referenceModel, *unknown* $referencedFields, \[*unknown* $options\])
Setup a 1-1 relation between two models
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasOne('id', 'RobotsDescription', 'robots_id');
}
}
```
```
protected **belongsTo** (*unknown* $fields, *unknown* $referenceModel, *unknown* $referencedFields, \[*unknown* $options\])
Setup a relation reverse 1-1 between two models
```
<pre class="calibre14">```
<?php
<?php
class RobotsParts extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->belongsTo('robots_id', 'Robots', 'id');
}
}
```
```
protected **hasMany** (*unknown* $fields, *unknown* $referenceModel, *unknown* $referencedFields, \[*unknown* $options\])
Setup a relation 1-n between two models
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasMany('id', 'RobotsParts', 'robots_id');
}
}
```
```
protected [*Phalcon\\Mvc\\Model\\Relation*](#)**hasManyToMany** (*string|array* $fields, *string* $intermediateModel, *string|array* $intermediateFields, *string|array* $intermediateReferencedFields, *unknown* $referenceModel, *string|array* $referencedFields, \[*array* $options\])
Setup a relation n-n between two models through an intermediate relation
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
//Setup a many-to-many relation to Parts through RobotsParts
$this->hasManyToMany(
'id',
'RobotsParts',
'robots_id',
'parts_id',
'Parts',
'id'
);
}
}
```
```
public **addBehavior** (*unknown* $behavior)
Setups a behavior in a model
```
<pre class="calibre14">```
<?php
<?php
use Phalcon\Mvc\Model\Behavior\Timestampable;
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->addBehavior(new Timestampable(array(
'onCreate' => array(
'field' => 'created_at',
'format' => 'Y-m-d'
)
)));
}
}
```
```
protected **keepSnapshots** (*unknown* $keepSnapshot)
Sets if the model must keep the original record snapshot in memory
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->keepSnapshots(true);
}
}
```
```
public **setSnapshotData** (*array* $data, \[*array* $columnMap\])
Sets the record's snapshot data. This method is used internally to set snapshot data when the model was set up to keep snapshot data
public **hasSnapshotData** ()
Checks if the object has internal snapshot data
public **getSnapshotData** ()
Returns the internal snapshot data
public **hasChanged** (\[*string|array* $fieldName\])
Check if a specific attribute has changed This only works if the model is keeping data snapshots
public **getChangedFields** ()
Returns a list of changed values
protected **useDynamicUpdate** (*unknown* $dynamicUpdate)
Sets if a model must use dynamic update instead of the all-field update
```
<pre class="calibre14">```
<?php
<?php
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->useDynamicUpdate(true);
}
}
```
```
public [*Phalcon\\Mvc\\Model\\ResultsetInterface*](#)**getRelated** (*string* $alias, \[*array* $arguments\])
Returns related records based on defined relations
protected *mixed*\*\*\_getRelatedRecords\*\* (*string* $modelName, *string* $method, *array* $arguments)
Returns related records defined relations depending on the method name
public *mixed*\*\*\_\_call\*\* (*string* $method, *array* $arguments)
Handles method calls when a method is not implemented
public static *mixed*\*\*\_\_callStatic\*\* (*string* $method, \[*array* $arguments\])
Handles method calls when a static method is not implemented
public **\_\_set** (*string* $property, *mixed* $value)
Magic method to assign values to the the model
public [*Phalcon\\Mvc\\Model\\Resultset*](#)[|](#)PhalconMvcModel **\_\_get** (*string* $property)
Magic method to get related records using the relation alias as a property
public **\_\_isset** (*unknown* $property)
Magic method to check if a property is a valid relation
public **serialize** ()
Serializes the object ignoring connections, services, related objects or static properties
public **unserialize** (*unknown* $data)
Unserializes the object from a serialized string
public **dump** ()
Returns a simple representation of the object that can be used with var\_dump
```
<pre class="calibre14">```
<?php
var_dump($robot->dump());
```
```
public *array***toArray** (\[*array* $columns\])
Returns the instance as an array representation
```
<pre class="calibre14">```
<?php
print_r($robot->toArray());
```
```
public static **setup** (*unknown* $options)
Enables/disables options in the ORM
public **reset** ()
Reset a model instance data
|
- [索引](# "总目录")
- [下一页](# "Abstract class Phalcon\Mvc\Model\Behavior") |
- [上一页](# "Class Phalcon\Mvc\Micro\LazyLoader") |
- [API Indice](#) »
- API参考
- API列表
- Abstract class Phalcon\Acl
- Abstract class Phalcon\Acl\Adapter
- Class Phalcon\Acl\Adapter\Memory
- Interface Phalcon\Acl\AdapterInterface
- Class Phalcon\Acl\Exception
- Class Phalcon\Acl\Resource
- Interface Phalcon\Acl\ResourceInterface
- Class Phalcon\Acl\Role
- Interface Phalcon\Acl\RoleInterface
- Class Phalcon\Annotations\Annotation
- Abstract class Phalcon\Annotations\Adapter
- Interface Phalcon\Annotations\AdapterInterface
- Class Phalcon\Annotations\Collection
- Class Phalcon\Annotations\Exception
- Class Phalcon\Annotations\Reader
- Interface Phalcon\Annotations\ReaderInterface
- Class Phalcon\Annotations\Reflection
- Class Phalcon\Assets\Collection
- Class Phalcon\Assets\Exception
- Interface Phalcon\Assets\FilterInterface
- Class Phalcon\Assets\Filters\Cssmin
- Class Phalcon\Assets\Filters\Jsmin
- Class Phalcon\Assets\Filters\None
- Class Phalcon\Assets\Inline
- Class Phalcon\Assets\Inline\Css
- Class Phalcon\Assets\Inline\Js
- Class Phalcon\Assets\Manager
- Class Phalcon\Assets\Resource
- Class Phalcon\Assets\Resource\Css
- Class Phalcon\Assets\Resource\Js
- Abstract class Phalcon\Cache\Backend
- Class Phalcon\Cache\Backend\Apc
- Class Phalcon\Cache\Backend\File
- Class Phalcon\Cache\Backend\Libmemcached
- Class Phalcon\Cache\Backend\Memcache
- Class Phalcon\Cache\Backend\Memory
- Class Phalcon\Cache\Backend\Mongo
- Class Phalcon\Cache\Backend\Redis
- Class Phalcon\Cache\Backend\Xcache
- Interface Phalcon\Cache\BackendInterface
- Class Phalcon\Cache\Exception
- Class Phalcon\Cache\Frontend\Base64
- Class Phalcon\Cache\Frontend\Data
- Class Phalcon\Cache\Frontend\Igbinary
- Class Phalcon\Cache\Frontend\Json
- Class Phalcon\Cache\Frontend\None
- Class Phalcon\Cache\Frontend\Output
- Interface Phalcon\Cache\FrontendInterface
- Class Phalcon\Cache\Multiple
- Class Phalcon\Cli\Router\Route
- Class Phalcon\Config
- Class Phalcon\Config\Adapter\Ini
- Class Phalcon\Config\Adapter\Json
- Class Phalcon\Config\Adapter\Php
- Class Phalcon\Config\Adapter\Yaml
- Class Phalcon\Config\Exception
- Class Phalcon\Crypt
- Class Phalcon\Crypt\Exception
- Interface Phalcon\CryptInterface
- Abstract class Phalcon\Db
- Abstract class Phalcon\Db\Adapter
- Interface Phalcon\Db\AdapterInterface
- Class Phalcon\Db\Column
- Interface Phalcon\Db\ColumnInterface
- Abstract class Phalcon\Db\Dialect
- Interface Phalcon\Db\DialectInterface
- Class Phalcon\Db\Exception
- Class Phalcon\Db\Index
- Interface Phalcon\Db\IndexInterface
- Class Phalcon\Db\Profiler
- Class Phalcon\Db\RawValue
- Class Phalcon\Db\Reference
- Interface Phalcon\Db\ReferenceInterface
- Class Phalcon\Db\Result\Pdo
- Interface Phalcon\Db\ResultInterface
- Class Phalcon\Debug
- Class Phalcon\Debug\Dump
- Class Phalcon\Debug\Exception
- Interface Phalcon\DiInterface
- Abstract class Phalcon\Dispatcher
- Interface Phalcon\DispatcherInterface
- Class Phalcon\Escaper
- Class Phalcon\Escaper\Exception
- Interface Phalcon\EscaperInterface
- Class Phalcon\Events\Event
- Interface Phalcon\Events\EventsAwareInterface
- Class Phalcon\Events\Exception
- Class Phalcon\Events\Manager
- Interface Phalcon\Events\ManagerInterface
- Class Phalcon\Exception
- Class Phalcon\Filter
- Class Phalcon\Filter\Exception
- Interface Phalcon\Filter\UserFilterInterface
- Interface Phalcon\FilterInterface
- Abstract class Phalcon\Flash
- Class Phalcon\Flash\Direct
- Class Phalcon\Flash\Exception
- Class Phalcon\Flash\Session
- Interface Phalcon\FlashInterface
- Class Phalcon\Forms\Form
- Abstract class Phalcon\Forms\Element
- Class Phalcon\Forms\Exception
- Class Phalcon\Forms\Manager
- Class Phalcon\Http\Cookie
- Class Phalcon\Http\Cookie\Exception
- Class Phalcon\Http\Request
- Class Phalcon\Http\Request\Exception
- Class Phalcon\Http\Request\File
- Interface Phalcon\Http\Request\FileInterface
- Interface Phalcon\Http\RequestInterface
- Class Phalcon\Http\Response
- Class Phalcon\Http\Response\Cookies
- Interface Phalcon\Http\Response\CookiesInterface
- Class Phalcon\Http\Response\Exception
- Class Phalcon\Http\Response\Headers
- Interface Phalcon\Http\Response\HeadersInterface
- Interface Phalcon\Http\ResponseInterface
- Class Phalcon\Image
- Abstract class Phalcon\Image\Adapter
- Class Phalcon\Image\Adapter\Imagick
- Interface Phalcon\Image\AdapterInterface
- Class Phalcon\Image\Exception
- Class Phalcon\Kernel
- Class Phalcon\Loader
- Class Phalcon\Loader\Exception
- Abstract class Phalcon\Logger
- Abstract class Phalcon\Logger\Adapter
- Class Phalcon\Logger\Adapter\File
- Class Phalcon\Logger\Adapter\Firephp
- Class Phalcon\Logger\Adapter\Stream
- Class Phalcon\Logger\Adapter\Syslog
- Interface Phalcon\Logger\AdapterInterface
- Class Phalcon\Logger\Exception
- Abstract class Phalcon\Logger\Formatter
- Interface Phalcon\Logger\FormatterInterface
- Class Phalcon\Logger\Item
- Class Phalcon\Logger\Multiple
- Class Phalcon\Mvc\Application
- Class Phalcon\Mvc\Application\Exception
- Abstract class Phalcon\Mvc\Collection
- Abstract class Phalcon\Mvc\Collection\Behavior
- Class Phalcon\Mvc\Collection\Behavior\SoftDelete
- Class Phalcon\Mvc\Collection\Behavior\Timestampable
- Interface Phalcon\Mvc\Collection\BehaviorInterface
- Class Phalcon\Mvc\Collection\Document
- Class Phalcon\Mvc\Collection\Exception
- Class Phalcon\Mvc\Collection\Manager
- Interface Phalcon\Mvc\Collection\ManagerInterface
- Interface Phalcon\Mvc\CollectionInterface
- Abstract class Phalcon\Mvc\Controller
- Interface Phalcon\Mvc\ControllerInterface
- Class Phalcon\Mvc\Dispatcher
- Class Phalcon\Mvc\Dispatcher\Exception
- Interface Phalcon\Mvc\DispatcherInterface
- Interface Phalcon\Mvc\EntityInterface
- Class Phalcon\Mvc\Micro
- Class Phalcon\Mvc\Micro\Collection
- Interface Phalcon\Mvc\Micro\CollectionInterface
- Class Phalcon\Mvc\Micro\Exception
- Class Phalcon\Mvc\Micro\LazyLoader
- Interface Phalcon\Mvc\Micro\MiddlewareInterface
- Abstract class Phalcon\Mvc\Model
- Abstract class Phalcon\Mvc\Model\Behavior
- Class Phalcon\Mvc\Model\Criteria
- Interface Phalcon\Mvc\Model\CriteriaInterface
- Class Phalcon\Mvc\Model\Exception
- Class Phalcon\Mvc\Model\Manager
- Interface Phalcon\Mvc\Model\ManagerInterface
- Class Phalcon\Mvc\Model\Message
- Interface Phalcon\Mvc\Model\MessageInterface
- Abstract class Phalcon\Mvc\Model\MetaData
- Interface Phalcon\Mvc\Model\MetaDataInterface
- Class Phalcon\Mvc\Model\Query
- Interface Phalcon\Mvc\Model\QueryInterface
- Class Phalcon\Mvc\Model\Relation
- Interface Phalcon\Mvc\Model\RelationInterface
- Interface Phalcon\Mvc\Model\ResultInterface
- Abstract class Phalcon\Mvc\Model\Resultset
- Abstract class Phalcon\Mvc\Model\Validator
- Interface Phalcon\Mvc\Model\ResultsetInterface
- Class Phalcon\Mvc\Model\Row
- Class Phalcon\Mvc\Model\Transaction
- Interface Phalcon\Mvc\Model\TransactionInterface
- Class Phalcon\Mvc\Model\ValidationFailed
- Interface Phalcon\Mvc\ModelInterface
- Interface Phalcon\Mvc\ModuleDefinitionInterface
- Class Phalcon\Mvc\Router
- Class Phalcon\Mvc\Router\Annotations
- Class Phalcon\Mvc\Router\Exception
- Class Phalcon\Mvc\Router\Group
- Interface Phalcon\Mvc\Router\GroupInterface
- Class Phalcon\Mvc\Router\Route
- Interface Phalcon\Mvc\Router\RouteInterface
- Interface Phalcon\Mvc\RouterInterface
- Class Phalcon\Mvc\Url
- Class Phalcon\Mvc\Url\Exception
- Interface Phalcon\Mvc\UrlInterface
- Class Phalcon\Mvc\User\Component
- Class Phalcon\Mvc\User\Module
- Class Phalcon\Mvc\User\Plugin
- Class Phalcon\Mvc\View
- Abstract class Phalcon\Mvc\View\Engine
- Interface Phalcon\Mvc\View\EngineInterface
- Class Phalcon\Mvc\View\Exception
- Class Phalcon\Mvc\View\Simple
- Interface Phalcon\Mvc\ViewBaseInterface
- Interface Phalcon\Mvc\ViewInterface
- Abstract class Phalcon\Paginator\Adapter
- Class Phalcon\Paginator\Adapter\Model
- Class Phalcon\Paginator\Adapter\NativeArray
- Class Phalcon\Paginator\Adapter\QueryBuilder
- Interface Phalcon\Paginator\AdapterInterface
- Class Phalcon\Paginator\Exception
- Class Phalcon\Queue\Beanstalk
- Class Phalcon\Queue\Beanstalk\Job
- Final class Phalcon\Registry
- Class Phalcon\Security
- Class Phalcon\Security\Exception
- Abstract class Phalcon\Session
- Abstract class Phalcon\Session\Adapter
- Interface Phalcon\Session\AdapterInterface
- Class Phalcon\Session\Bag
- Interface Phalcon\Session\BagInterface
- Class Phalcon\Session\Exception
- Class Phalcon\Tag
- Class Phalcon\Tag\Exception
- Abstract class Phalcon\Tag\Select
- Abstract class Phalcon\Text
- Abstract class Phalcon\Translate
- Abstract class Phalcon\Translate\Adapter
- Class Phalcon\Translate\Adapter\Csv
- Class Phalcon\Translate\Adapter\Gettext
- Class Phalcon\Translate\Adapter\NativeArray
- Interface Phalcon\Translate\AdapterInterface
- Class Phalcon\Translate\Exception
- Class Phalcon\Validation
- Class Phalcon\Validation\Exception
- Class Phalcon\Validation\Message
- Class Phalcon\Validation\Message\Group
- Interface Phalcon\Validation\MessageInterface
- Abstract class Phalcon\Validation\Validator
- Class Phalcon\Validation\Validator\Alnum
- Class Phalcon\Validation\Validator\Alpha
- Class Phalcon\Validation\Validator\Between
- Class Phalcon\Validation\Validator\Confirmation
- Class Phalcon\Validation\Validator\Digit
- Class Phalcon\Validation\Validator\Email
- Class Phalcon\Validation\Validator\ExclusionIn
- Class Phalcon\Validation\Validator\File
- Class Phalcon\Validation\Validator\Identical
- Class Phalcon\Validation\Validator\InclusionIn
- Class Phalcon\Validation\Validator\Numericality
- Class Phalcon\Validation\Validator\PresenceOf
- Class Phalcon\Validation\Validator\Regex
- Class Phalcon\Validation\Validator\StringLength
- Class Phalcon\Validation\Validator\Uniqueness
- Class Phalcon\Validation\Validator\Url
- Interface Phalcon\Validation\ValidatorInterface
- Class Phalcon\Version
- 参考手册
- 安装（Installation）
- 教程 1：让我们通过例子来学习（Tutorial 1: Let’s learn by example）
- 教程 2：Introducing INVO（Tutorial 2: Introducing INVO）
- 教程 3: Securing INVO
- 教程 4: Using CRUDs
- 教程 5: Customizing INVO
- 教程 6: Vkuró
- 教程 7：创建简单的 REST API（Tutorial 7: Creating a Simple REST API）
- 示例列表（List of examples）
- 依赖注入与服务定位器（Dependency Injection/Service Location）
- MVC 架构（The MVC Architecture）
- 使用控制器（Using Controllers）
- 使用模型（Working with Models）
- 模型元数据（Models Meta-Data）
- 事务管理（Model Transactions）
- Phalcon 查询语言（Phalcon Query Language (PHQL)）
- 缓存对象关系映射（Caching in the ORM）
- 对象文档映射 ODM (Object-Document Mapper)
- 使用视图（Using Views）
- 视图助手（View Helpers）
- 资源文件管理（Assets Management）
- Volt 模版引擎（Volt: Template Engine）
- MVC 应用（MVC Applications）
- 路由（Routing）
- 调度控制器（Dispatching Controllers）
- 微应用（Micro Applications）
- 使用命名空间（Working with Namespaces）
- 事件管理器（Events Manager）
- Request Environment
- 返回响应（Returning Responses）
- Cookie 管理（Cookies Management）
- 生成 URL 和 路径（Generating URLs and Paths）
- 闪存消息（Flashing Messages）
- 使用 Session 存储数据（Storing data in Session）
- 过滤与清理（Filtering and Sanitizing）
- 上下文编码（Contextual Escaping）
- 验证（Validation）
- 表单（Forms）
- 读取配置（Reading Configurations）
- 分页（Pagination）
- 使用缓存提高性能（Improving Performance with Cache）
- 安全（Security）
- Encryption/Decryption
- 访问控制列表 ACL（Access Control Lists ACL）
- 多语言支持（Multi-lingual Support）
- Universal Class Loader
- 日志记录（Logging）
- 注释解析器（Annotations Parser）
- 命令行应用（Command Line Applications）
- 队列（Queueing）
- 数据库抽象层（Database Abstraction Layer）
- 国际化（Internationalization）
- 数据库迁移（Database Migrations）
- 调试应用程序（Debugging Applications）
- Phalcon 开发工具（Phalcon Developer Tools）
- 提高性能：下一步该做什么？（Increasing Performance: What’s next?）
- 单元测试（Unit testing）
- 授权（License）