| Namespace | Phalcon\Mvc | Uses | Closure, Phalcon\Application\AbstractApplication, Phalcon\Di\DiInterface, Phalcon\Http\ResponseInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\Application\Exception, Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\ModuleDefinitionInterface | Extends | AbstractApplication |
Phalcon\Mvc\Application
This component encapsulates all the complex operations behind instantiating every component needed and integrating it with the rest to allow the MVC pattern to operate as desired.
Czech
German
English (US)
Spanish
Persian
French
Indonesian
Italian
Japanese
Korean
Polish
Portuguese, Brazilian
Russian
Turkish
Ukrainian
Chinese Simplifieduse Phalcon\Mvc\Application;
class MyApp extends Application
{
Register the services here to make them general or register
in the ModuleDefinition to make them module-specific
\/
protected function registerServices()
{
}
This method registers all the modules in the application
\/
public function main()
{
$this->registerModules(
[
"frontend" => [
"className" => "Multiple\\Frontend\\Module",
"path" => "../apps/frontend/Module.php",
],
"backend" => [
"className" => "Multiple\\Backend\\Module",
"path" => "../apps/backend/Module.php",
],
]
);
}
}
$application = new MyApp();
$application->main();
/**
* @var bool
*/
protected implicitView = true;
/**
* @var bool
*/
protected sendCookies = true;
/**
* @var bool
*/
protected sendHeaders = true;
public function handle( string $uri ): ResponseInterface | bool;
Handles a MVC request
public function sendCookiesOnHandleRequest( bool $sendCookies ): Application;
Enables or disables sending cookies by each request handling
public function sendHeadersOnHandleRequest( bool $sendHeaders ): Application;
Enables or disables sending headers by each request handling
public function useImplicitView( bool $implicitView ): Application;
By default. The view is implicitly buffering all the output You can full disable the view component using this method
| Namespace | Phalcon\Mvc\Application | Extends | \Phalcon\Application\Exception |
Phalcon\Mvc\Application\Exception
Exceptions thrown in Phalcon\Mvc\Application class will use this class
| Namespace | Phalcon\Mvc | Uses | Phalcon\Di\Injectable | Extends | Injectable | Implements | ControllerInterface |
Phalcon\Mvc\Controller
Every application controller should extend this class that encapsulates all the controller functionality
The controllers provide the “flow” between models and views. Controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation.
<?php
class PeopleController extends \Phalcon\Mvc\Controller
{
// This action will be executed by default
public function indexAction()
{
}
public function findAction()
{
}
public function saveAction()
{
// Forwards flow to the index action
return $this->dispatcher->forward(
[
"controller" => "people",
"action" => "index",
]
);
}
}
final public function __construct();
Phalcon\Mvc\Controller constructor
| Namespace | Phalcon\Mvc\Controller |
Phalcon\Mvc\Controller\BindModelInterface
Interface for Phalcon\Mvc\Controller
public static function getModelName(): string;
Return the model name associated with this controller
| Namespace | Phalcon\Mvc |
Phalcon\Mvc\ControllerInterface
Interface for controller handlers
| Namespace | Phalcon\Mvc | Uses | Phalcon\Mvc\Dispatcher\Exception, Phalcon\Events\ManagerInterface, Phalcon\Http\ResponseInterface, Phalcon\Dispatcher\AbstractDispatcher | Extends | BaseDispatcher | Implements | DispatcherInterface |
Dispatching is the process of taking the request object, extracting the module name, controller name, action name, and optional parameters contained in it, and then instantiating a controller and calling an action of that controller.
$di = new \Phalcon\Di\Di();
$dispatcher = new \Phalcon\Mvc\Dispatcher();
$dispatcher->setDI($di);
$dispatcher->setControllerName("posts");
$dispatcher->setActionName("index");
$dispatcher->setParams([]);
$controller = $dispatcher->dispatch();
//
protected defaultAction = index;
//
protected defaultHandler = index;
//
protected handlerSuffix = Controller;
public function forward( array $forward ): void;
Forwards the execution flow to another controller/action.
use Phalcon\Events\Event;
use Phalcon\Mvc\Dispatcher;
use App\Backend\Bootstrap as Backend;
use App\Frontend\Bootstrap as Frontend;
// Registering modules
$modules = [
"frontend" => [
"className" => Frontend::class,
"path" => __DIR__ . "/app/Modules/Frontend/Bootstrap.php",
"metadata" => [
"controllersNamespace" => "App\Frontend\Controllers",
],
],
"backend" => [
"className" => Backend::class,
"path" => __DIR__ . "/app/Modules/Backend/Bootstrap.php",
"metadata" => [
"controllersNamespace" => "App\Backend\Controllers",
],
],
];
$application->registerModules($modules);
// Setting beforeForward listener
$eventsManager = $di->getShared("eventsManager");
$eventsManager->attach(
"dispatch:beforeForward",
function(Event $event, Dispatcher $dispatcher, array $forward) use ($modules) {
$metadata = $modules[$forward["module"]]["metadata"];
$dispatcher->setModuleName(
$forward["module"]
);
$dispatcher->setNamespaceName(
$metadata["controllersNamespace"]
);
}
);
// Forward
$this->dispatcher->forward(
[
"module" => "backend",
"controller" => "posts",
"action" => "index",
]
);
public function getActiveController(): ControllerInterface;
Returns the active controller in the dispatcher
public function getControllerClass(): string;
Possible controller class name that will be located to dispatch the request
public function getControllerName(): string;
Gets last dispatched controller name
public function getLastController(): ControllerInterface;
Returns the latest dispatched controller
public function getPreviousActionName(): string;
Gets previous dispatched action name
public function getPreviousControllerName(): string;
Gets previous dispatched controller name
public function getPreviousNamespaceName(): string;
Gets previous dispatched namespace name
public function setControllerName( string $controllerName );
Sets the controller name to be dispatched
public function setControllerSuffix( string $controllerSuffix );
Sets the default controller suffix
public function setDefaultController( string $controllerName );
Sets the default controller name
protected function handleException( \Exception $exception );
Handles a user exception
protected function throwDispatchException( string $message, int $exceptionCode = int );
Throws an internal exception
| Namespace | Phalcon\Mvc\Dispatcher | Extends | \Phalcon\Dispatcher\Exception |
Phalcon\Mvc\Dispatcher\Exception
Exceptions thrown in Phalcon\Mvc\Dispatcher will use this class
| Namespace | Phalcon\Mvc | Uses | Phalcon\Dispatcher\DispatcherInterface | Extends | DispatcherInterfaceBase |
Phalcon\Mvc\DispatcherInterface
Interface for Phalcon\Mvc\Dispatcher
public function getActiveController(): ControllerInterface;
Returns the active controller in the dispatcher
public function getControllerName(): string;
Gets last dispatched controller name
public function getLastController(): ControllerInterface;
Returns the latest dispatched controller
public function setControllerName( string $controllerName );
Sets the controller name to be dispatched
public function setControllerSuffix( string $controllerSuffix );
Sets the default controller suffix
public function setDefaultController( string $controllerName );
Sets the default controller name
| Namespace | Phalcon\Mvc |
Phalcon\Mvc\EntityInterface
Interface for Phalcon\Mvc\Collection and Phalcon\Mvc\Model
public function readAttribute( string $attribute ): mixed | null;
Reads an attribute value by its name
public function writeAttribute( string $attribute, mixed $value );
Writes an attribute value by its name
| Namespace | Phalcon\Mvc | Uses | ArrayAccess, Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Di\FactoryDefault, Phalcon\Mvc\Micro\Exception, Phalcon\Di\ServiceInterface, Phalcon\Mvc\Micro\Collection, Phalcon\Mvc\Micro\LazyLoader, Phalcon\Http\ResponseInterface, Phalcon\Mvc\Model\BinderInterface, Phalcon\Mvc\Router\RouteInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\Micro\MiddlewareInterface, Phalcon\Mvc\Micro\CollectionInterface, Throwable | Extends | Injectable | Implements | ArrayAccess, EventsAwareInterface |
Phalcon\Mvc\Micro
With Phalcon you can create “Micro-Framework like” applications. By doing this, you only need to write a minimal amount of code to create a PHP application. Micro applications are suitable to small applications, APIs and prototypes in a practical way.
$app = new \Phalcon\Mvc\Micro();
$app->get(
"/say/welcome/{name}",
function ($name) {
echo "<h1>Welcome $name!</h1>";
}
);
$app->handle("/say/welcome/Phalcon");
/**
* @var callable|null
*/
protected activeHandler;
/**
* @var array
*/
protected afterBindingHandlers;
/**
* @var array
*/
protected afterHandlers;
/**
* @var array
*/
protected beforeHandlers;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var callable|null
*/
protected errorHandler;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected finishHandlers;
/**
* @var array
*/
protected handlers;
/**
* @var BinderInterface|null
*/
protected modelBinder;
/**
* @var callable|null
*/
protected notFoundHandler;
/**
* @var callable|null
*/
protected responseHandler;
/**
* @var mixed|null
*/
protected returnedValue;
/**
* @var RouterInterface|null
*/
protected router;
/**
* @var bool
*/
protected stopped = false;
public function __construct( DiInterface $container = null );
Phalcon\Mvc\Micro constructor
public function after( mixed $handler ): Micro;
Appends an ‘after’ middleware to be called after execute the route
public function afterBinding( mixed $handler ): Micro;
Appends a afterBinding middleware to be called after model binding
public function before( mixed $handler ): Micro;
Appends a before middleware to be called before execute the route
public function delete( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is DELETE
public function error( mixed $handler ): Micro;
Sets a handler that will be called when an exception is thrown handling the route
public function finish( mixed $handler ): Micro;
Appends a ‘finish’ middleware to be called when the request is finished
public function get( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is GET
public function getActiveHandler();
Return the handler that will be called for the matched route
public function getBoundModels(): array;
Returns bound models from binder instance
public function getEventsManager(): ManagerInterface | null;
Returns the internal event manager
public function getHandlers(): array;
Returns the internal handlers attached to the application
public function getModelBinder(): BinderInterface | null;
Gets model binder
public function getReturnedValue();
Returns the value returned by the executed handler
public function getRouter(): RouterInterface;
Returns the internal router used by the application
public function getService( string $serviceName );
Obtains a service from the DI
public function getSharedService( string $serviceName );
Obtains a shared service from the DI
public function handle( string $uri );
Handle the whole request
public function hasService( string $serviceName ): bool;
Checks if a service is registered in the DI
public function head( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is HEAD
public function map( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler without any HTTP method constraint
public function mount( CollectionInterface $collection ): Micro;
Mounts a collection of handlers
public function notFound( mixed $handler ): Micro;
Sets a handler that will be called when the router doesn’t match any of the defined routes
public function offsetExists( mixed $offset ): bool;
Check if a service is registered in the internal services container using the array syntax
public function offsetGet( mixed $offset ): mixed;
Allows to obtain a shared service in the internal services container using the array syntax
var_dump(
$app["request"]
);
public function offsetSet( mixed $offset, mixed $value ): void;
Allows to register a shared service in the internal services container using the array syntax
$app["request"] = new \Phalcon\Http\Request();
public function offsetUnset( mixed $offset ): void;
Removes a service from the internal services container using the array syntax
public function options( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is OPTIONS
public function patch( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is PATCH
public function post( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is POST
public function put( string $routePattern, mixed $handler ): RouteInterface;
Maps a route to a handler that only matches if the HTTP method is PUT
public function setActiveHandler( mixed $activeHandler );
Sets externally the handler that must be called by the matched route
public function setDI( DiInterface $container ): void;
Sets the DependencyInjector container
public function setEventsManager( ManagerInterface $eventsManager ): void;
Sets the events manager
public function setModelBinder( BinderInterface $modelBinder, mixed $cache = null ): Micro;
Sets model binder
$micro = new Micro($di);
$micro->setModelBinder(
new Binder(),
'cache'
);
public function setResponseHandler( mixed $handler ): Micro;
Appends a custom ‘response’ handler to be called instead of the default response handler
public function setService( string $serviceName, mixed $definition, bool $shared = bool ): ServiceInterface;
Sets a service from the DI
public function stop(): void;
Stops the middleware execution avoiding than other middlewares be executed
| Namespace | Phalcon\Mvc\Micro | Implements | CollectionInterface |
Phalcon\Mvc\Micro\Collection
Groups Micro-Mvc handlers as controllers
$app = new \Phalcon\Mvc\Micro();
$collection = new Collection();
$collection->setHandler(
new PostsController()
);
$collection->get("/posts/edit/{id}", "edit");
$app->mount($collection);
/**
* @var callable
*/
protected handler;
/**
* @var array
*/
protected handlers;
/**
* @var bool
*/
protected lazy = false;
/**
* @var string
*/
protected prefix = ;
public function delete( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is DELETE.
public function get( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is GET.
public function getHandler(): mixed;
Returns the main handler
public function getHandlers(): array;
Returns the registered handlers
public function getPrefix(): string;
Returns the collection prefix if any
public function head( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is HEAD.
public function isLazy(): bool;
Returns if the main handler must be lazy loaded
public function map( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler.
public function mapVia( string $routePattern, callable $handler, mixed $method, string $name = null ): CollectionInterface;
Maps a route to a handler via methods.
$collection->mapVia(
"/test",
"indexAction",
["POST", "GET"],
"test"
);
public function options( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is OPTIONS.
public function patch( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is PATCH.
public function post( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is POST.
public function put( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is PUT.
public function setHandler( mixed $handler, bool $lazy = bool ): CollectionInterface;
Sets the main handler.
public function setLazy( bool $lazy ): CollectionInterface;
Sets if the main handler must be lazy loaded
public function setPrefix( string $prefix ): CollectionInterface;
Sets a prefix for all routes added to the collection
protected function addMap( mixed $method, string $routePattern, callable $handler, string $name = null ): void;
Internal function to add a handler to the group.
| Namespace | Phalcon\Mvc\Micro |
Phalcon\Mvc\Micro\CollectionInterface
Interface for Phalcon\Mvc\Micro\Collection
public function delete( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is DELETE
public function get( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is GET
public function getHandler(): mixed;
Returns the main handler
public function getHandlers(): array;
Returns the registered handlers
public function getPrefix(): string;
Returns the collection prefix if any
public function head( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is HEAD
public function isLazy(): bool;
Returns if the main handler must be lazy loaded
public function map( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler
public function options( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is OPTIONS
public function patch( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is PATCH
public function post( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is POST
public function put( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
Maps a route to a handler that only matches if the HTTP method is PUT
public function setHandler( mixed $handler, bool $lazy = bool ): CollectionInterface;
Sets the main handler
public function setLazy( bool $lazy ): CollectionInterface;
Sets if the main handler must be lazy loaded
public function setPrefix( string $prefix ): CollectionInterface;
Sets a prefix for all routes added to the collection
| Namespace | Phalcon\Mvc\Micro | Extends | \Exception |
Exceptions thrown in Phalcon\Mvc\Micro will use this class
| Namespace | Phalcon\Mvc\Micro | Uses | Phalcon\Mvc\Model\BinderInterface |
Phalcon\Mvc\Micro\LazyLoader
Lazy-Load of handlers for Mvc\Micro using auto-loading
/**
* @var string
*/
protected definition;
/**
* @var object|null
*/
protected handler;
public function __construct( string $definition );
Phalcon\Mvc\Micro\LazyLoader constructor
public function callMethod( string $method, mixed $arguments, BinderInterface $modelBinder = null );
Calling __call method
public function getDefinition(): string;
public function getHandler(): object | null;
| Namespace | Phalcon\Mvc\Micro | Uses | Phalcon\Mvc\Micro |
Allows to implement Phalcon\Mvc\Micro middleware in classes
public function call( Micro $application );
Calls the middleware
| Namespace | Phalcon\Mvc | Uses | JsonSerializable, Phalcon\Db\Adapter\AdapterInterface, Phalcon\Db\Column, Phalcon\Db\DialectInterface, Phalcon\Db\Enum, Phalcon\Db\RawValue, Phalcon\Di\AbstractInjectionAware, Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Events\ManagerInterface, Phalcon\Messages\Message, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model\BehaviorInterface, Phalcon\Mvc\Model\Criteria, Phalcon\Mvc\Model\CriteriaInterface, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\ManagerInterface, Phalcon\Mvc\Model\MetaDataInterface, Phalcon\Mvc\Model\Query, Phalcon\Mvc\Model\Query\Builder, Phalcon\Mvc\Model\Query\BuilderInterface, Phalcon\Mvc\Model\QueryInterface, Phalcon\Mvc\Model\ResultInterface, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Relation, Phalcon\Mvc\Model\RelationInterface, Phalcon\Mvc\Model\TransactionInterface, Phalcon\Mvc\Model\ValidationFailed, Phalcon\Mvc\ModelInterface, Phalcon\Filter\Validation\ValidationInterface, Serializable | Extends | AbstractInjectionAware | Implements | EntityInterface, ModelInterface, ResultInterface, Serializable, JsonSerializable |
Phalcon\Mvc\Model
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.
$robot = new Robots();
$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;
if ($robot->save() === false) {
echo "Umh, We can store robots: ";
$messages = $robot->getMessages();
foreach ($messages as $message) {
echo $message;
}
} else {
echo "Great, a new robot was saved successfully!";
}
const DIRTY_STATE_DETACHED = 2;
const DIRTY_STATE_PERSISTENT = 0;
const DIRTY_STATE_TRANSIENT = 1;
const OP_CREATE = 1;
const OP_DELETE = 3;
const OP_NONE = 0;
const OP_UPDATE = 2;
const TRANSACTION_INDEX = transaction;
/**
* @var int
*/
protected dirtyState = 1;
/**
* @var array
*/
protected dirtyRelated;
/**
* @var array
*/
protected errorMessages;
/**
* @var ManagerInterface|null
*/
protected modelsManager;
/**
* @var MetaDataInterface|null
*/
protected modelsMetaData;
/**
* @var array
*/
protected related;
/**
* @var int
*/
protected operationMade = 0;
/**
* @var array
*/
protected oldSnapshot;
/**
* @var bool
*/
protected skipped = false;
/**
* @var array
*/
protected snapshot;
/**
* @var TransactionInterface|null
*/
protected transaction;
/**
* @var string|null
*/
protected uniqueKey;
/**
* @var array
*/
protected uniqueParams;
/**
* @var array
*/
protected uniqueTypes;
public function __call( string $method, array $arguments );
Handles method calls when a method is not implemented
public static function __callStatic( string $method, array $arguments );
Handles method calls when a static method is not implemented
final public function __construct( mixed $data = null, DiInterface $container = null, ManagerInterface $modelsManager = null );
Phalcon\Mvc\Model constructor
public function __get( string $property );
Magic method to get related records using the relation alias as a property
public function __isset( string $property ): bool;
Magic method to check if a property is a valid relation
public function __serialize(): array;
Serializes a model
public function __set( string $property, mixed $value );
Magic method to assign values to the the model
public function __unserialize( array $data ): void;
Unserializes an array to the model
public function addBehavior( BehaviorInterface $behavior ): void;
Setups a behavior in a model
use Phalcon\Mvc\Model;
use Phalcon\Mvc\Model\Behavior\Timestampable;
class Robots extends Model
{
public function initialize()
{
$this->addBehavior(
new Timestampable(
[
"beforeCreate" => [
"field" => "created_at",
"format" => "Y-m-d",
],
]
)
);
$this->addBehavior(
new Timestampable(
[
"beforeUpdate" => [
"field" => "updated_at",
"format" => "Y-m-d",
],
]
)
);
}
}
public function appendMessage( MessageInterface $message ): ModelInterface;
Appends a customized message on the validation process
use Phalcon\Mvc\Model;
use Phalcon\Messages\Message as Message;
class Robots extends Model
{
public function beforeSave()
{
if ($this->name === "Peter") {
$message = new Message(
"Sorry, but a robot cannot be named Peter"
);
$this->appendMessage($message);
}
}
}
public function assign( array $data, mixed $whiteList = null, mixed $dataColumnMap = null ): ModelInterface;
Assigns values to a model from an array
$robot->assign(
[
"type" => "mechanical",
"name" => "Astro Boy",
"year" => 1952,
]
);
// Assign by db row, column map needed
$robot->assign(
$dbRow,
[
"db_type" => "type",
"db_name" => "name",
"db_year" => "year",
]
);
// Allow assign only name and year
$robot->assign(
$_POST,
[
"name",
"year",
]
);
// By default assign method will use setters if exist, you can disable it by using ini_set to directly use properties
ini_set("phalcon.orm.disable_assign_setters", true);
$robot->assign(
$_POST,
[
"name",
"year",
]
);
public static function average( array $parameters = [] ): double | ResultsetInterface;
Returns the average value on a column for a result-set of rows matching the specified conditions.
Returned value will be a float for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the average of each group.
// What's the average price of robots?
$average = Robots::average(
[
"column" => "price",
]
);
echo "The average price is ", $average, "\n";
// What's the average price of mechanical robots?
$average = Robots::average(
[
"type = 'mechanical'",
"column" => "price",
]
);
echo "The average price of mechanical robots is ", $average, "\n";
public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;
Assigns values to a model from an array returning a new model
$robot = Phalcon\Mvc\Model::cloneResult(
new Robots(),
[
"type" => "mechanical",
"name" => "Astro Boy",
"year" => 1952,
]
);
public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = null ): ModelInterface;
Assigns values to a model from an array, returning a new model.
$robot = \Phalcon\Mvc\Model::cloneResultMap(
new Robots(),
[
"type" => "mechanical",
"name" => "Astro Boy",
"year" => 1952,
]
);
public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );
Returns an hydrated result based on the data and the column map
public static function count( mixed $parameters = null ): int | ResultsetInterface;
Counts how many records match the specified conditions.
Returns an integer for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the count of each group.
// 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 function create(): bool;
Inserts a model instance. If the instance already exists in the persistence it will throw an exception Returning true on success or false otherwise.
// 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->assign(
[
"type" => "mechanical",
"name" => "Astro Boy",
"year" => 1952,
]
);
$robot->create();
public function delete(): bool;
Deletes a model instance. Returning true on success or false otherwise.
$robot = Robots::findFirst("id=100");
$robot->delete();
$robots = Robots::find("type = 'mechanical'");
foreach ($robots as $robot) {
$robot->delete();
}
public function dump(): array;
Returns a simple representation of the object that can be used with var_dump()
var_dump(
$robot->dump()
);
public static function find( mixed $parameters = null ): ResultsetInterface;
Query for a set of records that match the specified conditions
// 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(
[
"type = 'virtual'",
"order" => "name",
]
);
foreach ($robots as $robot) {
echo $robot->name, "\n";
}
// Get first 100 virtual robots ordered by name
$robots = Robots::find(
[
"type = 'virtual'",
"order" => "name",
"limit" => 100,
]
);
foreach ($robots as $robot) {
echo $robot->name, "\n";
}
// encapsulate find it into an running transaction esp. useful for application unit-tests
// or complex business logic where we wanna control which transactions are used.
$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();
$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);
$newRobot->assign(
[
'name' => 'test',
'type' => 'mechanical',
'year' => 1944,
]
);
$newRobot->save();
$resultInsideTransaction = Robot::find(
[
'name' => 'test',
Model::TRANSACTION_INDEX => $myTransaction,
]
);
$resultOutsideTransaction = Robot::find(['name' => 'test']);
foreach ($setInsideTransaction as $robot) {
echo $robot->name, "\n";
}
foreach ($setOutsideTransaction as $robot) {
echo $robot->name, "\n";
}
// reverts all not commited changes
$myTransaction->rollback();
// creating two different transactions
$myTransaction1 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction1->begin();
$myTransaction2 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction2->begin();
// add a new robots
$firstNewRobot = new Robot();
$firstNewRobot->setTransaction($myTransaction1);
$firstNewRobot->assign(
[
'name' => 'first-transaction-robot',
'type' => 'mechanical',
'year' => 1944,
]
);
$firstNewRobot->save();
$secondNewRobot = new Robot();
$secondNewRobot->setTransaction($myTransaction2);
$secondNewRobot->assign(
[
'name' => 'second-transaction-robot',
'type' => 'fictional',
'year' => 1984,
]
);
$secondNewRobot->save();
// this transaction will find the robot.
$resultInFirstTransaction = Robot::find(
[
'name' => 'first-transaction-robot',
Model::TRANSACTION_INDEX => $myTransaction1,
]
);
// this transaction won't find the robot.
$resultInSecondTransaction = Robot::find(
[
'name' => 'first-transaction-robot',
Model::TRANSACTION_INDEX => $myTransaction2,
]
);
// this transaction won't find the robot.
$resultOutsideAnyExplicitTransaction = Robot::find(
[
'name' => 'first-transaction-robot',
]
);
// this transaction won't find the robot.
$resultInFirstTransaction = Robot::find(
[
'name' => 'second-transaction-robot',
Model::TRANSACTION_INDEX => $myTransaction2,
]
);
// this transaction will find the robot.
$resultInSecondTransaction = Robot::find(
[
'name' => 'second-transaction-robot',
Model::TRANSACTION_INDEX => $myTransaction1,
]
);
// this transaction won't find the robot.
$resultOutsideAnyExplicitTransaction = Robot::find(
[
'name' => 'second-transaction-robot',
]
);
$transaction1->rollback();
$transaction2->rollback();
public static function findFirst( mixed $parameters = null ): mixed | null;
Query the first record that matches the specified conditions
// 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(
[
"type = 'virtual'",
"order" => "name",
]
);
echo "The first virtual robot name is ", $robot->name;
// behaviour with transaction
$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();
$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);
$newRobot->assign(
[
'name' => 'test',
'type' => 'mechanical',
'year' => 1944,
]
);
$newRobot->save();
$findsARobot = Robot::findFirst(
[
'name' => 'test',
Model::TRANSACTION_INDEX => $myTransaction,
]
);
$doesNotFindARobot = Robot::findFirst(
[
'name' => 'test',
]
);
var_dump($findARobot);
var_dump($doesNotFindARobot);
$transaction->commit();
$doesFindTheRobotNow = Robot::findFirst(
[
'name' => 'test',
]
);
public function fireEvent( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified
public function fireEventCancel( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified This method stops if one of the callbacks/listeners returns bool false
public function getChangedFields(): array;
Returns a list of changed values.
$robots = Robots::findFirst();
print_r($robots->getChangedFields()); // []
$robots->deleted = 'Y';
$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]
public function getDirtyState(): int;
Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
public function getEventsManager(): EventsManagerInterface | null;
Returns the custom events manager or null if there is no custom events manager
public function getMessages( mixed $filter = null ): MessageInterface[];
Returns array of validation messages
$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 ";
$messages = $robot->getMessages();
foreach ($messages as $message) {
echo $message;
}
} else {
echo "Great, a new robot was saved successfully!";
}
public function getModelsManager(): ManagerInterface;
Returns the models manager related to the entity instance
public function getModelsMetaData(): MetaDataInterface;
{@inheritdoc}
public function getOldSnapshotData(): array;
Returns the internal old snapshot data
public function getOperationMade(): int;
Returns the type of the latest operation performed by the ORM Returns one of the OP_* class constants
final public function getReadConnection(): AdapterInterface;
Gets the connection used to read data for the model
final public function getReadConnectionService(): string;
Returns the DependencyInjection connection service name used to read data related the model
public function getRelated( string $alias, mixed $arguments = null );
Returns related records based on defined relations
final public function getSchema(): string | null;
Returns schema name where the mapped table is located
public function getSnapshotData(): array;
Returns the internal snapshot data
final public function getSource(): string;
Returns the table name mapped in the model
public function getTransaction(): TransactionInterface | null;
public function getUpdatedFields(): array;
Returns a list of updated values.
$robots = Robots::findFirst();
print_r($robots->getChangedFields()); // []
$robots->deleted = 'Y';
$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]
$robots->save();
print_r($robots->getChangedFields()); // []
print_r($robots->getUpdatedFields()); // ["deleted"]
final public function getWriteConnection(): AdapterInterface;
Gets the connection used to write data to the model
final public function getWriteConnectionService(): string;
Returns the DependencyInjection connection service name used to write data related to the model
public function hasChanged( mixed $fieldName = null, bool $allFields = bool ): bool;
Check if a specific attribute has changed This only works if the model is keeping data snapshots
$robot = new Robots();
$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;
$robot->create();
$robot->type = "hydraulic";
$hasChanged = $robot->hasChanged("type"); // returns true
$hasChanged = $robot->hasChanged(["type", "name"]); // returns true
$hasChanged = $robot->hasChanged(["type", "name"], true); // returns false
public function hasSnapshotData(): bool;
Checks if the object has internal snapshot data
public function hasUpdated( mixed $fieldName = null, bool $allFields = bool ): bool;
Check if a specific attribute was updated This only works if the model is keeping data snapshots
public function isRelationshipLoaded( string $relationshipAlias ): bool;
Checks if saved related records have already been loaded.
Only returns true if the records were previously fetched through the model without any additional parameters.
$robot = Robots::findFirst();
var_dump($robot->isRelationshipLoaded('robotsParts')); // false
$robotsParts = $robot->getRobotsParts(['id > 0']);
var_dump($robot->isRelationshipLoaded('robotsParts')); // false
$robotsParts = $robot->getRobotsParts(); // or $robot->robotsParts
var_dump($robot->isRelationshipLoaded('robotsParts')); // true
$robot->robotsParts = [new RobotsParts()];
var_dump($robot->isRelationshipLoaded('robotsParts')); // false
public function jsonSerialize(): array;
Serializes the object for json_encode
echo json_encode($robot);
public static function maximum( mixed $parameters = null ): mixed;
Returns the maximum value of a column for a result-set of rows that match the specified conditions
// What is the maximum robot id?
$id = Robots::maximum(
[
"column" => "id",
]
);
echo "The maximum robot id is: ", $id, "\n";
// What is the maximum id of mechanical robots?
$sum = Robots::maximum(
[
"type = 'mechanical'",
"column" => "id",
]
);
echo "The maximum robot id of mechanical robots is ", $id, "\n";
public static function minimum( mixed $parameters = null ): mixed;
Returns the minimum value of a column for a result-set of rows that match the specified conditions
// What is the minimum robot id?
$id = Robots::minimum(
[
"column" => "id",
]
);
echo "The minimum robot id is: ", $id;
// What is the minimum id of mechanical robots?
$sum = Robots::minimum(
[
"type = 'mechanical'",
"column" => "id",
]
);
echo "The minimum robot id of mechanical robots is ", $id;
public static function query( DiInterface $container = null ): CriteriaInterface;
Create a criteria for a specific model
public function readAttribute( string $attribute ): mixed | null;
Reads an attribute value by its name
echo $robot->readAttribute("name");
public function refresh(): ModelInterface;
Refreshes the model attributes re-querying the record from the database
public function save(): bool;
Inserts or updates a model instance. Returning true on success or false otherwise.
// 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 function serialize(): string;
Serializes the object ignoring connections, services, related objects or static properties
final public function setConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name
public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Sets the dirty state of the object using one of the DIRTY_STATE_* constants
public function setEventsManager( EventsManagerInterface $eventsManager );
Sets a custom events manager
public function setOldSnapshotData( array $data, mixed $columnMap = null );
Sets the record’s old snapshot data. This method is used internally to set old snapshot data when the model was set up to keep snapshot data
final public function setReadConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name used to read data
public function setSnapshotData( array $data, mixed $columnMap = null ): void;
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 function setTransaction( TransactionInterface $transaction ): ModelInterface;
Sets a transaction related to the Model instance
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();
}
final public function setWriteConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name used to write data
public static function setup( array $options ): void;
Enables/disables options in the ORM
public function skipOperation( bool $skip ): void;
Skips the current operation forcing a success state
public static function sum( mixed $parameters = null ): double | ResultsetInterface;
Calculates the sum on a column for a result-set of rows that match the specified conditions
// How much are all robots?
$sum = Robots::sum(
[
"column" => "price",
]
);
echo "The total price of robots is ", $sum, "\n";
// How much are mechanical robots?
$sum = Robots::sum(
[
"type = 'mechanical'",
"column" => "price",
]
);
echo "The total price of mechanical robots is ", $sum, "\n";
public function toArray( mixed $columns = null ): array;
Returns the instance as an array representation
print_r(
$robot->toArray()
);
public function unserialize( mixed $data );
Unserializes the object from a serialized string
public function update(): bool;
Updates a model instance. If the instance doesn’t exist in the persistence it will throw an exception. Returning true on success or false otherwise.
// Updating a robot name
$robot = Robots::findFirst("id = 100");
$robot->name = "Biomass";
$robot->update();
public function validationHasFailed(): bool;
Check whether validation process has generated any messages
use Phalcon\Mvc\Model;
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;
class Subscriptors extends Model
{
public function validation()
{
$validator = new Validation();
$validator->validate(
"status",
new ExclusionIn(
[
"domain" => [
"A",
"I",
],
]
)
);
return $this->validate($validator);
}
}
public function writeAttribute( string $attribute, mixed $value ): void;
Writes an attribute value by its name
$robot->writeAttribute("name", "Rosey");
protected function allowEmptyStringValues( array $attributes ): void;
Sets a list of attributes that must be skipped from the generated UPDATE statement
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->allowEmptyStringValues(
[
"name",
]
);
}
}
protected function belongsTo( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;
Setup a reverse 1-1 or n-1 relation between two models
class RobotsParts extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->belongsTo(
"robots_id",
Robots::class,
"id"
);
}
}
protected function cancelOperation();
Cancel the current operation
final protected function checkForeignKeysRestrict(): bool;
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
final protected function checkForeignKeysReverseCascade(): bool;
Reads both “hasMany” and “hasOne” relations and checks the virtual foreign keys (cascade) when deleting records
final protected function checkForeignKeysReverseRestrict(): bool;
Reads both “hasMany” and “hasOne” relations and checks the virtual foreign keys (restrict) when deleting records
protected function collectRelatedToSave(): array;
Collects previously queried (belongs-to, has-one and has-one-through) related records along with freshly added one
protected function doLowInsert( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table, mixed $identityField ): bool;
Sends a pre-build INSERT SQL statement to the relational database system
protected function doLowUpdate( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table ): bool;
Sends a pre-build UPDATE SQL statement to the relational database system
protected function getRelatedRecords( string $modelName, string $method, array $arguments );
Returns related records defined relations depending on the method name. Returns false if the relation is non-existent.
protected static function groupResult( string $functionName, string $alias, mixed $parameters = null ): ResultsetInterface;
Generate a PHQL SELECT statement for an aggregate
protected function has( MetaDataInterface $metaData, AdapterInterface $connection ): bool;
Checks whether the current record already exists
protected function hasMany( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;
Setup a 1-n relation between two models
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasMany(
"id",
RobotsParts::class,
"robots_id"
);
}
}
protected function hasManyToMany( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;
Setup an n-n relation between two models, through an intermediate relation
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
// Setup a many-to-many relation to Parts through RobotsParts
$this->hasManyToMany(
"id",
RobotsParts::class,
"robots_id",
"parts_id",
Parts::class,
"id",
);
}
}
protected function hasOne( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;
Setup a 1-1 relation between two models
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasOne(
"id",
RobotsDescription::class,
"robots_id"
);
}
}
protected function hasOneThrough( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;
Setup a 1-1 relation between two models, through an intermediate relation
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
// Setup a 1-1 relation to one item from Parts through RobotsParts
$this->hasOneThrough(
"id",
RobotsParts::class,
"robots_id",
"parts_id",
Parts::class,
"id",
);
}
}
protected function keepSnapshots( bool $keepSnapshot ): void;
Sets if the model must keep the original record snapshot in memory
use Phalcon\Mvc\Model;
class Robots extends Model
{
public function initialize()
{
$this->keepSnapshots(true);
}
}
final protected function possibleSetter( string $property, mixed $value ): bool;
Check for, and attempt to use, possible setter.
protected function postSave( bool $success, bool $exists ): bool;
Executes internal events after save a record
protected function postSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Save the related records assigned in the has-one/has-many relations
protected function preSave( MetaDataInterface $metaData, bool $exists, mixed $identityField ): bool;
Executes internal hooks before save a record
protected function preSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Saves related records that must be stored prior to save the master record
final protected function setSchema( string $schema ): ModelInterface;
Sets schema name where the mapped table is located
final protected function setSource( string $source ): ModelInterface;
Sets the table name to which model should be mapped
protected function skipAttributes( array $attributes ): void;
Sets a list of attributes that must be skipped from the generated INSERT/UPDATE statement
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributes(
[
"price",
]
);
}
}
protected function skipAttributesOnCreate( array $attributes ): void;
Sets a list of attributes that must be skipped from the generated INSERT statement
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnCreate(
[
"created_at",
]
);
}
}
protected function skipAttributesOnUpdate( array $attributes ): void;
Sets a list of attributes that must be skipped from the generated UPDATE statement
class Robots extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnUpdate(
[
"modified_in",
]
);
}
}
protected function useDynamicUpdate( bool $dynamicUpdate ): void;
Sets if a model must use dynamic update instead of the all-field update
use Phalcon\Mvc\Model;
class Robots extends Model
{
public function initialize()
{
$this->useDynamicUpdate(true);
}
}
protected function validate( ValidationInterface $validator ): bool;
Executes validators on every validation call
use Phalcon\Mvc\Model;
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;
class Subscriptors extends Model
{
public function validation()
{
$validator = new Validation();
$validator->add(
"status",
new ExclusionIn(
[
"domain" => [
"A",
"I",
],
]
)
);
return $this->validate($validator);
}
}
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface | Implements | BehaviorInterface |
Phalcon\Mvc\Model\Behavior
This is an optional base class for ORM behaviors
/**
* @var array
*/
protected options;
public function __construct( array $options = [] );
Phalcon\Mvc\Model\Behavior
public function missingMethod( ModelInterface $model, string $method, array $arguments = [] );
Acts as fallbacks when a missing method is called on the model
public function notify( string $type, ModelInterface $model );
This method receives the notifications from the EventsManager
protected function getOptions( string $eventName = null );
Returns the behavior options related to an event
protected function mustTakeAction( string $eventName ): bool;
Checks whether the behavior must take action on certain event
| Namespace | Phalcon\Mvc\Model\Behavior | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Behavior, Phalcon\Mvc\Model\Exception | Extends | Behavior |
Phalcon\Mvc\Model\Behavior\SoftDelete
Instead of permanently delete a record it marks the record as deleted changing the value of a flag column
public function notify( string $type, ModelInterface $model );
Listens for notifications from the models manager
| Namespace | Phalcon\Mvc\Model\Behavior | Uses | Closure, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Behavior, Phalcon\Mvc\Model\Exception | Extends | Behavior |
Phalcon\Mvc\Model\Behavior\Timestampable
Allows to automatically update a model’s attribute saving the datetime when a record is created or updated
public function notify( string $type, ModelInterface $model );
Listens for notifications from the models manager
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\BehaviorInterface
Interface for Phalcon\Mvc\Model\Behavior
public function missingMethod( ModelInterface $model, string $method, array $arguments = [] );
Calls a method when it’s missing in the model
public function notify( string $type, ModelInterface $model );
This method receives the notifications from the EventsManager
| Namespace | Phalcon\Mvc\Model | Uses | Closure, Phalcon\Mvc\Controller\BindModelInterface, Phalcon\Mvc\Model\Binder\BindableInterface, Phalcon\Cache\Adapter\AdapterInterface, ReflectionFunction, ReflectionMethod | Implements | BinderInterface |
Phalcon\Mvc\Model\Binder
This is an class for binding models into params for handler
/**
* Array for storing active bound models
*
* @var array
*/
protected boundModels;
/**
* Cache object used for caching parameters for model binding
*
* @var AdapterInterface|null
*/
protected cache;
/**
* Internal cache for caching parameters for model binding during request
*
* @var array
*/
protected internalCache;
/**
* Array for original values
*
* @var array
*/
protected originalValues;
public function __construct( AdapterInterface $cache = null );
Phalcon\Mvc\Model\Binder constructor
public function bindToHandler( object $handler, array $params, string $cacheKey, string $methodName = null ): array;
Bind models into params in proper handler
public function getBoundModels(): array;
Return the active bound models
public function getCache(): AdapterInterface;
Sets cache instance
public function getOriginalValues(): array;
Return the array for original values
public function setCache( AdapterInterface $cache ): BinderInterface;
Gets cache instance
protected function findBoundModel( mixed $paramValue, string $className ): mixed | bool;
Find the model by param value.
protected function getParamsFromCache( string $cacheKey ): array | null;
Get params classes from cache by key
protected function getParamsFromReflection( object $handler, array $params, string $cacheKey, string $methodName ): array;
Get modified params for handler using reflection
| Namespace | Phalcon\Mvc\Model\Binder |
Phalcon\Mvc\Model\Binder\BindableInterface
Interface for bindable classes
public function getModelName(): string | array;
Return the model name or models names and parameters keys associated with this class
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Cache\Adapter\AdapterInterface |
Phalcon\Mvc\Model\BinderInterface
Interface for Phalcon\Mvc\Model\Binder
public function bindToHandler( object $handler, array $params, string $cacheKey, string $methodName = null ): array;
Bind models into params in proper handler
public function getBoundModels(): array;
Gets active bound models
public function getCache(): AdapterInterface;
Gets cache instance
public function setCache( AdapterInterface $cache ): BinderInterface;
Sets cache instance
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Di\Di, Phalcon\Db\Column, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\Query\BuilderInterface | Implements | CriteriaInterface, InjectionAwareInterface |
Phalcon\Mvc\Model\Criteria
This class is used to build the array parameter required by Phalcon\Mvc\Model::find() and Phalcon\Mvc\Model::findFirst() using an object-oriented interface.
$robots = Robots::query()
->where("type = :type:")
->andWhere("year < 2000")
->bind(["type" => "mechanical"])
->limit(5, 10)
->orderBy("name")
->execute();
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var int
*/
protected hiddenParamNumber = 0;
/**
* @var string|null
*/
protected model;
/**
* @var array
*/
protected params;
public function andWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Appends a condition to the current conditions using an AND operator
public function betweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;
Appends a BETWEEN condition to the current conditions
$criteria->betweenWhere("price", 100.25, 200.50);
public function bind( array $bindParams, bool $merge = bool ): CriteriaInterface;
Sets the bound parameters in the criteria This method replaces all previously set bound parameters
public function bindTypes( array $bindTypes ): CriteriaInterface;
Sets the bind types in the criteria This method replaces all previously set bound parameters
public function cache( array $cache ): CriteriaInterface;
Sets the cache options in the criteria This method replaces all previously set cache options
public function columns( mixed $columns ): CriteriaInterface;
Sets the columns to be queried
$criteria->columns(
[
"id",
"name",
]
);
public function conditions( string $conditions ): CriteriaInterface;
Adds the conditions parameter to the criteria
public function createBuilder(): BuilderInterface;
Creates a query builder from criteria.
$builder = Robots::query()
->where("type = :type:")
->bind(["type" => "mechanical"])
->createBuilder();
public function distinct( mixed $distinct ): CriteriaInterface;
Sets SELECT DISTINCT / SELECT ALL flag
public function execute(): ResultsetInterface;
Executes a find using the parameters built with the criteria
public function forUpdate( bool $forUpdate = bool ): CriteriaInterface;
Adds the “for_update” parameter to the criteria
public static function fromInput( DiInterface $container, string $modelName, array $data, string $operator = string ): CriteriaInterface;
Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
public function getColumns(): string | array | null;
Returns the columns to be queried
public function getConditions(): string | null;
Returns the conditions parameter in the criteria
public function getDI(): DiInterface;
Returns the DependencyInjector container
public function getGroupBy();
Returns the group clause in the criteria
public function getHaving();
Returns the having clause in the criteria
public function getLimit(): int | array | null;
Returns the limit parameter in the criteria, which will be
public function getModelName(): string;
Returns an internal model name on which the criteria will be applied
public function getOrderBy(): string | null;
Returns the order clause in the criteria
public function getParams(): array;
Returns all the parameters defined in the criteria
public function getWhere(): string | null;
Returns the conditions parameter in the criteria
public function groupBy( mixed $group ): CriteriaInterface;
Adds the group-by clause to the criteria
public function having( mixed $having ): CriteriaInterface;
Adds the having clause to the criteria
public function inWhere( string $expr, array $values ): CriteriaInterface;
Appends an IN condition to the current conditions
$criteria->inWhere("id", [1, 2, 3]);
public function innerJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds an INNER join to the query
$criteria->innerJoin(
Robots::class
);
$criteria->innerJoin(
Robots::class,
"r.id = RobotsParts.robots_id"
);
$criteria->innerJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function join( string $model, mixed $conditions = null, mixed $alias = null, mixed $type = null ): CriteriaInterface;
Adds an INNER join to the query
$criteria->join(
Robots::class
);
$criteria->join(
Robots::class,
"r.id = RobotsParts.robots_id"
);
$criteria->join(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
$criteria->join(
Robots::class,
"r.id = RobotsParts.robots_id",
"r",
"LEFT"
);
public function leftJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a LEFT join to the query
$criteria->leftJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function limit( int $limit, int $offset = int ): CriteriaInterface;
Adds the limit parameter to the criteria.
$criteria->limit(100);
$criteria->limit(100, 200);
$criteria->limit("100", "200");
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;
Appends a NOT BETWEEN condition to the current conditions
$criteria->notBetweenWhere("price", 100.25, 200.50);
public function notInWhere( string $expr, array $values ): CriteriaInterface;
Appends a NOT IN condition to the current conditions
$criteria->notInWhere("id", [1, 2, 3]);
public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Appends a condition to the current conditions using an OR operator
public function orderBy( string $orderColumns ): CriteriaInterface;
Adds the order-by clause to the criteria
public function rightJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a RIGHT join to the query
$criteria->rightJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function setDI( DiInterface $container ): void;
Sets the DependencyInjector container
public function setModelName( string $modelName ): CriteriaInterface;
Set a model on which the query will be executed
public function sharedLock( bool $sharedLock = bool ): CriteriaInterface;
Adds the “shared_lock” parameter to the criteria
public function where( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Sets the conditions parameter in the criteria
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Di\DiInterface |
Phalcon\Mvc\Model\CriteriaInterface
Interface for Phalcon\Mvc\Model\Criteria
public function andWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Appends a condition to the current conditions using an AND operator
public function betweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;
Appends a BETWEEN condition to the current conditions
$criteria->betweenWhere("price", 100.25, 200.50);
public function bind( array $bindParams ): CriteriaInterface;
Sets the bound parameters in the criteria This method replaces all previously set bound parameters
public function bindTypes( array $bindTypes ): CriteriaInterface;
Sets the bind types in the criteria This method replaces all previously set bound parameters
public function cache( array $cache ): CriteriaInterface;
Sets the cache options in the criteria This method replaces all previously set cache options
public function conditions( string $conditions ): CriteriaInterface;
Adds the conditions parameter to the criteria
public function distinct( mixed $distinct ): CriteriaInterface;
Sets SELECT DISTINCT / SELECT ALL flag
public function execute(): ResultsetInterface;
Executes a find using the parameters built with the criteria
public function forUpdate( bool $forUpdate = bool ): CriteriaInterface;
Sets the “for_update” parameter to the criteria
public function getColumns(): string | array | null;
Returns the columns to be queried
public function getConditions(): string | null;
Returns the conditions parameter in the criteria
public function getGroupBy();
Returns the group clause in the criteria
public function getHaving();
Returns the having clause in the criteria
public function getLimit(): int | array | null;
Returns the limit parameter in the criteria, which will be
public function getModelName(): string;
Returns an internal model name on which the criteria will be applied
public function getOrderBy(): string | null;
Returns the order parameter in the criteria
public function getParams(): array;
Returns all the parameters defined in the criteria
public function getWhere(): string | null;
Returns the conditions parameter in the criteria
public function groupBy( mixed $group ): CriteriaInterface;
Adds the group-by clause to the criteria
public function having( mixed $having ): CriteriaInterface;
Adds the having clause to the criteria
public function inWhere( string $expr, array $values ): CriteriaInterface;
Appends an IN condition to the current conditions
$criteria->inWhere("id", [1, 2, 3]);
public function innerJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds an INNER join to the query
$criteria->innerJoin(
Robots::class
);
$criteria->innerJoin(
Robots::class,
"r.id = RobotsParts.robots_id"
);
$criteria->innerJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function leftJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a LEFT join to the query
$criteria->leftJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function limit( int $limit, int $offset = int ): CriteriaInterface;
Sets the limit parameter to the criteria
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;
Appends a NOT BETWEEN condition to the current conditions
$criteria->notBetweenWhere("price", 100.25, 200.50);
public function notInWhere( string $expr, array $values ): CriteriaInterface;
Appends a NOT IN condition to the current conditions
$criteria->notInWhere("id", [1, 2, 3]);
public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Appends a condition to the current conditions using an OR operator
public function orderBy( string $orderColumns ): CriteriaInterface;
Adds the order-by parameter to the criteria
public function rightJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a RIGHT join to the query
$criteria->rightJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function setModelName( string $modelName ): CriteriaInterface;
Set a model on which the query will be executed
public function sharedLock( bool $sharedLock = bool ): CriteriaInterface;
Sets the “shared_lock” parameter to the criteria
public function where( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Sets the conditions parameter in the criteria
| Namespace | Phalcon\Mvc\Model | Extends | \Exception |
Phalcon\Mvc\Model\Exception
Exceptions thrown in Phalcon\Mvc\Model* classes will use this class
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Query\Builder, Phalcon\Mvc\Model\Query\BuilderInterface, Phalcon\Mvc\Model\Query\StatusInterface, ReflectionClass, ReflectionProperty | Implements | ManagerInterface, InjectionAwareInterface, EventsAwareInterface |
Phalcon\Mvc\Model\Manager
This components controls the initialization of models, keeping record of relations between the different models of the application.
A ModelsManager is injected to a model via a Dependency Injector/Services Container such as Phalcon\Di\Di.
use Phalcon\Di\Di;
use Phalcon\Mvc\Model\Manager as ModelsManager;
$di = new Di();
$di->set(
"modelsManager",
function() {
return new ModelsManager();
}
);
$robot = new Robots($di);
/**
* @var array
*/
protected aliases;
/**
* Models' behaviors
*
* @var array
*/
protected behaviors;
/**
* Belongs to relations
*
* @var array
*/
protected belongsTo;
/**
* All the relationships by model
*
* @var array
*/
protected belongsToSingle;
/**
* @var BuilderInterface|null
*/
protected builder;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var array
*/
protected customEventsManager;
/**
* Does the model use dynamic update, instead of updating all rows?
*
* @var array
*/
protected dynamicUpdate;
/**
* @var EventsManagerInterface|null
*/
protected eventsManager;
/**
* Has many relations
*
* @var array
*/
protected hasMany;
/**
* Has many relations by model
*
* @var array
*/
protected hasManySingle;
/**
* Has many-Through relations
*
* @var array
*/
protected hasManyToMany;
/**
* Has many-Through relations by model
*
* @var array
*/
protected hasManyToManySingle;
/**
* Has one relations
*
* @var array
*/
protected hasOne;
/**
* Has one relations by model
*
* @var array
*/
protected hasOneSingle;
/**
* Has one through relations
*
* @var array
*/
protected hasOneThrough;
/**
* Has one through relations by model
*
* @var array
*/
protected hasOneThroughSingle;
/**
* Mark initialized models
*
* @var array
*/
protected initialized;
/**
* @var array
*/
protected keepSnapshots;
/**
* Last model initialized
*
* @var ModelInterface|null
*/
protected lastInitialized;
/**
* Last query created/executed
*
* @var QueryInterface|null
*/
protected lastQuery;
/**
* @var array
*/
protected modelVisibility;
/**
* @var string
*/
protected prefix = ;
/**
* @var array
*/
protected readConnectionServices;
/**
* @var array
*/
protected sources;
/**
* @var array
*/
protected schemas;
/**
* @var array
*/
protected writeConnectionServices;
/**
* Stores a list of reusable instances
*
* @var array
*/
protected reusable;
public function __destruct();
Destroys the current PHQL cache
public function addBehavior( ModelInterface $model, BehaviorInterface $behavior ): void;
Binds a behavior to a model
public function addBelongsTo( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a relation reverse many to one between two models
public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a relation 1-n between two models
public function addHasManyToMany( ModelInterface $model, mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setups a relation n-m between two models
public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a 1-1 relation between two models
public function addHasOneThrough( ModelInterface $model, mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setups a relation 1-1 between two models using an intermediate model
public function clearReusableObjects(): void;
Clears the internal reusable list
public function createBuilder( mixed $params = null ): BuilderInterface;
Creates a Phalcon\Mvc\Model\Query\Builder
public function createQuery( string $phql ): QueryInterface;
Creates a Phalcon\Mvc\Model\Query without execute it
public function executeQuery( string $phql, mixed $placeholders = null, mixed $types = null ): mixed;
Creates a Phalcon\Mvc\Model\Query and execute it
$model = new Robots();
$manager = $model->getModelsManager();
// \Phalcon\Mvc\Model\Resultset\Simple
$manager->executeQuery('SELECTFROM Robots');
// \Phalcon\Mvc\Model\Resultset\Complex
$manager->executeQuery('SELECT COUNT(type) FROM Robots GROUP BY type');
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('INSERT INTO Robots (id) VALUES (1)');
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('UPDATE Robots SET id = 0 WHERE id = :id:', ['id' => 1]);
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('DELETE FROM Robots WHERE id = :id:', ['id' => 1]);
public function existsBelongsTo( string $modelName, string $modelRelation ): bool;
Checks whether a model has a belongsTo relation with another model @deprecated
public function existsHasMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasMany relation with another model @deprecated
public function existsHasManyToMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasManyToMany relation with another model @deprecated
public function existsHasOne( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOne relation with another model @deprecated
public function existsHasOneThrough( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOneThrough relation with another model @deprecated
public function getBelongsTo( ModelInterface $model ): RelationInterface[] | array;
Gets all the belongsTo relations defined in a model
$relations = $modelsManager->getBelongsTo(
new Robots()
);
public function getBelongsToRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;
Gets belongsTo related records from a model
public function getBuilder(): BuilderInterface | null;
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
public function getConnectionService( ModelInterface $model, array $connectionServices ): string;
Returns the connection service name used to read or write data related to a model depending on the connection services
public function getCustomEventsManager( ModelInterface $model ): EventsManagerInterface | null;
Returns a custom events manager related to a model or null if there is no related events manager
public function getDI(): DiInterface;
Returns the DependencyInjector container
public function getEventsManager(): EventsManagerInterface | null;
Returns the internal event manager
public function getHasMany( ModelInterface $model ): RelationInterface[] | array;
Gets hasMany relations defined on a model
public function getHasManyRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;
Gets hasMany related records from a model
public function getHasManyToMany( ModelInterface $model ): RelationInterface[] | array;
Gets hasManyToMany relations defined on a model
public function getHasOne( ModelInterface $model ): array;
Gets hasOne relations defined on a model
public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];
Gets hasOne relations defined on a model
public function getHasOneRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ModelInterface | bool;
Gets belongsTo related records from a model
public function getHasOneThrough( ModelInterface $model ): RelationInterface[] | array;
Gets hasOneThrough relations defined on a model
public function getLastInitialized(): ModelInterface;
Get last initialized model
public function getLastQuery(): QueryInterface;
Returns the last query created or executed in the models manager
public function getModelPrefix(): string;
Returns the prefix for all model sources.
public function getModelSchema( ModelInterface $model ): string | null;
Returns the mapped schema for a model
public function getModelSource( ModelInterface $model ): string;
Returns the mapped source for a model
public function getReadConnection( ModelInterface $model ): AdapterInterface;
Returns the connection to read data related to a model
public function getReadConnectionService( ModelInterface $model ): string;
Returns the connection service name used to read data related to a model
public function getRelationByAlias( string $modelName, string $alias ): RelationInterface | bool;
Returns a relation by its alias
public function getRelationRecords( RelationInterface $relation, ModelInterface $record, mixed $parameters = null, string $method = null );
Helper method to query records based on a relation definition
public function getRelations( string $modelName ): RelationInterface[];
Query all the relationships defined on a model
public function getRelationsBetween( string $first, string $second ): RelationInterface[] | bool;
Query the first relationship defined between two models
public function getReusableRecords( string $modelName, string $key );
Returns a reusable object from the internal list
public function getWriteConnection( ModelInterface $model ): AdapterInterface;
Returns the connection to write data related to a model
public function getWriteConnectionService( ModelInterface $model ): string;
Returns the connection service name used to write data related to a model
public function hasBelongsTo( string $modelName, string $modelRelation ): bool;
Checks whether a model has a belongsTo relation with another model
public function hasHasMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasMany relation with another model
public function hasHasManyToMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasManyToMany relation with another model
public function hasHasOne( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOne relation with another model
public function hasHasOneThrough( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOneThrough relation with another model
public function initialize( ModelInterface $model ): bool;
Initializes a model in the model manager
public function isInitialized( string $className ): bool;
Check whether a model is already initialized
public function isKeepingSnapshots( ModelInterface $model ): bool;
Checks if a model is keeping snapshots for the queried records
public function isUsingDynamicUpdate( ModelInterface $model ): bool;
Checks if a model is using dynamic update instead of all-field update
final public function isVisibleModelProperty( ModelInterface $model, string $property ): bool;
Check whether a model property is declared as public.
$isPublic = $manager->isVisibleModelProperty(
new Robots(),
"name"
);
public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;
Sets if a model must keep snapshots
public function load( string $modelName ): ModelInterface;
Loads a model throwing an exception if it doesn’t exist
public function missingMethod( ModelInterface $model, string $eventName, mixed $data );
Dispatch an event to the listeners and behaviors This method expects that the endpoint listeners/behaviors returns true meaning that a least one was implemented
public function notifyEvent( string $eventName, ModelInterface $model );
Receives events generated in the models and dispatches them to an events-manager if available. Notify the behaviors that are listening in the model
public function setConnectionService( ModelInterface $model, string $connectionService ): void;
Sets both write and read connection service for a model
public function setCustomEventsManager( ModelInterface $model, EventsManagerInterface $eventsManager ): void;
Sets a custom events manager for a specific model
public function setDI( DiInterface $container ): void;
Sets the DependencyInjector container
public function setEventsManager( EventsManagerInterface $eventsManager ): void;
Sets a global events manager
public function setModelPrefix( string $prefix ): void;
Sets the prefix for all model sources.
use Phalcon\Mvc\Model\Manager;
$di->set(
"modelsManager",
function () {
$modelsManager = new Manager();
$modelsManager->setModelPrefix("wp_");
return $modelsManager;
}
);
$robots = new Robots();
echo $robots->getSource(); // wp_robots
$param string $prefix
public function setModelSchema( ModelInterface $model, string $schema ): void;
Sets the mapped schema for a model
public function setModelSource( ModelInterface $model, string $source ): void;
Sets the mapped source for a model
public function setReadConnectionService( ModelInterface $model, string $connectionService ): void;
Sets read connection service for a model
public function setReusableRecords( string $modelName, string $key, mixed $records ): void;
Stores a reusable record in the internal list
public function setWriteConnectionService( ModelInterface $model, string $connectionService ): void;
Sets write connection service for a model
public function useDynamicUpdate( ModelInterface $model, bool $dynamicUpdate ): void;
Sets if a model must use dynamic update instead of the all-field update
protected function getConnection( ModelInterface $model, array $connectionServices ): AdapterInterface;
Returns the connection to read or write data related to a model depending on the connection services.
final protected function mergeFindParameters( mixed $findParamsOne, mixed $findParamsTwo ): array;
Merge two arrays of find parameters
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Db\Adapter\AdapterInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Query\BuilderInterface, Phalcon\Mvc\Model\Query\StatusInterface |
Phalcon\Mvc\Model\ManagerInterface
Interface for Phalcon\Mvc\Model\Manager
public function addBehavior( ModelInterface $model, BehaviorInterface $behavior ): void;
Binds a behavior to a model
public function addBelongsTo( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a relation reverse 1-1 between two models
public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a relation 1-n between two models
public function addHasManyToMany( ModelInterface $model, mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setups a relation n-m between two models
public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setup a 1-1 relation between two models
public function addHasOneThrough( ModelInterface $model, mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;
Setups a 1-1 relation between two models using an intermediate table
public function createBuilder( mixed $params = null ): BuilderInterface;
Creates a Phalcon\Mvc\Model\Query\Builder
public function createQuery( string $phql ): QueryInterface;
Creates a Phalcon\Mvc\Model\Query without execute it
public function executeQuery( string $phql, mixed $placeholders = null, mixed $types = null ): mixed;
Creates a Phalcon\Mvc\Model\Query and execute it
public function getBelongsTo( ModelInterface $model ): RelationInterface[] | array;
Gets belongsTo relations defined on a model
public function getBelongsToRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;
Gets belongsTo related records from a model
public function getBuilder(): BuilderInterface | null;
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
public function getHasMany( ModelInterface $model ): RelationInterface[] | array;
Gets hasMany relations defined on a model
public function getHasManyRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;
Gets hasMany related records from a model
public function getHasManyToMany( ModelInterface $model ): RelationInterface[] | array;
Gets hasManyToMany relations defined on a model
public function getHasOne( ModelInterface $model ): RelationInterface[] | array;
Gets hasOne relations defined on a model
public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];
Gets hasOne relations defined on a model
public function getHasOneRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ModelInterface | bool;
Gets hasOne related records from a model
public function getHasOneThrough( ModelInterface $model ): RelationInterface[] | array;
Gets hasOneThrough relations defined on a model
public function getLastInitialized(): ModelInterface;
Get last initialized model
public function getLastQuery(): QueryInterface;
Returns the last query created or executed in the models manager
public function getModelSchema( ModelInterface $model ): string | null;
Returns the mapped schema for a model
public function getModelSource( ModelInterface $model ): string;
Returns the mapped source for a model
public function getReadConnection( ModelInterface $model ): AdapterInterface;
Returns the connection to read data related to a model
public function getReadConnectionService( ModelInterface $model ): string;
Returns the connection service name used to read data related to a model
public function getRelationByAlias( string $modelName, string $alias ): RelationInterface | bool;
Returns a relation by its alias
public function getRelationRecords( RelationInterface $relation, ModelInterface $record, mixed $parameters = null, string $method = null );
Helper method to query records based on a relation definition
public function getRelations( string $modelName ): RelationInterface[];
Query all the relationships defined on a model
public function getRelationsBetween( string $first, string $second ): RelationInterface[] | bool;
Query the relations between two models
public function getWriteConnection( ModelInterface $model ): AdapterInterface;
Returns the connection to write data related to a model
public function getWriteConnectionService( ModelInterface $model ): string;
Returns the connection service name used to write data related to a model
public function hasBelongsTo( string $modelName, string $modelRelation ): bool;
Checks whether a model has a belongsTo relation with another model
public function hasHasMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasMany relation with another model
public function hasHasManyToMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasManyToMany relation with another model
public function hasHasOne( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOne relation with another model
public function hasHasOneThrough( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOneThrough relation with another model
public function initialize( ModelInterface $model );
Initializes a model in the model manager
public function isInitialized( string $className ): bool;
Check of a model is already initialized
public function isKeepingSnapshots( ModelInterface $model ): bool;
Checks if a model is keeping snapshots for the queried records
public function isUsingDynamicUpdate( ModelInterface $model ): bool;
Checks if a model is using dynamic update instead of all-field update
public function isVisibleModelProperty( ModelInterface $model, string $property ): bool;
Check whether a model property is declared as public.
$isPublic = $manager->isVisibleModelProperty(
new Robots(),
"name"
);
public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;
Sets if a model must keep snapshots
public function load( string $modelName ): ModelInterface;
Loads a model throwing an exception if it doesn’t exist
public function missingMethod( ModelInterface $model, string $eventName, mixed $data );
Dispatch an event to the listeners and behaviors This method expects that the endpoint listeners/behaviors returns true meaning that a least one is implemented
public function notifyEvent( string $eventName, ModelInterface $model );
Receives events generated in the models and dispatches them to an events-manager if available Notify the behaviors that are listening in the model
public function setConnectionService( ModelInterface $model, string $connectionService ): void;
Sets both write and read connection service for a model
public function setModelSchema( ModelInterface $model, string $schema ): void;
Sets the mapped schema for a model
public function setModelSource( ModelInterface $model, string $source ): void;
Sets the mapped source for a model
public function setReadConnectionService( ModelInterface $model, string $connectionService ): void;
Sets read connection service for a model
public function setWriteConnectionService( ModelInterface $model, string $connectionService );
Sets write connection service for a model
public function useDynamicUpdate( ModelInterface $model, bool $dynamicUpdate ): void;
Sets if a model must use dynamic update instead of the all-field update
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Cache\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\MetaData\Strategy\Introspection, Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface, Phalcon\Mvc\ModelInterface | Implements | InjectionAwareInterface, MetaDataInterface |
Phalcon\Mvc\Model\MetaData
Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc. This component collect them and store for further querying by Phalcon\Mvc\Model. Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
$metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
$attributes = $metaData->getAttributes(
new Robots()
);
print_r($attributes);
const MODELS_ATTRIBUTES = 0;
const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
const MODELS_COLUMN_MAP = 0;
const MODELS_DATA_TYPES = 4;
const MODELS_DATA_TYPES_BIND = 9;
const MODELS_DATA_TYPES_NUMERIC = 5;
const MODELS_DATE_AT = 6;
const MODELS_DATE_IN = 7;
const MODELS_DEFAULT_VALUES = 12;
const MODELS_EMPTY_STRING_VALUES = 13;
const MODELS_IDENTITY_COLUMN = 8;
const MODELS_NON_PRIMARY_KEY = 2;
const MODELS_NOT_NULL = 3;
const MODELS_PRIMARY_KEY = 1;
const MODELS_REVERSE_COLUMN_MAP = 1;
/**
* @var CacheAdapterInterface|null
*/
protected adapter;
/**
* @var array
*/
protected columnMap;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var array
*/
protected metaData;
/**
* @var StrategyInterface|null
*/
protected strategy;
public function getAdapter(): CacheAdapterInterface | null;
Return the internal cache adapter
public function getAttributes( ModelInterface $model ): array;
Returns table attributes names (fields)
print_r(
$metaData->getAttributes(
new Robots()
)
);
public function getAutomaticCreateAttributes( ModelInterface $model ): array;
Returns attributes that must be ignored from the INSERT SQL generation
print_r(
$metaData->getAutomaticCreateAttributes(
new Robots()
)
);
public function getAutomaticUpdateAttributes( ModelInterface $model ): array;
Returns attributes that must be ignored from the UPDATE SQL generation
print_r(
$metaData->getAutomaticUpdateAttributes(
new Robots()
)
);
public function getBindTypes( ModelInterface $model ): array;
Returns attributes and their bind data types
print_r(
$metaData->getBindTypes(
new Robots()
)
);
public function getColumnMap( ModelInterface $model ): array | null;
Returns the column map if any
print_r(
$metaData->getColumnMap(
new Robots()
)
);
public function getDI(): DiInterface;
Returns the DependencyInjector container
public function getDataTypes( ModelInterface $model ): array;
Returns attributes and their data types
print_r(
$metaData->getDataTypes(
new Robots()
)
);
public function getDataTypesNumeric( ModelInterface $model ): array;
Returns attributes which types are numerical
print_r(
$metaData->getDataTypesNumeric(
new Robots()
)
);
public function getDefaultValues( ModelInterface $model ): array;
Returns attributes (which have default values) and their default values
print_r(
$metaData->getDefaultValues(
new Robots()
)
);
public function getEmptyStringAttributes( ModelInterface $model ): array;
Returns attributes allow empty strings
print_r(
$metaData->getEmptyStringAttributes(
new Robots()
)
);
public function getIdentityField( ModelInterface $model ): string | null;
Returns the name of identity field (if one is present)
print_r(
$metaData->getIdentityField(
new Robots()
)
);
public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;
Returns an array of fields which are not part of the primary key
print_r(
$metaData->getNonPrimaryKeyAttributes(
new Robots()
)
);
public function getNotNullAttributes( ModelInterface $model ): array;
Returns an array of not null attributes
print_r(
$metaData->getNotNullAttributes(
new Robots()
)
);
public function getPrimaryKeyAttributes( ModelInterface $model ): array;
Returns an array of fields which are part of the primary key
print_r(
$metaData->getPrimaryKeyAttributes(
new Robots()
)
);
public function getReverseColumnMap( ModelInterface $model ): array | null;
Returns the reverse column map if any
print_r(
$metaData->getReverseColumnMap(
new Robots()
)
);
public function getStrategy(): StrategyInterface;
Return the strategy to obtain the meta-data
public function hasAttribute( ModelInterface $model, string $attribute ): bool;
Check if a model has certain attribute
var_dump(
$metaData->hasAttribute(
new Robots(),
"name"
)
);
public function isEmpty(): bool;
Checks if the internal meta-data container is empty
var_dump(
$metaData->isEmpty()
);
public function read( string $key ): array | null;
Reads metadata from the adapter
final public function readColumnMap( ModelInterface $model ): array | null;
Reads the ordered/reversed column map for certain model
print_r(
$metaData->readColumnMap(
new Robots()
)
);
final public function readColumnMapIndex( ModelInterface $model, int $index ): array | null;
Reads column-map information for certain model using a MODEL_* constant
print_r(
$metaData->readColumnMapIndex(
new Robots(),
MetaData::MODELS_REVERSE_COLUMN_MAP
)
);
final public function readMetaData( ModelInterface $model ): array | null;
Reads the complete meta-data for certain model
print_r(
$metaData->readMetaData(
new Robots()
)
);
final public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;
Reads meta-data for certain model
print_r(
$metaData->readMetaDataIndex(
new Robots(),
0
)
);
public function reset(): void;
Resets internal meta-data in order to regenerate it
$metaData->reset();
public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes ): void;
Set the attributes that must be ignored from the INSERT SQL generation
$metaData->setAutomaticCreateAttributes(
new Robots(),
[
"created_at" => true,
]
);
public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes ): void;
Set the attributes that must be ignored from the UPDATE SQL generation
$metaData->setAutomaticUpdateAttributes(
new Robots(),
[
"modified_at" => true,
]
);
public function setDI( DiInterface $container ): void;
Sets the DependencyInjector container
public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void;
Set the attributes that allow empty string values
$metaData->setEmptyStringAttributes(
new Robots(),
[
"name" => true,
]
);
public function setStrategy( StrategyInterface $strategy ): void;
Set the meta-data extraction strategy
public function write( string $key, array $data ): void;
Writes the metadata to adapter
final public function writeMetaDataIndex( ModelInterface $model, int $index, mixed $data ): void;
Writes meta-data for certain model using a MODEL_* constant
print_r(
$metaData->writeColumnMapIndex(
new Robots(),
MetaData::MODELS_REVERSE_COLUMN_MAP,
[
"leName" => "name",
]
)
);
protected function getArrVal( array $collection, mixed $index, mixed $defaultValue = null ): mixed;
@todo Remove this when we get traits
final protected function initialize( ModelInterface $model, mixed $key, mixed $table, mixed $schema );
Initialize old behaviour for compatability
final protected function initializeColumnMap( ModelInterface $model, mixed $key ): bool;
Initialize ColumnMap for a certain table
final protected function initializeMetaData( ModelInterface $model, mixed $key ): bool;
Initialize the metadata for certain table
| Namespace | Phalcon\Mvc\Model\MetaData | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception, Phalcon\Cache\AdapterFactory | Extends | MetaData |
Phalcon\Mvc\Model\MetaData\Apcu
Stores model meta-data in the APCu cache. Data will erased if the web server is restarted
By default meta-data is stored for 48 hours (172800 seconds)
You can query the meta-data by printing apcu_fetch(‘$PMM$’) or apcu_fetch(‘$PMM$my-app-id’)
$metaData = new \Phalcon\Mvc\Model\MetaData\Apcu(
[
"prefix" => "my-app-id",
"lifetime" => 86400,
]
);
public function __construct( AdapterFactory $factory, array $options = null );
Phalcon\Mvc\Model\MetaData\Apcu constructor
| Namespace | Phalcon\Mvc\Model\MetaData | Uses | Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\MetaData, Phalcon\Cache\AdapterFactory | Extends | MetaData |
Phalcon\Mvc\Model\MetaData\Libmemcached
Stores model meta-data in the Memcache.
By default meta-data is stored for 48 hours (172800 seconds)
public function __construct( AdapterFactory $factory, array $options = [] );
Phalcon\Mvc\Model\MetaData\Libmemcached constructor
public function reset(): void;
Flush Memcache data and resets internal meta-data in order to regenerate it
| Namespace | Phalcon\Mvc\Model\MetaData | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception | Extends | MetaData |
Phalcon\Mvc\Model\MetaData\Memory
Stores model meta-data in memory. Data will be erased when the request finishes
public function __construct( mixed $options = null );
Phalcon\Mvc\Model\MetaData\Memory constructor
public function read( string $key ): array | null;
Reads the meta-data from temporal memory
public function write( string $key, array $data ): void;
Writes the meta-data to temporal memory
| Namespace | Phalcon\Mvc\Model\MetaData | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Cache\AdapterFactory | Extends | MetaData |
Phalcon\Mvc\Model\MetaData\Redis
Stores model meta-data in the Redis.
By default meta-data is stored for 48 hours (172800 seconds)
use Phalcon\Mvc\Model\MetaData\Redis;
$metaData = new Redis(
[
"host" => "127.0.0.1",
"port" => 6379,
"persistent" => 0,
"lifetime" => 172800,
"index" => 2,
]
);
public function __construct( AdapterFactory $factory, array $options = [] );
Phalcon\Mvc\Model\MetaData\Redis constructor
public function reset(): void;
Flush Redis data and resets internal meta-data in order to regenerate it
| Namespace | Phalcon\Mvc\Model\MetaData\Strategy | Uses | Phalcon\Di\DiInterface, Phalcon\Db\Column, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception | Implements | StrategyInterface |
This file is part of the Phalcon Framework.
(c) Phalcon Team [email protected]
For the full copyright and license information, please view the LICENSE.txt file that was distributed with this source code.
final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;
Read the model’s column map, this can’t be inferred
final public function getMetaData( ModelInterface $model, DiInterface $container ): array;
The meta-data is obtained by reading the column descriptions from the database information schema
| Namespace | Phalcon\Mvc\Model\MetaData\Strategy | Uses | Phalcon\Di\DiInterface, Phalcon\Db\Adapter\AdapterInterface, Phalcon\Db\Column, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\MetaData | Implements | StrategyInterface |
Phalcon\Mvc\Model\MetaData\Strategy\Introspection
Queries the table meta-data in order to introspect the model’s metadata
final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;
Read the model’s column map, this can’t be inferred
final public function getMetaData( ModelInterface $model, DiInterface $container ): array;
The meta-data is obtained by reading the column descriptions from the database information schema
| Namespace | Phalcon\Mvc\Model\MetaData\Strategy | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Di\DiInterface |
This file is part of the Phalcon Framework.
(c) Phalcon Team [email protected]
For the full copyright and license information, please view the LICENSE.txt file that was distributed with this source code.
public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;
Read the model’s column map, this can’t be inferred
@todo Not implemented
public function getMetaData( ModelInterface $model, DiInterface $container ): array;
The meta-data is obtained by reading the column descriptions from the database information schema
| Namespace | Phalcon\Mvc\Model\MetaData | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception | Extends | MetaData |
Phalcon\Mvc\Model\MetaData\Stream
Stores model meta-data in PHP files.
$metaData = new \Phalcon\Mvc\Model\MetaData\Files(
[
"metaDataDir" => "app/cache/metadata/",
]
);
/**
* @var string
*/
protected metaDataDir = ./;
public function __construct( array $options = [] );
Phalcon\Mvc\Model\MetaData\Files constructor
public function read( string $key ): array | null;
Reads meta-data from files
public function write( string $key, array $data ): void;
Writes the meta-data to files
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface |
Phalcon\Mvc\Model\MetaDataInterface
Interface for Phalcon\Mvc\Model\MetaData
public function getAttributes( ModelInterface $model ): array;
Returns table attributes names (fields)
public function getAutomaticCreateAttributes( ModelInterface $model ): array;
Returns attributes that must be ignored from the INSERT SQL generation
public function getAutomaticUpdateAttributes( ModelInterface $model ): array;
Returns attributes that must be ignored from the UPDATE SQL generation
public function getBindTypes( ModelInterface $model ): array;
Returns attributes and their bind data types
public function getColumnMap( ModelInterface $model ): array | null;
Returns the column map if any
public function getDataTypes( ModelInterface $model ): array;
Returns attributes and their data types
public function getDataTypesNumeric( ModelInterface $model ): array;
Returns attributes which types are numerical
public function getDefaultValues( ModelInterface $model ): array;
Returns attributes (which have default values) and their default values
public function getEmptyStringAttributes( ModelInterface $model ): array;
Returns attributes allow empty strings
public function getIdentityField( ModelInterface $model ): string | null;
Returns the name of identity field (if one is present)
public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;
Returns an array of fields which are not part of the primary key
public function getNotNullAttributes( ModelInterface $model ): array;
Returns an array of not null attributes
public function getPrimaryKeyAttributes( ModelInterface $model ): array;
Returns an array of fields which are part of the primary key
public function getReverseColumnMap( ModelInterface $model ): array | null;
Returns the reverse column map if any
public function getStrategy(): StrategyInterface;
Return the strategy to obtain the meta-data
public function hasAttribute( ModelInterface $model, string $attribute ): bool;
Check if a model has certain attribute
public function isEmpty(): bool;
Checks if the internal meta-data container is empty
public function read( string $key ): array | null;
Reads meta-data from the adapter
public function readColumnMap( ModelInterface $model ): array | null;
Reads the ordered/reversed column map for certain model
public function readColumnMapIndex( ModelInterface $model, int $index ): array | null;
Reads column-map information for certain model using a MODEL_* constant
public function readMetaData( ModelInterface $model ): array | null;
Reads meta-data for certain model
public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;
Reads meta-data for certain model using a MODEL_* constant
public function reset();
Resets internal meta-data in order to regenerate it
public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes );
Set the attributes that must be ignored from the INSERT SQL generation
public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes );
Set the attributes that must be ignored from the UPDATE SQL generation
public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void;
Set the attributes that allow empty string values
public function setStrategy( StrategyInterface $strategy );
Set the meta-data extraction strategy
public function write( string $key, array $data ): void;
Writes meta-data to the adapter
public function writeMetaDataIndex( ModelInterface $model, int $index, mixed $data );
Writes meta-data for certain model using a MODEL_* constant
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Db\Column, Phalcon\Db\RawValue, Phalcon\Db\ResultInterface, Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Query\Status, Phalcon\Mvc\Model\Resultset\Complex, Phalcon\Mvc\Model\Query\StatusInterface, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Resultset\Simple, Phalcon\Di\InjectionAwareInterface, Phalcon\Db\DialectInterface, Phalcon\Mvc\Model\Query\Lang | Implements | QueryInterface, InjectionAwareInterface |
Phalcon\Mvc\Model\Query
This class takes a PHQL intermediate representation and executes it.
$phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
WHERE b.name = :name: ORDER BY c.name";
$result = $manager->executeQuery(
$phql,
[
"name" => "Lamborghini",
]
);
foreach ($result as $row) {
echo "Name: ", $row->cars->name, "\n";
echo "Price: ", $row->cars->price, "\n";
echo "Taxes: ", $row->taxes, "\n";
}
// with transaction
use Phalcon\Mvc\Model\Query;
use Phalcon\Mvc\Model\Transaction;
// $di needs to have the service "db" registered for this to work
$di = Phalcon\Di\FactoryDefault::getDefault();
$phql = 'SELECTFROM robot';
$myTransaction = new Transaction($di);
$myTransaction->begin();
$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);
$newRobot->type = "mechanical";
$newRobot->name = "Astro Boy";
$newRobot->year = 1952;
$newRobot->save();
$queryWithTransaction = new Query($phql, $di);
$queryWithTransaction->setTransaction($myTransaction);
$resultWithEntries = $queryWithTransaction->execute();
$queryWithOutTransaction = new Query($phql, $di);
$resultWithOutEntries = $queryWithTransaction->execute();
const TYPE_DELETE = 303;
const TYPE_INSERT = 306;
const TYPE_SELECT = 309;
const TYPE_UPDATE = 300;
/**
* @var array
* TODO: Add default value, instead of null, also remove type check
*/
protected ast;
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var mixed|null
*/
protected cache;
/**
* @var array|null
*/
protected cacheOptions;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var bool
*/
protected enableImplicitJoins;
/**
* @var array
*/
protected intermediate;
/**
* @var \Phalcon\Mvc\Model\ManagerInterface|null
*/
protected manager;
/**
* @var \Phalcon\Mvc\Model\MetaDataInterface|null
*/
protected metaData;
/**
* @var array
*/
protected models;
/**
* @var array
*/
protected modelsInstances;
/**
* @var int
*/
protected nestingLevel = -1;
/**
* @var string|null
*/
protected phql;
/**
* @var bool
*/
protected sharedLock = false;
/**
* @var array
*/
protected sqlAliases;
/**
* @var array
*/
protected sqlAliasesModels;
/**
* @var array
*/
protected sqlAliasesModelsInstances;
/**
* @var array
*/
protected sqlColumnAliases;
/**
* @var array
*/
protected sqlModelsAliases;
/**
* @var int|null
*/
protected type;
/**
* @var bool
*/
protected uniqueRow = false;
/**
* TransactionInterface so that the query can wrap a transaction
* around batch updates and intermediate selects within the transaction.
* however if a model got a transaction set inside it will use the local
* transaction instead of this one
*
* @var TransactionInterface|null
*/
protected transaction;
/**
* @var array|null
*/
protected static internalPhqlCache;
public function __construct( string $phql = null, DiInterface $container = null, array $options = [] );
Phalcon\Mvc\Model\Query constructor
public function cache( array $cacheOptions ): QueryInterface;
Sets the cache parameters of the query
public static function clean(): void;
Destroys the internal PHQL cache
public function execute( array $bindParams = [], array $bindTypes = [] );
Executes a parsed PHQL statement
public function getBindParams(): array;
Returns default bind params
public function getBindTypes(): array;
Returns default bind types
public function getCache(): AdapterInterface;
Returns the current cache backend instance
public function getCacheOptions(): array;
Returns the current cache options
public function getDI(): DiInterface;
Returns the dependency injection container
public function getIntermediate(): array;
Returns the intermediate representation of the PHQL statement
public function getSingleResult( array $bindParams = [], array $bindTypes = [] ): ModelInterface;
Executes the query returning the first result
public function getSql(): array;
Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
public function getTransaction(): TransactionInterface | null;
public function getType(): int;
Gets the type of PHQL statement executed
public function getUniqueRow(): bool;
Check if the query is programmed to get only the first row in the resultset
public function parse(): array;
Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query
public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;
Set default bind parameters
public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;
Set default bind parameters
public function setDI( DiInterface $container ): void;
Sets the dependency injection container
public function setIntermediate( array $intermediate ): QueryInterface;
Allows to set the IR to be executed
public function setSharedLock( bool $sharedLock = bool ): QueryInterface;
Set SHARED LOCK clause
public function setTransaction( TransactionInterface $transaction ): QueryInterface;
allows to wrap a transaction around all queries
public function setType( int $type ): QueryInterface;
Sets the type of PHQL statement to be executed
public function setUniqueRow( bool $uniqueRow ): QueryInterface;
Tells to the query if only the first row in the resultset must be returned
final protected function _prepareDelete(): array;
Analyzes a DELETE intermediate code and produces an array to be executed later
final protected function _prepareInsert(): array;
Analyzes an INSERT intermediate code and produces an array to be executed later
final protected function _prepareSelect( mixed $ast = null, bool $merge = bool ): array;
Analyzes a SELECT intermediate code and produces an array to be executed later
final protected function _prepareUpdate(): array;
Analyzes an UPDATE intermediate code and produces an array to be executed later
final protected function executeDelete( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;
Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
final protected function executeInsert( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;
Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status
final protected function executeSelect( array $intermediate, array $bindParams, array $bindTypes, bool $simulate = bool ): ResultsetInterface | array;
Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset
final protected function executeUpdate( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;
Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
final protected function getCallArgument( array $argument ): array;
Resolves an expression in a single call argument
final protected function getCaseExpression( array $expr ): array;
Resolves an expression in a single call argument
final protected function getExpression( array $expr, bool $quoting = bool ): array;
Resolves an expression from its intermediate code into an array
final protected function getFunctionCall( array $expr ): array;
Resolves an expression in a single call argument
final protected function getGroupClause( array $group ): array;
Returns a processed group clause for a SELECT statement
final protected function getJoin( ManagerInterface $manager, array $join ): array;
Resolves a JOIN clause checking if the associated models exist
final protected function getJoinType( array $join ): string;
Resolves a JOIN type
final protected function getJoins( array $select ): array;
Processes the JOINs in the query returning an internal representation for the database dialect
final protected function getLimitClause( array $limitClause ): array;
Returns a processed limit clause for a SELECT statement
final protected function getMultiJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;
Resolves joins involving many-to-many relations
final protected function getOrderClause( mixed $order ): array;
Returns a processed order clause for a SELECT statement
final protected function getQualified( array $expr ): array;
Replaces the model’s name to its source name in a qualified-name expression
protected function getReadConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;
Gets the read connection from the model if there is no transaction set inside the query object
final protected function getRelatedRecords( ModelInterface $model, array $intermediate, array $bindParams, array $bindTypes ): ResultsetInterface;
Query the records on which the UPDATE/DELETE operation will be done
final protected function getSelectColumn( array $column ): array;
Resolves a column from its intermediate representation into an array used to determine if the resultset produced is simple or complex
final protected function getSingleJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;
Resolves joins involving has-one/belongs-to/has-many relations
final protected function getTable( ManagerInterface $manager, array $qualifiedName );
Resolves a table in a SELECT statement checking if the model exists
protected function getWriteConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;
Gets the write connection from the model if there is no transaction inside the query object
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Di\Di, Phalcon\Db\Column, Phalcon\Di\DiInterface, Phalcon\Mvc\Model\Exception, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\QueryInterface | Implements | BuilderInterface, InjectionAwareInterface |
Phalcon\Mvc\Model\Query\Builder
Helps to create PHQL queries using an OO interface
$params = [
"models" => [
Users::class,
],
"columns" => ["id", "name", "status"],
"conditions" => [
[
"created > :min: AND created < :max:",
[
"min" => "2013-01-01",
"max" => "2014-01-01",
],
[
"min" => PDO::PARAM_STR,
"max" => PDO::PARAM_STR,
],
],
],
// or "conditions" => "created > '2013-01-01' AND created < '2014-01-01'",
"group" => ["id", "name"],
"having" => "name = 'Kamil'",
"order" => ["name", "id"],
"limit" => 20,
"offset" => 20,
// or "limit" => [20, 20],
];
$queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var array|string|null
*/
protected columns;
/**
* @var array|string|null
*/
protected conditions;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var mixed
*/
protected distinct;
/**
* @var bool
*/
protected forUpdate = false;
/**
* @var array
*/
protected group;
/**
* @var string|null
*/
protected having;
/**
* @var int
*/
protected hiddenParamNumber = 0;
/**
* @var array
*/
protected joins;
/**
* @var array|string
*/
protected limit;
/**
* @var array|string
*/
protected models;
/**
* @var int
*/
protected offset = 0;
/**
* @var array|string
*/
protected order;
/**
* @var bool
*/
protected sharedLock = false;
public function __construct( mixed $params = null, DiInterface $container = null );
Phalcon\Mvc\Model\Query\Builder constructor
public function addFrom( string $model, string $alias = null ): BuilderInterface;
Add a model to take part of the query
// Load data from models Robots
$builder->addFrom(
Robots::class
);
// Load data from model 'Robots' using 'r' as alias in PHQL
$builder->addFrom(
Robots::class,
"r"
);
public function andHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current HAVING conditions clause using a AND operator
$builder->andHaving("SUM(Robots.price) > 0");
$builder->andHaving(
"SUM(Robots.price) > :sum:",
[
"sum" => 100,
]
);
public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current WHERE conditions using a AND operator
$builder->andWhere("name = 'Peter'");
$builder->andWhere(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
final public function autoescape( string $identifier ): string;
Automatically escapes identifiers but only if they need to be escaped.
public function betweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a BETWEEN condition to the current HAVING conditions clause
$builder->betweenHaving("SUM(Robots.price)", 100.25, 200.50);
public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a BETWEEN condition to the current WHERE conditions
$builder->betweenWhere("price", 100.25, 200.50);
public function columns( mixed $columns ): BuilderInterface;
Sets the columns to be queried
$builder->columns("id, name");
$builder->columns(
[
"id",
"name",
]
);
$builder->columns(
[
"name",
"number" => "COUNT(*)",
]
);
public function distinct( mixed $distinct ): BuilderInterface;
Sets SELECT DISTINCT / SELECT ALL flag
$builder->distinct("status");
$builder->distinct(null);
public function forUpdate( bool $forUpdate ): BuilderInterface;
Sets a FOR UPDATE clause
$builder->forUpdate(true);
public function from( mixed $models ): BuilderInterface;
Sets the models who makes part of the query
$builder->from(
Robots::class
);
$builder->from(
[
Robots::class,
RobotsParts::class,
]
);
$builder->from(
[
"r" => Robots::class,
"rp" => RobotsParts::class,
]
);
public function getBindParams(): array;
Returns default bind params
public function getBindTypes(): array;
Returns default bind types
public function getColumns();
Return the columns to be queried
public function getDI(): DiInterface;
Returns the DependencyInjector container
public function getDistinct(): bool;
Returns SELECT DISTINCT / SELECT ALL flag
public function getFrom();
Return the models who makes part of the query
public function getGroupBy(): array;
Returns the GROUP BY clause
public function getHaving(): string;
Return the current having clause
public function getJoins(): array;
Return join parts of the query
public function getLimit();
Returns the current LIMIT clause
public function getModels(): string | array | null;
Returns the models involved in the query
public function getOffset(): int;
Returns the current OFFSET clause
public function getOrderBy();
Returns the set ORDER BY clause
final public function getPhql(): string;
Returns a PHQL statement built based on the builder parameters
public function getQuery(): QueryInterface;
Returns the query built
public function getWhere();
Return the conditions for the query
public function groupBy( mixed $group ): BuilderInterface;
Sets a GROUP BY clause
$builder->groupBy(
[
"Robots.name",
]
);
public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Sets the HAVING condition clause
$builder->having("SUM(Robots.price) > 0");
$builder->having(
"SUM(Robots.price) > :sum:",
[
"sum" => 100,
]
);
public function inHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends an IN condition to the current HAVING conditions clause
$builder->inHaving("SUM(Robots.price)", [100, 200]);
public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends an IN condition to the current WHERE conditions
$builder->inWhere(
"id",
[1, 2, 3]
);
public function innerJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds an INNER join to the query
// Inner Join model 'Robots' with automatic conditions and alias
$builder->innerJoin(
Robots::class
);
// Inner Join model 'Robots' specifying conditions
$builder->innerJoin(
Robots::class,
"Robots.id = RobotsParts.robots_id"
);
// Inner Join model 'Robots' specifying conditions and alias
$builder->innerJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function join( string $model, string $conditions = null, string $alias = null, string $type = null ): BuilderInterface;
Adds an :type: join (by default type - INNER) to the query
// Inner Join model 'Robots' with automatic conditions and alias
$builder->join(
Robots::class
);
// Inner Join model 'Robots' specifying conditions
$builder->join(
Robots::class,
"Robots.id = RobotsParts.robots_id"
);
// Inner Join model 'Robots' specifying conditions and alias
$builder->join(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
// Left Join model 'Robots' specifying conditions, alias and type of join
$builder->join(
Robots::class,
"r.id = RobotsParts.robots_id",
"r",
"LEFT"
);
public function leftJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds a LEFT join to the query
$builder->leftJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function limit( int $limit, mixed $offset = null ): BuilderInterface;
Sets a LIMIT clause, optionally an offset clause
$builder->limit(100);
$builder->limit(100, 20);
$builder->limit("100", "20");
public function notBetweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT BETWEEN condition to the current HAVING conditions clause
$builder->notBetweenHaving("SUM(Robots.price)", 100.25, 200.50);
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT BETWEEN condition to the current WHERE conditions
$builder->notBetweenWhere("price", 100.25, 200.50);
public function notInHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT IN condition to the current HAVING conditions clause
$builder->notInHaving("SUM(Robots.price)", [100, 200]);
public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT IN condition to the current WHERE conditions
$builder->notInWhere("id", [1, 2, 3]);
public function offset( int $offset ): BuilderInterface;
Sets an OFFSET clause
$builder->offset(30);
public function orHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current HAVING conditions clause using an OR operator
$builder->orHaving("SUM(Robots.price) > 0");
$builder->orHaving(
"SUM(Robots.price) > :sum:",
[
"sum" => 100,
]
);
public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current conditions using an OR operator
$builder->orWhere("name = 'Peter'");
$builder->orWhere(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
public function orderBy( mixed $orderBy ): BuilderInterface;
Sets an ORDER BY condition clause
$builder->orderBy("Robots.name");
$builder->orderBy(["1", "Robots.name"]);
$builder->orderBy(["Robots.name DESC"]);
public function rightJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds a RIGHT join to the query
$builder->rightJoin(
Robots::class,
"r.id = RobotsParts.robots_id",
"r"
);
public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;
Set default bind parameters
public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;
Set default bind types
public function setDI( DiInterface $container ): void;
Sets the DependencyInjector container
public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Sets the query WHERE conditions
$builder->where(100);
$builder->where("name = 'Peter'");
$builder->where(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
protected function conditionBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;
Appends a BETWEEN condition
protected function conditionIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;
Appends an IN condition
protected function conditionNotBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;
Appends a NOT BETWEEN condition
protected function conditionNotIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;
Appends a NOT IN condition
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Mvc\Model\QueryInterface |
Phalcon\Mvc\Model\Query\BuilderInterface
Interface for Phalcon\Mvc\Model\Query\Builder
const OPERATOR_AND = and;
const OPERATOR_OR = or;
public function addFrom( string $model, string $alias = null ): BuilderInterface;
Add a model to take part of the query
public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current conditions using a AND operator
public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a BETWEEN condition to the current conditions
public function columns( mixed $columns ): BuilderInterface;
Sets the columns to be queried
public function distinct( mixed $distinct ): BuilderInterface;
Sets SELECT DISTINCT / SELECT ALL flag
$builder->distinct("status");
$builder->distinct(null);
public function forUpdate( bool $forUpdate ): BuilderInterface;
Sets a FOR UPDATE clause
$builder->forUpdate(true);
public function from( mixed $models ): BuilderInterface;
Sets the models who makes part of the query
public function getBindParams(): array;
Returns default bind params
public function getBindTypes(): array;
Returns default bind types
public function getColumns();
Return the columns to be queried
public function getDistinct(): bool;
Returns SELECT DISTINCT / SELECT ALL flag
public function getFrom();
Return the models who makes part of the query
public function getGroupBy(): array;
Returns the GROUP BY clause
public function getHaving(): string;
Returns the HAVING condition clause
public function getJoins(): array;
Return join parts of the query
public function getLimit();
Returns the current LIMIT clause
public function getModels(): string | array | null;
Returns the models involved in the query
public function getOffset(): int;
Returns the current OFFSET clause
public function getOrderBy();
Return the set ORDER BY clause
public function getPhql(): string;
Returns a PHQL statement built based on the builder parameters
public function getQuery(): QueryInterface;
Returns the query built
public function getWhere();
Return the conditions for the query
public function groupBy( mixed $group ): BuilderInterface;
Sets a GROUP BY clause
public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Sets a HAVING condition clause
public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends an IN condition to the current conditions
public function innerJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds an INNER join to the query
public function join( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds an :type: join (by default type - INNER) to the query
public function leftJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds a LEFT join to the query
public function limit( int $limit, mixed $offset = null ): BuilderInterface;
Sets a LIMIT clause
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT BETWEEN condition to the current conditions
public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;
Appends a NOT IN condition to the current conditions
public function offset( int $offset ): BuilderInterface;
Sets an OFFSET clause
public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Appends a condition to the current conditions using an OR operator
public function orderBy( mixed $orderBy ): BuilderInterface;
Sets an ORDER BY condition clause
public function rightJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;
Adds a RIGHT join to the query
public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;
Set default bind parameters
public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;
Set default bind types
public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;
Sets conditions for the query
| Namespace | Phalcon\Mvc\Model\Query |
Phalcon\Mvc\Model\Query\Lang
PHQL is implemented as a parser (written in C) that translates syntax in that of the target RDBMS. It allows Phalcon to offer a unified SQL language to the developer, while internally doing all the work of translating PHQL instructions to the most optimal SQL instructions depending on the RDBMS type associated with a model.
To achieve the highest performance possible, we wrote a parser that uses the same technology as SQLite. This technology provides a small in-memory parser with a very low memory footprint that is also thread-safe.
use Phalcon\Mvc\Model\Query\Lang;
$intermediate = Lang::parsePHQL(
"SELECT r.* FROM Robots r LIMIT 10"
);
public static function parsePHQL( string $phql ): array;
Parses a PHQL statement returning an intermediate representation (IR)
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface | Implements | StatusInterface |
Phalcon\Mvc\Model\Query\Status
This class represents the status returned by a PHQL statement like INSERT, UPDATE or DELETE. It offers context information and the related messages produced by the model which finally executes the operations when it fails
$phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
$status = $app->modelsManager->executeQuery(
$phql,
[
"id" => 100,
"name" => "Astroy Boy",
"type" => "mechanical",
"year" => 1959,
]
);
// Check if the update was successful
if ($status->success()) {
echo "OK";
}
/**
* @var ModelInterface|null
*/
protected model;
/**
* @var bool
*/
protected success;
public function __construct( bool $success, ModelInterface $model = null );
Phalcon\Mvc\Model\Query\Status
public function getMessages(): MessageInterface[];
Returns the messages produced because of a failed operation
public function getModel(): ModelInterface;
Returns the model that executed the action
public function success(): bool;
Allows to check if the executed operation was successful
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\Query\StatusInterface
Interface for Phalcon\Mvc\Model\Query\Status
public function getMessages(): MessageInterface[];
Returns the messages produced by an operation failed
public function getModel(): ModelInterface;
Returns the model which executed the action
public function success(): bool;
Allows to check if the executed operation was successful
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\QueryInterface
Interface for Phalcon\Mvc\Model\Query
public function cache( array $cacheOptions ): QueryInterface;
Sets the cache parameters of the query
public function execute( array $bindParams = [], array $bindTypes = [] );
Executes a parsed PHQL statement
public function getBindParams(): array;
Returns default bind params
public function getBindTypes(): array;
Returns default bind types
public function getCacheOptions(): array;
Returns the current cache options
public function getSingleResult( array $bindParams = [], array $bindTypes = [] ): ModelInterface;
Executes the query returning the first result
public function getSql(): array;
Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
public function getUniqueRow(): bool;
Check if the query is programmed to get only the first row in the resultset
public function parse(): array;
Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query
public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;
Set default bind parameters
public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;
Set default bind parameters
public function setSharedLock( bool $sharedLock = bool ): QueryInterface;
Set SHARED LOCK clause
public function setUniqueRow( bool $uniqueRow ): QueryInterface;
Tells to the query if only the first row in the resultset must be returned
| Namespace | Phalcon\Mvc\Model | Implements | RelationInterface |
Phalcon\Mvc\Model\Relation
This class represents a relationship between two models
const ACTION_CASCADE = 2;
const ACTION_RESTRICT = 1;
const BELONGS_TO = 0;
const HAS_MANY = 2;
const HAS_MANY_THROUGH = 4;
const HAS_ONE = 1;
const HAS_ONE_THROUGH = 3;
const NO_ACTION = 0;
/**
* @var array|string
*/
protected fields;
/**
* @var array|string
*/
protected intermediateFields;
/**
* @var string|null
*/
protected intermediateModel;
/**
* @var array|string
*/
protected intermediateReferencedFields;
/**
* @var array
*/
protected options;
/**
* @var array|string
*/
protected referencedFields;
/**
* @var string
*/
protected referencedModel;
/**
* @var int
*/
protected type;
public function __construct( int $type, string $referencedModel, mixed $fields, mixed $referencedFields, array $options = [] );
Phalcon\Mvc\Model\Relation constructor
public function getFields();
Returns the fields
public function getForeignKey();
Returns the foreign key configuration
public function getIntermediateFields();
Gets the intermediate fields for has-*-through relations
public function getIntermediateModel(): string;
Gets the intermediate model for has-*-through relations
public function getIntermediateReferencedFields();
Gets the intermediate referenced fields for has-*-through relations
public function getOption( string $name );
Returns an option by the specified name If the option doesn’t exist null is returned
public function getOptions(): array;
Returns the options
public function getParams();
Returns parameters that must be always used when the related records are obtained
public function getReferencedFields();
Returns the referenced fields
public function getReferencedModel(): string;
Returns the referenced model
public function getType(): int;
Returns the relation type
public function isForeignKey(): bool;
Check whether the relation act as a foreign key
public function isReusable(): bool;
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
public function isThrough(): bool;
Check whether the relation is a ‘many-to-many’ relation or not
public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );
Sets the intermediate model data for has-*-through relations
| Namespace | Phalcon\Mvc\Model |
Phalcon\Mvc\Model\RelationInterface
Interface for Phalcon\Mvc\Model\Relation
public function getFields();
Returns the fields
public function getForeignKey();
Returns the foreign key configuration
public function getIntermediateFields();
Gets the intermediate fields for has-*-through relations
public function getIntermediateModel(): string;
Gets the intermediate model for has-*-through relations
public function getIntermediateReferencedFields();
Gets the intermediate referenced fields for has-*-through relations
public function getOption( string $name );
Returns an option by the specified name If the option doesn’t exist null is returned
public function getOptions(): array;
Returns the options
public function getParams();
Returns parameters that must be always used when the related records are obtained
public function getReferencedFields();
Returns the referenced fields
public function getReferencedModel(): string;
Returns the referenced model
public function getType(): int;
Returns the relations type
public function isForeignKey(): bool;
Check whether the relation act as a foreign key
public function isReusable(): bool;
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
public function isThrough(): bool;
Check whether the relation is a ‘many-to-many’ relation or not
public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );
Sets the intermediate model data for has-*-through relations
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\ResultInterface
All single objects passed as base objects to Resultsets must implement this interface
public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Sets the object’s state
| Namespace | Phalcon\Mvc\Model | Uses | ArrayAccess, Closure, Countable, Iterator, JsonSerializable, Phalcon\Cache\CacheInterface, Phalcon\Db\Enum, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface, SeekableIterator, Serializable | Implements | ResultsetInterface, Iterator, SeekableIterator, Countable, ArrayAccess, Serializable, JsonSerializable |
Phalcon\Mvc\Model\Resultset
This component allows to Phalcon\Mvc\Model returns large resultsets with the minimum memory consumption Resultsets can be traversed using a standard foreach or a while statement. If a resultset is serialized it will dump all the rows into a big array. Then unserialize will retrieve the rows as they were before serializing.
// Using a standard foreach
$robots = Robots::find(
[
"type = 'virtual'",
"order" => "name",
]
);
foreach ($robots as robot) {
echo robot->name, "\n";
}
// Using a while
$robots = Robots::find(
[
"type = 'virtual'",
"order" => "name",
]
);
$robots->rewind();
while ($robots->valid()) {
$robot = $robots->current();
echo $robot->name, "\n";
$robots->next();
}
const HYDRATE_ARRAYS = 1;
const HYDRATE_OBJECTS = 2;
const HYDRATE_RECORDS = 0;
const TYPE_RESULT_FULL = 0;
const TYPE_RESULT_PARTIAL = 1;
/**
* @var mixed|null
*/
protected activeRow;
/**
* @var CacheInterface|null
*/
protected cache;
/**
* @var int
*/
protected count = 0;
/**
* @var array
*/
protected errorMessages;
/**
* @var int
*/
protected hydrateMode = 0;
/**
* @var bool
*/
protected isFresh = true;
/**
* @var int
*/
protected pointer = 0;
/**
* @var mixed|null
*/
protected row;
/**
* @var array|null
*/
protected rows;
/**
* Phalcon\Db\ResultInterface or false for empty resultset
*
* @var ResultInterface|bool
*/
protected result;
public function __construct( mixed $result, mixed $cache = null );
Phalcon\Mvc\Model\Resultset constructor
final public function count(): int;
Counts how many rows are in the resultset
public function delete( Closure $conditionCallback = null ): bool;
Deletes every record in the resultset
public function filter( callable $filter ): ModelInterface[];
Filters a resultset returning only those the developer requires
$filtered = $robots->filter(
function ($robot) {
if ($robot->id < 3) {
return $robot;
}
}
);
public function getCache(): CacheInterface | null;
Returns the associated cache for the resultset
public function getFirst(): mixed | null;
Get first row in the resultset
$model = new Robots();
$manager = $model->getModelsManager();
// \Robots
$manager->createQuery('SELECTFROM Robots')
->execute()
->getFirst();
// \Phalcon\Mvc\Model\Row
$manager->createQuery('SELECT r.id FROM Robots AS r')
->execute()
->getFirst();
// NULL
$manager->createQuery('SELECT r.id FROM Robots AS r WHERE r.name = "NON-EXISTENT"')
->execute()
->getFirst();
public function getHydrateMode(): int;
Returns the current hydration mode
public function getLast(): ModelInterface | null;
Get last row in the resultset
public function getMessages(): MessageInterface[];
Returns the error messages produced by a batch operation
public function getType(): int;
Returns the internal type of data retrieval that the resultset is using
public function isFresh(): bool;
Tell if the resultset if fresh or an old one cached
public function jsonSerialize(): array;
Returns serialised model objects as array for json_encode. Calls jsonSerialize on each object if present
$robots = Robots::find();
echo json_encode($robots);
public function key(): int | null;
Gets pointer number of active row in the resultset
public function next(): void;
Moves cursor to next row in the resultset
public function offsetExists( mixed $index ): bool;
Checks whether offset exists in the resultset
public function offsetGet( mixed $index ): mixed;
Gets row in a specific position of the resultset
public function offsetSet( mixed $index, mixed $value ): void;
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
public function offsetUnset( mixed $offset ): void;
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
final public function rewind(): void;
Rewinds resultset to its beginning
final public function seek( mixed $position ): void;
Changes the internal pointer to a specific position in the resultset. Set the new position if required, and then set this->row
public function setHydrateMode( int $hydrateMode ): ResultsetInterface;
Sets the hydration mode in the resultset
public function setIsFresh( bool $isFresh ): ResultsetInterface;
Set if the resultset is fresh or an old one cached
public function update( mixed $data, Closure $conditionCallback = null ): bool;
Updates every record in the resultset
public function valid(): bool;
Check whether internal resource has rows to fetch
| Namespace | Phalcon\Mvc\Model\Resultset | Uses | Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Db\ResultInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface, stdClass | Extends | Resultset | Implements | ResultsetInterface |
Phalcon\Mvc\Model\Resultset\Complex
Complex resultsets may include complete objects and scalar values. This class builds every complex row as it is required
/**
* @var array
*/
protected columnTypes;
/**
* Unserialised result-set hydrated all rows already. unserialise() sets
* disableHydration to true
*
* @var bool
*/
protected disableHydration = false;
public function __construct( mixed $columnTypes, ResultInterface $result = null, mixed $cache = null );
Phalcon\Mvc\Model\Resultset\Complex constructor
public function __serialize(): array;
public function __unserialize( array $data ): void;
final public function current(): mixed;
Returns current row in the resultset
public function serialize(): string;
Serializing a resultset will dump all related rows into a big array
public function toArray(): array;
Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.
public function unserialize( mixed $data ): void;
Unserializing a resultset will allow to only works on the rows present in the saved state
| Namespace | Phalcon\Mvc\Model\Resultset | Uses | Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface | Extends | Resultset |
Phalcon\Mvc\Model\Resultset\Simple
Simple resultsets only contains a complete objects This class builds every complete object as it is required
/**
* @var array|string
*/
protected columnMap;
/**
* @var ModelInterface|Row
*/
protected model;
/**
* @var bool
*/
protected keepSnapshots = false;
public function __construct( mixed $columnMap, mixed $model, mixed $result, mixed $cache = null, bool $keepSnapshots = bool );
Phalcon\Mvc\Model\Resultset\Simple constructor
public function __serialize(): array;
public function __unserialize( array $data ): void;
final public function current(): ModelInterface | null;
Returns current row in the resultset
public function serialize(): string;
Serializing a resultset will dump all related rows into a big array
public function toArray( bool $renameColumns = bool ): array;
Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does. Export the resultset to an array couldn’t be faster with a large number of records
public function unserialize( mixed $data ): void;
Unserializing a resultset will allow to only works on the rows present in the saved state
| Namespace | Phalcon\Mvc\Model | Uses | Closure, Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\ResultsetInterface
Interface for Phalcon\Mvc\Model\Resultset
public function delete( Closure $conditionCallback = null ): bool;
Deletes every record in the resultset
public function filter( callable $filter ): ModelInterface[];
Filters a resultset returning only those the developer requires
$filtered = $robots->filter(
function ($robot) {
if ($robot->id < 3) {
return $robot;
}
}
);
public function getCache(): mixed | null;
Returns the associated cache for the resultset
public function getFirst(): mixed | null;
Get first row in the resultset
public function getHydrateMode(): int;
Returns the current hydration mode
public function getLast(): ModelInterface | null;
Get last row in the resultset
public function getMessages(): MessageInterface[];
Returns the error messages produced by a batch operation
public function getType(): int;
Returns the internal type of data retrieval that the resultset is using
public function isFresh(): bool;
Tell if the resultset if fresh or an old one cached
public function setHydrateMode( int $hydrateMode ): ResultsetInterface;
Sets the hydration mode in the resultset
public function setIsFresh( bool $isFresh ): ResultsetInterface;
Set if the resultset is fresh or an old one cached
public function toArray(): array;
Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.
public function update( mixed $data, Closure $conditionCallback = null ): bool;
Updates every record in the resultset
| Namespace | Phalcon\Mvc\Model | Uses | ArrayAccess, JsonSerializable, Phalcon\Mvc\EntityInterface, Phalcon\Mvc\ModelInterface | Extends | \stdClass | Implements | EntityInterface, ResultInterface, ArrayAccess, JsonSerializable |
This component allows Phalcon\Mvc\Model to return rows without an associated entity. This objects implements the ArrayAccess interface to allow access the object as object->x or array[x].
public function jsonSerialize(): array;
Serializes the object for json_encode
public function offsetExists( mixed $index ): bool;
Checks whether offset exists in the row
public function offsetGet( mixed $index ): mixed;
Gets a record in a specific position of the row
public function offsetSet( mixed $index, mixed $value ): void;
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
public function offsetUnset( mixed $offset ): void;
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
public function readAttribute( string $attribute );
Reads an attribute value by its name
echo $robot->readAttribute("name");
public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Set the current object’s state
public function toArray(): array;
Returns the instance as an array representation
public function writeAttribute( string $attribute, mixed $value ): void;
Writes an attribute value by its name
$robot->writeAttribute("name", "Rosey");
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\Failed, Phalcon\Mvc\Model\Transaction\ManagerInterface, Phalcon\Mvc\Model\TransactionInterface | Implements | TransactionInterface |
Phalcon\Mvc\Model\Transaction
Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. Phalcon\Transaction is intended to be used with Phalcon_Model_Base. Phalcon Transactions should be created using Phalcon\Transaction\Manager.
use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;
try {
$manager = new Manager();
$transaction = $manager->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("Can't save robot part");
}
$transaction->commit();
} catch(Failed $e) {
echo "Failed, reason: ", $e->getMessage();
}
/**
* @var bool
*/
protected activeTransaction = false;
/**
* @var AdapterInterface
*/
protected connection;
/**
* @var bool
*/
protected isNewTransaction = true;
/**
* @var ManagerInterface|null
*/
protected manager;
/**
* @var array
*/
protected messages;
/**
* @var ModelInterface|null
*/
protected rollbackRecord;
/**
* @var bool
*/
protected rollbackOnAbort = false;
/**
* @var bool
*/
protected rollbackThrowException = false;
public function __construct( DiInterface $container, bool $autoBegin = bool, string $service = string );
Phalcon\Mvc\Model\Transaction constructor
public function begin(): bool;
Starts the transaction
public function commit(): bool;
Commits the transaction
public function getConnection(): AdapterInterface;
Returns the connection related to transaction
public function getMessages(): array;
Returns validations messages from last save try
public function isManaged(): bool;
Checks whether transaction is managed by a transaction manager
public function isValid(): bool;
Checks whether internal connection is under an active transaction
public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;
Rollbacks the transaction
public function setIsNewTransaction( bool $isNew ): void;
Sets if is a reused transaction or new once
public function setRollbackOnAbort( bool $rollbackOnAbort ): void;
Sets flag to rollback on abort the HTTP connection
public function setRollbackedRecord( ModelInterface $record ): void;
Sets object which generates rollback action
public function setTransactionManager( ManagerInterface $manager ): void;
Sets transaction manager related to the transaction
public function throwRollbackException( bool $status ): TransactionInterface;
Enables throwing exception
| Namespace | Phalcon\Mvc\Model\Transaction | Extends | \Phalcon\Mvc\Model\Exception |
Phalcon\Mvc\Model\Transaction\Exception
Exceptions thrown in Phalcon\Mvc\Model\Transaction will use this class
| Namespace | Phalcon\Mvc\Model\Transaction | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface | Extends | Exception |
Phalcon\Mvc\Model\Transaction\Failed
This class will be thrown to exit a try/catch block for isolated transactions
/**
* @var ModelInterface|null
*/
protected record;
public function __construct( string $message, ModelInterface $record = null );
Phalcon\Mvc\Model\Transaction\Failed constructor
public function getRecord(): ModelInterface;
Returns validation record messages which stop the transaction
public function getRecordMessages(): MessageInterface[];
Returns validation record messages which stop the transaction
| Namespace | Phalcon\Mvc\Model\Transaction | Uses | Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\Transaction, Phalcon\Mvc\Model\TransactionInterface | Implements | ManagerInterface, InjectionAwareInterface |
Phalcon\Mvc\Model\Transaction\Manager
A transaction acts on a single database connection. If you have multiple class-specific databases, the transaction will not protect interaction among them.
This class manages the objects that compose a transaction. A transaction produces a unique connection that is passed to every object part of the transaction.
use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;
try {
$transactionManager = new Manager();
$transaction = $transactionManager->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("Can't save robot part");
}
$transaction->commit();
} catch (Failed $e) {
echo "Failed, reason: ", $e->getMessage();
}
/**
* @var DiInterface|null
*/
protected container;
/**
* @var bool
*/
protected initialized = false;
/**
* @var int
*/
protected number = 0;
/**
* @var bool
*/
protected rollbackPendent = true;
/**
* @var string
*/
protected service = db;
/**
* @var array
*/
protected transactions;
public function __construct( DiInterface $container = null );
Phalcon\Mvc\Model\Transaction\Manager constructor
public function collectTransactions(): void;
Remove all the transactions from the manager
public function commit();
Commits active transactions within the manager
public function get( bool $autoBegin = bool ): TransactionInterface;
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once This method registers a shutdown function to rollback active connections
public function getDI(): DiInterface;
Returns the dependency injection container
public function getDbService(): string;
Returns the database service used to isolate the transaction
public function getOrCreateTransaction( bool $autoBegin = bool ): TransactionInterface;
Create/Returns a new transaction or an existing one
public function getRollbackPendent(): bool;
Check if the transaction manager is registering a shutdown function to clean up pendent transactions
public function has(): bool;
Checks whether the manager has an active transaction
public function notifyCommit( TransactionInterface $transaction ): void;
Notifies the manager about a committed transaction
public function notifyRollback( TransactionInterface $transaction ): void;
Notifies the manager about a rollbacked transaction
public function rollback( bool $collect = bool ): void;
Rollbacks active transactions within the manager Collect will remove the transaction from the manager
public function rollbackPendent(): void;
Rollbacks active transactions within the manager
public function setDI( DiInterface $container ): void;
Sets the dependency injection container
public function setDbService( string $service ): ManagerInterface;
Sets the database service used to run the isolated transactions
public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;
Set if the transaction manager must register a shutdown function to clean up pendent transactions
protected function collectTransaction( TransactionInterface $transaction ): void;
Removes transactions from the TransactionManager
| Namespace | Phalcon\Mvc\Model\Transaction | Uses | Phalcon\Mvc\Model\TransactionInterface |
Phalcon\Mvc\Model\Transaction\ManagerInterface
Interface for Phalcon\Mvc\Model\Transaction\Manager
public function collectTransactions(): void;
Remove all the transactions from the manager
public function commit();
Commits active transactions within the manager
public function get( bool $autoBegin = bool ): TransactionInterface;
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
public function getDbService(): string;
Returns the database service used to isolate the transaction
public function getRollbackPendent(): bool;
Check if the transaction manager is registering a shutdown function to clean up pendent transactions
public function has(): bool;
Checks whether manager has an active transaction
public function notifyCommit( TransactionInterface $transaction ): void;
Notifies the manager about a committed transaction
public function notifyRollback( TransactionInterface $transaction ): void;
Notifies the manager about a rollbacked transaction
public function rollback( bool $collect = bool ): void;
Rollbacks active transactions within the manager Collect will remove transaction from the manager
public function rollbackPendent(): void;
Rollbacks active transactions within the manager
public function setDbService( string $service ): ManagerInterface;
Sets the database service used to run the isolated transactions
public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;
Set if the transaction manager must register a shutdown function to clean up pendent transactions
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\ManagerInterface |
Phalcon\Mvc\Model\TransactionInterface
Interface for Phalcon\Mvc\Model\Transaction
public function begin(): bool;
Starts the transaction
public function commit(): bool;
Commits the transaction
public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;
Returns connection related to transaction
public function getMessages(): array;
Returns validations messages from last save try
public function isManaged(): bool;
Checks whether transaction is managed by a transaction manager
public function isValid(): bool;
Checks whether internal connection is under an active transaction
public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;
Rollbacks the transaction
public function setIsNewTransaction( bool $isNew ): void;
Sets if is a reused transaction or new once
public function setRollbackOnAbort( bool $rollbackOnAbort ): void;
Sets flag to rollback on abort the HTTP connection
public function setRollbackedRecord( ModelInterface $record ): void;
Sets object which generates rollback action
public function setTransactionManager( ManagerInterface $manager ): void;
Sets transaction manager related to the transaction
public function throwRollbackException( bool $status ): TransactionInterface;
Enables throwing exception
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Messages\Message, Phalcon\Mvc\ModelInterface | Extends | Exception |
Phalcon\Mvc\Model\ValidationFailed
This exception is generated when a model fails to save a record Phalcon\Mvc\Model must be set up to have this behavior
/**
* @var array
*/
protected messages;
/**
* @var ModelInterface
*/
protected model;
public function __construct( ModelInterface $model, array $validationMessages );
Phalcon\Mvc\Model\ValidationFailed constructor
public function getMessages(): Message[];
Returns the complete group of messages produced in the validation
public function getModel(): ModelInterface;
Returns the model that generated the messages
| Namespace | Phalcon\Mvc | Uses | Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model\CriteriaInterface, Phalcon\Mvc\Model\MetaDataInterface, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\TransactionInterface |
Phalcon\Mvc\ModelInterface
Interface for Phalcon\Mvc\Model
public function appendMessage( MessageInterface $message ): ModelInterface;
Appends a customized message on the validation process
public function assign( array $data, mixed $whiteList = null, mixed $dataColumnMap = null ): ModelInterface;
Assigns values to a model from an array
public static function average( array $parameters = [] ): double | ResultsetInterface;
Allows to calculate the average value on a column matching the specified conditions
public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;
Assigns values to a model from an array returning a new model
public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = bool ): ModelInterface;
Assigns values to a model from an array returning a new model
public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );
Returns an hydrated result based on the data and the column map
public static function count( mixed $parameters = null ): int | ResultsetInterface;
Allows to count how many records match the specified conditions
Returns an integer for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the count of each group.
public function create(): bool;
Inserts a model instance. If the instance already exists in the persistence it will throw an exception. Returning true on success or false otherwise.
public function delete(): bool;
Deletes a model instance. Returning true on success or false otherwise.
public static function find( mixed $parameters = null ): ResultsetInterface;
Allows to query a set of records that match the specified conditions
public static function findFirst( mixed $parameters = null ): mixed | null;
Allows to query the first record that match the specified conditions
public function fireEvent( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified
public function fireEventCancel( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified. This method stops if one of the callbacks/listeners returns bool false
public function getDirtyState(): int;
Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
public function getMessages(): MessageInterface[];
Returns array of validation messages
public function getModelsMetaData(): MetaDataInterface;
Returns the models meta-data service related to the entity instance.
public function getOperationMade(): int;
Returns the type of the latest operation performed by the ORM Returns one of the OP_* class constants
public function getReadConnection(): AdapterInterface;
Gets internal database connection
public function getReadConnectionService(): string;
Returns DependencyInjection connection service used to read data
public function getRelated( string $alias, mixed $arguments = null );
Returns related records based on defined relations
public function getSchema(): string | null;
Returns schema name where table mapped is located
public function getSource(): string;
Returns table name mapped in the model
public function getWriteConnection(): AdapterInterface;
Gets internal database connection
public function getWriteConnectionService(): string;
Returns DependencyInjection connection service used to write data
public static function maximum( mixed $parameters = null ): mixed;
Allows to get the maximum value of a column that match the specified conditions
public static function minimum( mixed $parameters = null ): mixed;
Allows to get the minimum value of a column that match the specified conditions
public static function query( DiInterface $container = null ): CriteriaInterface;
Create a criteria for a specific model
public function refresh(): ModelInterface;
Refreshes the model attributes re-querying the record from the database
public function save(): bool;
Inserts or updates a model instance. Returning true on success or false otherwise.
public function setConnectionService( string $connectionService ): void;
Sets both read/write connection services
public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Sets the dirty state of the object using one of the DIRTY_STATE_* constants
public function setReadConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service used to read data
public function setSnapshotData( array $data, mixed $columnMap = null ): void;
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 function setTransaction( TransactionInterface $transaction ): ModelInterface;
Sets a transaction related to the Model instance
public function setWriteConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service used to write data
public function skipOperation( bool $skip ): void;
Skips the current operation forcing a success state
public static function sum( mixed $parameters = null ): double | ResultsetInterface;
Allows to calculate a sum on a column that match the specified conditions
public function update(): bool;
Updates a model instance. If the instance doesn’t exist in the persistence it will throw an exception. Returning true on success or false otherwise.
public function validationHasFailed(): bool;
Check whether validation process has generated any messages
| Namespace | Phalcon\Mvc | Uses | Phalcon\Di\DiInterface |
Phalcon\Mvc\ModuleDefinitionInterface
This interface must be implemented by class module definitions
public function registerAutoloaders( DiInterface $container = null );
Registers an autoloader related to the module
public function registerServices( DiInterface $container );
Registers services related to the module
| Namespace | Phalcon\Mvc | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Http\RequestInterface, Phalcon\Mvc\Router\Exception, Phalcon\Mvc\Router\GroupInterface, Phalcon\Mvc\Router\Route, Phalcon\Mvc\Router\RouteInterface | Extends | AbstractInjectionAware | Implements | RouterInterface, EventsAwareInterface |
Phalcon\Mvc\Router
Phalcon\Mvc\Router is the standard framework router. Routing is the process of taking a URI endpoint (that part of the URI which comes after the base URL) and decomposing it into parameters to determine which module, controller, and action of that controller should receive the request
use Phalcon\Mvc\Router;
$router = new Router();
$router->add(
"/documentation/{chapter}/{name}\.{type:[a-z]+}",
[
"controller" => "documentation",
"action" => "show",
]
);
$router->handle(
"/documentation/1/examples.html"
);
echo $router->getControllerName();
const POSITION_FIRST = 0;
const POSITION_LAST = 1;
/**
* @var string
*/
protected action = "";
/**
* @var string
*/
protected controller = "";
/**
* @var string
*/
protected defaultAction = "";
/**
* @var string
*/
protected defaultController = "";
/**
* @var string
*/
protected defaultModule = "";
/**
* @var string
*/
protected defaultNamespace = "";
/**
* @var array
*/
protected defaultParams;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected keyRouteNames;
/**
* @var array
*/
protected keyRouteIds;
/**
* @var RouteInterface|null
*/
protected matchedRoute;
/**
* @var array
*/
protected matches;
/**
* @var string
*/
protected module = "";
/**
* @var string
*/
protected namespaceName = "";
/**
* @var array|string|null
*/
protected notFoundPaths;
/**
* @var array
*/
protected params;
/**
* @var bool
*/
protected removeExtraSlashes = false;
/**
* @var array
*/
protected routes;
/**
* @var bool
*/
protected wasMatched = false;
public function __construct( bool $defaultRoutes = bool );
Phalcon\Mvc\Router constructor
public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router without any HTTP constraint
use Phalcon\Mvc\Router;
$router->add("/about", "About::index");
$router->add(
"/about",
"About::index",
["GET", "POST"]
);
$router->add(
"/about",
"About::index",
["GET", "POST"],
Router::POSITION_FIRST
);
public function addConnect( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is CONNECT
public function addDelete( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is DELETE
public function addGet( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is GET
public function addHead( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is HEAD
public function addOptions( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Add a route to the router that only match if the HTTP method is OPTIONS
public function addPatch( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PATCH
public function addPost( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is POST
public function addPurge( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)
public function addPut( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PUT
public function addTrace( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;
Adds a route to the router that only match if the HTTP method is TRACE
public function attach( RouteInterface $route, int $position = static-constant-access ): RouterInterface;
Attach Route object to the routes stack.
use Phalcon\Mvc\Router;
use Phalcon\Mvc\Router\Route;
class CustomRoute extends Route {
// ...
}
$router = new Router();
$router->attach(
new CustomRoute("/about", "About::index", ["GET", "HEAD"]),
Router::POSITION_FIRST
);
public function clear(): void;
Removes all the pre-defined routes
public function getActionName(): string;
Returns the processed action name
public function getControllerName(): string;
Returns the processed controller name
public function getDefaults(): array;
Returns an array of default parameters
public function getEventsManager(): ManagerInterface | null;
Returns the internal event manager
public function getKeyRouteIds(): array;
public function getKeyRouteNames(): array;
public function getMatchedRoute(): RouteInterface | null;
Returns the route that matches the handled URI
public function getMatches(): array;
Returns the sub expressions in the regular expression matched
public function getModuleName(): string;
Returns the processed module name
public function getNamespaceName(): string;
Returns the processed namespace name
public function getParams(): array;
Returns the processed parameters
public function getRouteById( mixed $id ): RouteInterface | bool;
Returns a route object by its id
public function getRouteByName( string $name ): RouteInterface | bool;
Returns a route object by its name
public function getRoutes(): RouteInterface[];
Returns all the routes defined in the router
public function handle( string $uri ): void;
Handles routing information received from the rewrite engine
// Passing a URL
$router->handle("/posts/edit/1");
public function isExactControllerName(): bool;
Returns whether controller name should not be mangled
public function mount( GroupInterface $group ): RouterInterface;
Mounts a group of routes in the router
public function notFound( mixed $paths ): RouterInterface;
Set a group of paths to be returned when none of the defined routes are matched
public function removeExtraSlashes( bool $remove ): RouterInterface;
Set whether router must remove the extra slashes in the handled routes
public function setDefaultAction( string $actionName ): RouterInterface;
Sets the default action name
public function setDefaultController( string $controllerName ): RouterInterface;
Sets the default controller name
public function setDefaultModule( string $moduleName ): RouterInterface;
Sets the name of the default module
public function setDefaultNamespace( string $namespaceName ): RouterInterface;
Sets the name of the default namespace
@parma string namespaceName
public function setDefaults( array $defaults ): RouterInterface;
Sets an array of default paths. If a route is missing a path the router will use the defined here. This method must not be used to set a 404 route
$router->setDefaults(
[
"module" => "common",
"action" => "index",
]
);
public function setEventsManager( ManagerInterface $eventsManager ): void;
Sets the events manager
public function setKeyRouteIds( array $routeIds ): Router;
public function setKeyRouteNames( array $routeNames ): Router;
public function wasMatched(): bool;
Checks if the router matches any of the defined routes
| Namespace | Phalcon\Mvc\Router | Uses | Phalcon\Di\DiInterface, Phalcon\Mvc\Router, Phalcon\Annotations\Annotation | Extends | Router |
Phalcon\Mvc\Router\Annotations
A router that reads routes annotations from classes/resources
use Phalcon\Mvc\Router\Annotations;
$di->setShared(
"router",
function() {
// Use the annotations router
$router = new Annotations(false);
// This will do the same as above but only if the handled uri starts with /robots
$router->addResource("Robots", "/robots");
return $router;
}
);
/**
* @var string
*/
protected actionSuffix = Action;
/**
* @var callable|string|null
*/
protected actionPreformatCallback;
/**
* @var string
*/
protected controllerSuffix = Controller;
/**
* @var array
*/
protected handlers;
/**
* @var string
*/
protected routePrefix = ;
public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;
Adds a resource to the annotations handler A resource is a class that contains routing annotations The class is located in a module
public function addResource( string $handler, string $prefix = null ): Annotations;
Adds a resource to the annotations handler A resource is a class that contains routing annotations
public function getActionPreformatCallback();
public function getResources(): array;
Return the registered resources
public function handle( string $uri ): void;
Produce the routing parameters from the rewrite information
public function processActionAnnotation( string $module, string $namespaceName, string $controller, string $action, Annotation $annotation ): void;
Checks for annotations in the public methods of the controller
public function processControllerAnnotation( string $handler, Annotation $annotation );
Checks for annotations in the controller docblock
public function setActionPreformatCallback( mixed $callback = null );
Sets the action preformat callback $action here already without suffix ‘Action’
// Array as callback
$annotationRouter->setActionPreformatCallback(
[
new Uncamelize(),
'__invoke'
]
);
// Function as callback
$annotationRouter->setActionPreformatCallback(
function ($action) {
return $action;
}
);
// String as callback
$annotationRouter->setActionPreformatCallback('strtolower');
// If empty method constructor called [null], sets uncamelize with - delimiter
$annotationRouter->setActionPreformatCallback();
public function setActionSuffix( string $actionSuffix );
Changes the action method suffix
public function setControllerSuffix( string $controllerSuffix );
Changes the controller class suffix
| Namespace | Phalcon\Mvc\Router | Extends | \Exception |
Phalcon\Mvc\Router\Exception
Exceptions thrown in Phalcon\Mvc\Router will use this class
| Namespace | Phalcon\Mvc\Router | Implements | GroupInterface |
Phalcon\Mvc\Router\Group
Helper class to create a group of routes with common attributes
$router = new \Phalcon\Mvc\Router();
//Create a group with a common module and controller
$blog = new Group(
[
"module" => "blog",
"controller" => "index",
]
);
//All the routes start with /blog
$blog->setPrefix("/blog");
//Add a route to the group
$blog->add(
"/save",
[
"action" => "save",
]
);
//Add another route to the group
$blog->add(
"/edit/{id}",
[
"action" => "edit",
]
);
//This route maps to a controller different than the default
$blog->add(
"/blog",
[
"controller" => "about",
"action" => "index",
]
);
//Add the group to the router
$router->mount($blog);
/**
* @var callable|null
*/
protected beforeMatch;
/**
* @var string|null
*/
protected hostname;
/**
* @var array|string|null
*/
protected paths;
/**
* @var string|null
*/
protected prefix;
/**
* @var array
*/
protected routes;
public function __construct( mixed $paths = null );
Phalcon\Mvc\Router\Group constructor
public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;
Adds a route to the router on any HTTP method
$router->add("/about", "About::index");
public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is CONNECT
public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is DELETE
public function addGet( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is GET
public function addHead( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is HEAD
public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;
Add a route to the router that only match if the HTTP method is OPTIONS
public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PATCH
public function addPost( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is POST
public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PURGE
public function addPut( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PUT
public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is TRACE
public function beforeMatch( callable $beforeMatch ): GroupInterface;
Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched
public function clear(): void;
Removes all the pre-defined routes
public function getBeforeMatch(): callable;
Returns the ‘before match’ callback if any
public function getHostname(): string;
Returns the hostname restriction
public function getPaths(): array | string;
Returns the common paths defined for this group
public function getPrefix(): string;
Returns the common prefix for all the routes
public function getRoutes(): RouteInterface[];
Returns the routes added to the group
public function setHostname( string $hostname ): GroupInterface;
Set a hostname restriction for all the routes in the group
public function setPaths( mixed $paths ): GroupInterface;
Set common paths for all the routes in the group
public function setPrefix( string $prefix ): GroupInterface;
Set a common uri prefix for all the routes in this group
protected function addRoute( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;
Adds a route applying the common attributes
| Namespace | Phalcon\Mvc\Router |
Phalcon\Mvc\Router\GroupInterface
$router = new \Phalcon\Mvc\Router();
// Create a group with a common module and controller
$blog = new Group(
[
"module" => "blog",
"controller" => "index",
]
);
// All the routes start with /blog
$blog->setPrefix("/blog");
// Add a route to the group
$blog->add(
"/save",
[
"action" => "save",
]
);
// Add another route to the group
$blog->add(
"/edit/{id}",
[
"action" => "edit",
]
);
// This route maps to a controller different than the default
$blog->add(
"/blog",
[
"controller" => "about",
"action" => "index",
]
);
// Add the group to the router
$router->mount($blog);
public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;
Adds a route to the router on any HTTP method
router->add("/about", "About::index");
public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is CONNECT
public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is DELETE
public function addGet( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is GET
public function addHead( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is HEAD
public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;
Add a route to the router that only match if the HTTP method is OPTIONS
public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PATCH
public function addPost( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is POST
public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PURGE
public function addPut( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PUT
public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;
Adds a route to the router that only match if the HTTP method is TRACE
public function beforeMatch( callable $beforeMatch ): GroupInterface;
Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched
public function clear(): void;
Removes all the pre-defined routes
public function getBeforeMatch(): callable;
Returns the ‘before match’ callback if any
public function getHostname(): string;
Returns the hostname restriction
public function getPaths(): array | string;
Returns the common paths defined for this group
public function getPrefix(): string;
Returns the common prefix for all the routes
public function getRoutes(): RouteInterface[];
Returns the routes added to the group
public function setHostname( string $hostname ): GroupInterface;
Set a hostname restriction for all the routes in the group
public function setPaths( mixed $paths ): GroupInterface;
Set common paths for all the routes in the group
public function setPrefix( string $prefix ): GroupInterface;
Set a common uri prefix for all the routes in this group
| Namespace | Phalcon\Mvc\Router | Implements | RouteInterface |
Phalcon\Mvc\Router\Route
This class represents every route added to the router
/**
* @var callable|null
*/
protected beforeMatch;
/**
* @var string|null
*/
protected compiledPattern;
/**
* @var array
*/
protected converters;
/**
* @var GroupInterface|null
*/
protected group;
/**
* @var string|null
*/
protected hostname;
/**
* @var string|null
*/
protected id;
/**
* @var array|string
*/
protected methods;
/**
* @var callable|null
*/
protected match;
/**
* @var string|null
*/
protected name;
/**
* @var array
*/
protected paths;
/**
* @var string
*/
protected pattern;
/**
* @var int
*/
protected static uniqueId = 0;
public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );
Phalcon\Mvc\Router\Route constructor
public function beforeMatch( callable $callback ): RouteInterface;
Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched
$router->add(
"/login",
[
"module" => "admin",
"controller" => "session",
]
)->beforeMatch(
function ($uri, $route) {
// Check if the request was made with Ajax
if ($_SERVER["HTTP_X_REQUESTED_WITH"] === "xmlhttprequest") {
return false;
}
return true;
}
);
public function compilePattern( string $pattern ): string;
Replaces placeholders from pattern returning a valid PCRE regular expression
public function convert( string $name, mixed $converter ): RouteInterface;
{@inheritdoc}
public function extractNamedParams( string $pattern ): array | bool;
Extracts parameters from a string
public function getBeforeMatch(): callable;
Returns the ‘before match’ callback if any
public function getCompiledPattern(): string;
Returns the route’s compiled pattern
public function getConverters(): array;
Returns the router converter
public function getGroup(): GroupInterface | null;
Returns the group associated with the route
public function getHostname(): string | null;
Returns the hostname restriction if any
public function getHttpMethods(): array | string;
Returns the HTTP methods that constraint matching the route
public function getId(): string | null;
public function getMatch(): callable;
Returns the ‘match’ callback if any
public function getName(): string | null;
Returns the route’s name
public function getPaths(): array;
Returns the paths
public function getPattern(): string;
Returns the route’s pattern
public function getReversedPaths(): array;
Returns the paths using positions as keys and names as values
public function getRouteId(): string;
Returns the route’s id
public static function getRoutePaths( mixed $paths = null ): array;
Returns routePaths
public function match( mixed $callback ): RouteInterface;
Allows to set a callback to handle the request directly in the route
$router->add(
"/help",
[]
)->match(
function () {
return $this->getResponse()->redirect("https://support.google.com/", true);
}
);
public function reConfigure( string $pattern, mixed $paths = null ): void;
Reconfigure the route adding a new pattern and a set of paths
public static function reset(): void;
Resets the internal route id generator
public function setGroup( GroupInterface $group ): RouteInterface;
Sets the group associated with the route
public function setHostname( string $hostname ): RouteInterface;
Sets a hostname restriction to the route
$route->setHostname("localhost");
public function setHttpMethods( mixed $httpMethods ): RouteInterface;
Sets a set of HTTP methods that constraint the matching of the route (alias of via)
$route->setHttpMethods("GET");
$route->setHttpMethods(
[
"GET",
"POST",
]
);
public function setName( string $name ): RouteInterface;
Sets the route’s name
$router->add(
"/about",
[
"controller" => "about",
]
)->setName("about");
public function via( mixed $httpMethods ): RouteInterface;
Set one or more HTTP methods that constraint the matching of the route
$route->via("GET");
$route->via(
[
"GET",
"POST",
]
);
| Namespace | Phalcon\Mvc\Router |
Phalcon\Mvc\Router\RouteInterface
Interface for Phalcon\Mvc\Router\Route
public function compilePattern( string $pattern ): string;
Replaces placeholders from pattern returning a valid PCRE regular expression
public function convert( string $name, mixed $converter ): RouteInterface;
Adds a converter to perform an additional transformation for certain parameter.
public function getCompiledPattern(): string;
Returns the route’s pattern
public function getHostname(): string | null;
Returns the hostname restriction if any
public function getHttpMethods(): string | array;
Returns the HTTP methods that constraint matching the route
public function getName(): string | null;
Returns the route’s name
public function getPaths(): array;
Returns the paths
public function getPattern(): string;
Returns the route’s pattern
public function getReversedPaths(): array;
Returns the paths using positions as keys and names as values
public function getRouteId(): string;
Returns the route’s id
public function reConfigure( string $pattern, mixed $paths = null ): void;
Reconfigure the route adding a new pattern and a set of paths
public static function reset(): void;
Resets the internal route id generator
public function setHostname( string $hostname ): RouteInterface;
Sets a hostname restriction to the route
public function setHttpMethods( mixed $httpMethods ): RouteInterface;
Sets a set of HTTP methods that constraint the matching of the route
public function setName( string $name ): RouteInterface;
Sets the route’s name
public function via( mixed $httpMethods ): RouteInterface;
Set one or more HTTP methods that constraint the matching of the route
| Namespace | Phalcon\Mvc | Uses | Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Router\GroupInterface |
Interface for Phalcon\Mvc\Router
public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router on any HTTP method
public function addConnect( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is CONNECT
public function addDelete( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is DELETE
public function addGet( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is GET
public function addHead( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is HEAD
public function addOptions( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Add a route to the router that only match if the HTTP method is OPTIONS
public function addPatch( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PATCH
public function addPost( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is POST
public function addPurge( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)
public function addPut( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is PUT
public function addTrace( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;
Adds a route to the router that only match if the HTTP method is TRACE
public function attach( RouteInterface $route, int $position = Router::POSITION_LAST ): RouterInterface;
Attach Route object to the routes stack.
public function clear(): void;
Removes all the defined routes
public function getActionName(): string;
Returns processed action name
public function getControllerName(): string;
Returns processed controller name
public function getMatchedRoute(): RouteInterface | null;
Returns the route that matches the handled URI
public function getMatches(): array;
Return the sub expressions in the regular expression matched
public function getModuleName(): string;
Returns processed module name
public function getNamespaceName(): string;
Returns processed namespace name
public function getParams(): array;
Returns processed extra params
public function getRouteById( mixed $id ): RouteInterface | bool;
Returns a route object by its id
public function getRouteByName( string $name ): RouteInterface | bool;
Returns a route object by its name
public function getRoutes(): RouteInterface[];
Return all the routes defined in the router
public function handle( string $uri ): void;
Handles routing information received from the rewrite engine
public function mount( GroupInterface $group ): RouterInterface;
Mounts a group of routes in the router
public function setDefaultAction( string $actionName ): RouterInterface;
Sets the default action name
public function setDefaultController( string $controllerName ): RouterInterface;
Sets the default controller name
public function setDefaultModule( string $moduleName ): RouterInterface;
Sets the name of the default module
public function setDefaults( array $defaults ): RouterInterface;
Sets an array of default paths
public function wasMatched(): bool;
Check if the router matches any of the defined routes
| Namespace | Phalcon\Mvc | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Mvc\RouterInterface, Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Url\Exception, Phalcon\Mvc\Url\UrlInterface | Extends | AbstractInjectionAware | Implements | UrlInterface |
This components helps in the generation of: URIs, URLs and Paths
// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");
// Generate a URL for a predefined route
echo $url->get(
[
"for" => "blog-post",
"title" => "some-cool-stuff",
"year" => "2012",
]
);
/**
* @var null | string
*/
protected baseUri;
/**
* @var null | string
*/
protected basePath;
/**
* @var RouterInterface | null
*/
protected router;
/**
* @var null | string
*/
protected staticBaseUri;
public function __construct( RouterInterface $router = null );
public function get( mixed $uri = null, mixed $args = null, bool $local = null, mixed $baseUri = null ): string;
Generates a URL
// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");
// Generate a URL for a predefined route
echo $url->get(
[
"for" => "blog-post",
"title" => "some-cool-stuff",
"year" => "2015",
]
);
// Generate a URL with GET arguments (/show/products?id=1&name=Carrots)
echo $url->get(
"show/products",
[
"id" => 1,
"name" => "Carrots",
]
);
// Generate an absolute URL by setting the third parameter as false.
echo $url->get(
"https://phalcon.io/",
null,
false
);
public function getBasePath(): string;
Returns the base path
public function getBaseUri(): string;
Returns the prefix for all the generated urls. By default /
public function getStatic( mixed $uri = null ): string;
Generates a URL for a static resource
// Generate a URL for a static resource
echo $url->getStatic("img/logo.png");
// Generate a URL for a static predefined route
echo $url->getStatic(
[
"for" => "logo-cdn",
]
);
public function getStaticBaseUri(): string;
Returns the prefix for all the generated static urls. By default /
public function path( string $path = null ): string;
Generates a local path
public function setBasePath( string $basePath ): UrlInterface;
Sets a base path for all the generated paths
$url->setBasePath("/var/www/htdocs/");
public function setBaseUri( string $baseUri ): UrlInterface;
Sets a prefix for all the URIs to be generated
$url->setBaseUri("/invo/");
$url->setBaseUri("/invo/index.php/");
public function setStaticBaseUri( string $staticBaseUri ): UrlInterface;
Sets a prefix for all static URLs generated
$url->setStaticBaseUri("/invo/");
| Namespace | Phalcon\Mvc\Url | Extends | \Exception |
Phalcon\Mvc\Url\Exception
Exceptions thrown in Phalcon\Mvc\Url will use this class
| Namespace | Phalcon\Mvc\Url |
Interface for Phalcon\Mvc\Url\UrlInterface
public function get( mixed $uri = null, mixed $args = null, bool $local = null ): string;
Generates a URL
public function getBasePath(): string;
Returns a base path
public function getBaseUri(): string;
Returns the prefix for all the generated urls. By default /
public function path( string $path = null ): string;
Generates a local path
public function setBasePath( string $basePath ): UrlInterface;
Sets a base paths for all the generated paths
public function setBaseUri( string $baseUri ): UrlInterface;
Sets a prefix to all the urls generated
| Namespace | Phalcon\Mvc | Uses | Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Events\ManagerInterface, Phalcon\Mvc\View\Exception, Phalcon\Events\EventsAwareInterface, Phalcon\Mvc\View\Engine\Php | Extends | Injectable | Implements | ViewInterface, EventsAwareInterface |
Phalcon\Mvc\View
Phalcon\Mvc\View is a class for working with the “view” portion of the model-view-controller pattern. That is, it exists to help keep the view script separate from the model and controller scripts. It provides a system of helpers, output filters, and variable escaping.
use Phalcon\Mvc\View;
$view = new View();
// Setting views directory
$view->setViewsDir("app/views/");
$view->start();
// Shows recent posts view (app/views/posts/recent.phtml)
$view->render("posts", "recent");
$view->finish();
// Printing views output
echo $view->getContent();
const LEVEL_ACTION_VIEW = 1;
const LEVEL_AFTER_TEMPLATE = 4;
const LEVEL_BEFORE_TEMPLATE = 2;
const LEVEL_LAYOUT = 3;
const LEVEL_MAIN_LAYOUT = 5;
const LEVEL_NO_RENDER = 0;
/**
* @var string
*/
protected actionName;
/**
* @var array
*/
protected activeRenderPaths;
/**
* @var string
*/
protected basePath = ;
/**
* @var string
*/
protected content = ;
/**
* @var string
*/
protected controllerName;
/**
* @var int
*/
protected currentRenderLevel = 0;
/**
* @var bool
*/
protected disabled = false;
/**
* @var array
*/
protected disabledLevels;
/**
* @var array|bool
*/
protected engines = false;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var string|null
*/
protected layout;
/**
* @var string
*/
protected layoutsDir = ;
/**
* @var string
*/
protected mainView = index;
/**
* @var array
*/
protected options;
/**
* @var array
*/
protected params;
/**
* @var array|null
*/
protected pickView;
/**
* @var string
*/
protected partialsDir = ;
/**
* @var array
*/
protected registeredEngines;
/**
* @var int
*/
protected renderLevel = 5;
/**
* @var array
*/
protected templatesAfter;
/**
* @var array
*/
protected templatesBefore;
/**
* @var array
*/
protected viewsDirs;
/**
* @var array
*/
protected viewParams;
public function __construct( array $options = [] );
Phalcon\Mvc\View constructor
public function __get( string $key ): mixed | null;
Magic method to retrieve a variable passed to the view
echo $this->view->products;
public function __isset( string $key ): bool;
Magic method to retrieve if a variable is set in the view
echo isset($this->view->products);
public function __set( string $key, mixed $value );
Magic method to pass variables to the views
$this->view->products = $products;
public function cleanTemplateAfter(): View;
Resets any template before layouts
public function cleanTemplateBefore(): View;
Resets any “template before” layouts
public function disable(): View;
Disables the auto-rendering process
public function disableLevel( mixed $level ): ViewInterface;
Disables a specific level of rendering
// Render all levels except ACTION level
$this->view->disableLevel(
View::LEVEL_ACTION_VIEW
);
public function enable(): View;
Enables the auto-rendering process
public function exists( string $view ): bool;
Checks whether view exists @deprecated
public function finish(): View;
Finishes the render process by stopping the output buffering
public function getActionName(): string;
Gets the name of the action rendered
public function getActiveRenderPath(): string | array;
Returns the path (or paths) of the views that are currently rendered
public function getBasePath(): string;
Gets base path
public function getContent(): string;
Returns output from another view stage
public function getControllerName(): string;
Gets the name of the controller rendered
public function getCurrentRenderLevel(): int;
public function getEventsManager(): ManagerInterface | null;
Returns the internal event manager
public function getLayout(): string;
Returns the name of the main view
public function getLayoutsDir(): string;
Gets the current layouts sub-directory
public function getMainView(): string;
Returns the name of the main view
public function getParamsToView(): array;
Returns parameters to views
public function getPartial( string $partialPath, mixed $params = null ): string;
Renders a partial view
// Retrieve the contents of a partial
echo $this->getPartial("shared/footer");
// Retrieve the contents of a partial with arguments
echo $this->getPartial(
"shared/footer",
[
"content" => $html,
]
);
public function getPartialsDir(): string;
Gets the current partials sub-directory
public function getRegisteredEngines(): array;
public function getRender( string $controllerName, string $actionName, array $params = [], mixed $configCallback = null ): string;
Perform the automatic rendering returning the output as a string
$template = $this->view->getRender(
"products",
"show",
[
"products" => $products,
]
);
public function getRenderLevel(): int;
public function getVar( string $key ): mixed | null;
Returns a parameter previously set in the view
public function getViewsDir(): string | array;
Gets views directory
public function has( string $view ): bool;
Checks whether view exists
public function isDisabled(): bool;
Whether automatic rendering is enabled
public function partial( string $partialPath, mixed $params = null );
Renders a partial view
// Show a partial inside another view
$this->partial("shared/footer");
// Show a partial inside another view with parameters
$this->partial(
"shared/footer",
[
"content" => $html,
]
);
public function pick( mixed $renderView ): View;
Choose a different view to render instead of last-controller/last-action
use Phalcon\Mvc\Controller;
class ProductsController extends Controller
{
public function saveAction()
{
// Do some save stuff...
// Then show the list view
$this->view->pick("products/list");
}
}
public function processRender( string $controllerName, string $actionName, array $params = [], bool $fireEvents = bool ): bool;
Processes the view and templates; Fires events if needed
public function registerEngines( array $engines ): View;
Register templating engines
$this->view->registerEngines(
[
".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
".volt" => \Phalcon\Mvc\View\Engine\Volt::class,
".mhtml" => \MyCustomEngine::class,
]
);
public function render( string $controllerName, string $actionName, array $params = [] ): View | bool;
Executes render process from dispatching data
// Shows recent posts view (app/views/posts/recent.phtml)
$view->start()->render("posts", "recent")->finish();
public function reset(): View;
Resets the view component to its factory default values
public function setBasePath( string $basePath ): View;
Sets base path. Depending of your platform, always add a trailing slash or backslash
$view->setBasePath(__DIR__ . "/");
public function setContent( string $content ): View;
Externally sets the view content
$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;
Sets the events manager
public function setLayout( string $layout ): View;
Change the layout to be used instead of using the name of the latest controller name
$this->view->setLayout("main");
public function setLayoutsDir( string $layoutsDir ): View;
Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
$view->setLayoutsDir("../common/layouts/");
public function setMainView( string $viewPath ): View;
Sets default view name. Must be a file without extension in the views directory
// Renders as main view views-dir/base.phtml
$this->view->setMainView("base");
public function setParamToView( string $key, mixed $value ): View;
Adds parameters to views (alias of setVar)
$this->view->setParamToView("products", $products);
public function setPartialsDir( string $partialsDir ): View;
Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
$view->setPartialsDir("../common/partials/");
public function setRenderLevel( int $level ): ViewInterface;
Sets the render level for the view
// Render the view related to the controller only
$this->view->setRenderLevel(
View::LEVEL_LAYOUT
);
public function setTemplateAfter( mixed $templateAfter ): View;
Sets a “template after” controller layout
public function setTemplateBefore( mixed $templateBefore ): View;
Sets a template before the controller layout
public function setVar( string $key, mixed $value ): View;
Set a single view parameter
$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): View;
Set all the render params
$this->view->setVars(
[
"products" => $products,
]
);
public function setViewsDir( mixed $viewsDir ): View;
Sets the views directory. Depending of your platform, always add a trailing slash or backslash
public function start(): View;
Starts rendering process enabling the output buffering
public function toString( string $controllerName, string $actionName, array $params = [] ): string;
Renders the view and returns it as a string
protected function engineRender( array $engines, string $viewPath, bool $silence, bool $mustClean = bool );
Checks whether view exists on registered extensions and render it
protected function getViewsDirs(): array;
Gets views directories
final protected function isAbsolutePath( string $path );
Checks if a path is absolute or not
protected function loadTemplateEngines(): array;
Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
| Namespace | Phalcon\Mvc\View\Engine | Uses | Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Mvc\ViewBaseInterface | Extends | Injectable | Implements | EngineInterface |
All the template engine adapters must inherit this class. This provides basic interfacing between the engine and the Phalcon\Mvc\View component.
/**
* @var ViewBaseInterface
*/
protected view;
public function __construct( ViewBaseInterface $view, DiInterface $container = null );
Phalcon\Mvc\View\Engine constructor
public function getContent(): string;
Returns cached output on another view stage
public function getView(): ViewBaseInterface;
Returns the view component related to the adapter
public function partial( string $partialPath, mixed $params = null ): void;
Renders a partial inside another view
| Namespace | Phalcon\Mvc\View\Engine |
Interface for Phalcon\Mvc\View engine adapters
public function getContent(): string;
Returns cached output on another view stage
public function partial( string $partialPath, mixed $params = null ): void;
Renders a partial inside another view
public function render( string $path, mixed $params, bool $mustClean = bool );
Renders a view using the template engine
TODO: Change params to array type
| Namespace | Phalcon\Mvc\View\Engine | Extends | AbstractEngine |
Adapter to use PHP itself as templating engine
public function render( string $path, mixed $params, bool $mustClean = bool );
Renders a view using the template engine
| Namespace | Phalcon\Mvc\View\Engine | Uses | Phalcon\Di\DiInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Html\Link\Link, Phalcon\Html\Link\Serializer\Header, Phalcon\Mvc\View\Engine\Volt\Compiler, Phalcon\Mvc\View\Exception | Extends | AbstractEngine | Implements | EventsAwareInterface |
Designer friendly and fast template engine for PHP written in Zephir/C
/**
* @var Compiler
*/
protected compiler;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected macros;
/**
* @var array
*/
protected options;
public function callMacro( string $name, array $arguments = [] ): mixed;
Checks if a macro is defined and calls it
public function convertEncoding( string $text, string $from, string $to ): string;
Performs a string conversion
public function getCompiler(): Compiler;
Returns the Volt’s compiler
public function getEventsManager(): ManagerInterface | null;
Returns the internal event manager
public function getOptions(): array;
Return Volt’s options
public function isIncluded( mixed $needle, mixed $haystack ): bool;
Checks if the needle is included in the haystack
public function length( mixed $item ): int;
Length filter. If an array/object is passed a count is performed otherwise a strlen/mb_strlen
public function preload( mixed $parameters ): string;
Parses the preload element passed and sets the necessary link headers @todo find a better way to handle this
public function render( string $path, mixed $params, bool $mustClean = bool );
Renders a view using the template engine
public function setEventsManager( ManagerInterface $eventsManager ): void;
Sets the events manager
public function setOptions( array $options );
Set Volt’s options
public function slice( mixed $value, int $start = int, mixed $end = null );
Extracts a slice from a string/array/traversable object value
public function sort( array $value ): array;
Sorts an array
| Namespace | Phalcon\Mvc\View\Engine\Volt | Uses | Closure, Phalcon\Di\DiInterface, Phalcon\Mvc\ViewBaseInterface, Phalcon\Di\InjectionAwareInterface | Implements | InjectionAwareInterface |
This class reads and compiles Volt templates into PHP plain code
$compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
$compiler->compile("views/partials/header.volt");
require $compiler->getCompiledTemplatePath();
/**
* @var bool
*/
protected autoescape = false;
/**
* @var int
*/
protected blockLevel = 0;
/**
* @var array|null
*
* TODO: Make array only?
*/
protected blocks;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var string|null
*/
protected compiledTemplatePath;
/**
* @var string|null
*/
protected currentBlock;
/**
* @var string|null
*/
protected currentPath;
/**
* @var int
*/
protected exprLevel = 0;
/**
* @var bool
*/
protected extended = false;
/**
* @var array
*/
protected extensions;
/**
* @var array|bool
*
* TODO: Make it always array
*/
protected extendedBlocks;
/**
* @var array
*/
protected filters;
/**
* @var int
*/
protected foreachLevel = 0;
/**
* @var array
*/
protected forElsePointers;
/**
* @var array
*/
protected functions;
/**
* @var int
*/
protected level = 0;
/**
* @var array
*/
protected loopPointers;
/**
* @var array
*/
protected macros;
/**
* @var array
*/
protected options;
/**
* @var string
*/
protected prefix = ;
/**
* @var ViewBaseInterface|null
*/
protected view;
public function __construct( ViewBaseInterface $view = null );
Phalcon\Mvc\View\Engine\Volt\Compiler
public function addExtension( mixed $extension ): Compiler;
Registers a Volt’s extension
@var mixed extension
public function addFilter( string $name, mixed $definition ): Compiler;
Register a new filter in the compiler
public function addFunction( string $name, mixed $definition ): Compiler;
Register a new function in the compiler
public function attributeReader( array $expr ): string;
Resolves attribute reading
public function compile( string $templatePath, bool $extendsMode = bool );
Compiles a template into a file applying the compiler options This method does not return the compiled path if the template was not compiled
$compiler->compile("views/layouts/main.volt");
require $compiler->getCompiledTemplatePath();
public function compileAutoEscape( array $statement, bool $extendsMode ): string;
Compiles a “autoescape” statement returning PHP code
public function compileCall( array $statement, bool $extendsMode );
Compiles calls to macros
public function compileCase( array $statement, bool $caseClause = bool ): string;
Compiles a “case”/”default” clause returning PHP code
public function compileDo( array $statement ): string;
Compiles a “do” statement returning PHP code
public function compileEcho( array $statement ): string;
Compiles a {{ }} statement returning PHP code
public function compileElseIf( array $statement ): string;
Compiles a “elseif” statement returning PHP code
public function compileFile( string $path, string $compiledPath, bool $extendsMode = bool );
Compiles a template into a file forcing the destination path
$compiler->compileFile(
"views/layouts/main.volt",
"views/layouts/main.volt.php"
);
public function compileForElse(): string;
Generates a ‘forelse’ PHP code
public function compileForeach( array $statement, bool $extendsMode = bool ): string;
Compiles a “foreach” intermediate code representation into plain PHP code
public function compileIf( array $statement, bool $extendsMode = bool ): string;
Compiles a ‘if’ statement returning PHP code
public function compileInclude( array $statement ): string;
Compiles a ‘include’ statement returning PHP code
public function compileMacro( array $statement, bool $extendsMode ): string;
Compiles macros
public function compileReturn( array $statement ): string;
Compiles a “return” statement returning PHP code
@throws \Phalcon\Mvc\View\Engine\Volt\Exception
public function compileSet( array $statement ): string;
Compiles a “set” statement returning PHP code
public function compileString( string $viewCode, bool $extendsMode = bool ): string;
Compiles a template into a string
echo $compiler->compileString('{{ "hello world" }}');
public function compileSwitch( array $statement, bool $extendsMode = bool ): string;
Compiles a ‘switch’ statement returning PHP code
final public function expression( array $expr, bool $doubleQuotes = bool ): string;
Resolves an expression node in an AST volt tree
final public function fireExtensionEvent( string $name, array $arguments = [] );
Fires an event to registered extensions
public function functionCall( array $expr, bool $doubleQuotes = bool ): string;
Resolves function intermediate code into PHP function calls
public function getCompiledTemplatePath(): string;
Returns the path to the last compiled template
public function getDI(): DiInterface;
Returns the internal dependency injector
public function getExtensions(): array;
Returns the list of extensions registered in Volt
public function getFilters(): array;
Register the user registered filters
public function getFunctions(): array;
Register the user registered functions
public function getOption( string $option ): string | null;
Returns a compiler’s option
public function getOptions(): array;
Returns the compiler options
public function getTemplatePath(): string;
Returns the path that is currently being compiled
public function getUniquePrefix(): string;
Return a unique prefix to be used as prefix for compiled variables and contexts
public function parse( string $viewCode ): array;
Parses a Volt template returning its intermediate representation
print_r(
$compiler->parse("{{ 3 + 2 }}")
);
public function resolveTest( array $test, string $left ): string;
Resolves filter intermediate code into a valid PHP expression
public function setDI( DiInterface $container ): void;
Sets the dependency injector
public function setOption( string $option, mixed $value );
Sets a single compiler option
public function setOptions( array $options );
Sets the compiler options
public function setUniquePrefix( string $prefix ): Compiler;
Set a unique prefix to be used as prefix for compiled variables
protected function compileSource( string $viewCode, bool $extendsMode = bool ): string;
Compiles a Volt source code returning a PHP plain version
protected function getFinalPath( string $path );
Gets the final path with VIEW
final protected function resolveFilter( array $filter, string $left ): string;
Resolves filter intermediate code into PHP function calls
final protected function statementList( array $statements, bool $extendsMode = bool ): string;
Traverses a statement list compiling each of its nodes
final protected function statementListOrExtends( mixed $statements );
Compiles a block of statements
| Namespace | Phalcon\Mvc\View\Engine\Volt | Uses | Phalcon\Mvc\View\Exception | Extends | BaseException |
Class for exceptions thrown by Phalcon\Mvc\View
/**
* @var array
*/
protected statement;
public function __construct( string $message = string, array $statement = [], int $code = int, \Exception $previous = null );
public function getStatement(): array;
Gets currently parsed statement (if any).
| Namespace | Phalcon\Mvc\View | Extends | \Exception |
Phalcon\Mvc\View\Exception
Class for exceptions thrown by Phalcon\Mvc\View
| Namespace | Phalcon\Mvc\View | Uses | Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\ViewBaseInterface, Phalcon\Mvc\View\Engine\EngineInterface, Phalcon\Mvc\View\Engine\Php | Extends | Injectable | Implements | ViewBaseInterface, EventsAwareInterface |
Phalcon\Mvc\View\Simple
This component allows to render views without hierarchical levels
use Phalcon\Mvc\View\Simple as View;
$view = new View();
// Render a view
echo $view->render(
"templates/my-view",
[
"some" => $param,
]
);
// Or with filename with extension
echo $view->render(
"templates/my-view.volt",
[
"parameter" => $here,
]
);
/**
* @var string
*/
protected activeRenderPath;
/**
* @var string
*/
protected content;
/**
* @var EngineInterface[]|false
*/
protected engines = false;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected options;
/**
* @var array
*/
protected registeredEngines;
/**
* @var string
*/
protected viewsDir;
/**
* @var array
*/
protected viewParams;
public function __construct( array $options = [] );
Phalcon\Mvc\View\Simple constructor
public function __get( string $key ): mixed | null;
Magic method to retrieve a variable passed to the view
echo $this->view->products;
public function __set( string $key, mixed $value ): void;
Magic method to pass variables to the views
$this->view->products = $products;
public function getActiveRenderPath(): string;
Returns the path of the view that is currently rendered
public function getContent(): string;
Returns output from another view stage
public function getEventsManager(): ManagerInterface | null;
Returns the internal event manager
public function getParamsToView(): array;
Returns parameters to views
public function getRegisteredEngines(): array;
public function getVar( string $key ): mixed | null;
Returns a parameter previously set in the view
public function getViewsDir(): string;
Gets views directory
public function partial( string $partialPath, mixed $params = null ): void;
Renders a partial view
// Show a partial inside another view
$this->partial("shared/footer");
// Show a partial inside another view with parameters
$this->partial(
"shared/footer",
[
"content" => $html,
]
);
public function registerEngines( array $engines ): void;
Register templating engines
$this->view->registerEngines(
[
".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
".volt" => \Phalcon\Mvc\View\Engine\Volt::class,
".mhtml" => \MyCustomEngine::class,
]
);
public function render( string $path, array $params = [] ): string;
Renders a view
public function setContent( string $content ): Simple;
Externally sets the view content
$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;
Sets the events manager
public function setParamToView( string $key, mixed $value ): Simple;
Adds parameters to views (alias of setVar)
$this->view->setParamToView("products", $products);
public function setVar( string $key, mixed $value ): Simple;
Set a single view parameter
$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): Simple;
Set all the render params
$this->view->setVars(
[
"products" => $products,
]
);
public function setViewsDir( string $viewsDir ): void;
Sets views directory
final protected function internalRender( string $path, mixed $params ): void;
Tries to render the view with every engine registered in the component
protected function loadTemplateEngines(): array;
Loads registered template engines, if none are registered it will use Phalcon\Mvc\View\Engine\Php
| Namespace | Phalcon\Mvc | Uses | Phalcon\Cache\Adapter\AdapterInterface |
Phalcon\Mvc\ViewInterface
Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple
public function getContent(): string;
Returns cached output from another view stage
public function getParamsToView(): array;
Returns parameters to views
public function getViewsDir(): string | array;
Gets views directory
public function partial( string $partialPath, mixed $params = null );
Renders a partial view
public function setContent( string $content );
Externally sets the view content
public function setParamToView( string $key, mixed $value );
Adds parameters to views (alias of setVar)
public function setVar( string $key, mixed $value );
Adds parameters to views
public function setViewsDir( string $viewsDir );
Sets views directory. Depending of your platform, always add a trailing slash or backslash
| Namespace | Phalcon\Mvc | Extends | ViewBaseInterface |
Phalcon\Mvc\ViewInterface
Interface for Phalcon\Mvc\View
public function cleanTemplateAfter();
Resets any template before layouts
public function cleanTemplateBefore();
Resets any template before layouts
public function disable();
Disables the auto-rendering process
public function enable();
Enables the auto-rendering process
public function finish();
Finishes the render process by stopping the output buffering
public function getActionName(): string;
Gets the name of the action rendered
public function getActiveRenderPath(): string | array;
Returns the path of the view that is currently rendered
public function getBasePath(): string;
Gets base path
public function getControllerName(): string;
Gets the name of the controller rendered
public function getLayout(): string;
Returns the name of the main view
public function getLayoutsDir(): string;
Gets the current layouts sub-directory
public function getMainView(): string;
Returns the name of the main view
public function getPartialsDir(): string;
Gets the current partials sub-directory
public function isDisabled(): bool;
Whether the automatic rendering is disabled
public function pick( string $renderView );
Choose a view different to render than last-controller/last-action
public function registerEngines( array $engines );
Register templating engines
public function render( string $controllerName, string $actionName, array $params = [] ): ViewInterface | bool;
Executes render process from dispatching data
public function reset();
Resets the view component to its factory default values
public function setBasePath( string $basePath );
Sets base path. Depending of your platform, always add a trailing slash or backslash
public function setLayout( string $layout );
Change the layout to be used instead of using the name of the latest controller name
public function setLayoutsDir( string $layoutsDir );
Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
public function setMainView( string $viewPath );
Sets default view name. Must be a file without extension in the views directory
public function setPartialsDir( string $partialsDir );
Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
public function setRenderLevel( int $level ): ViewInterface;
Sets the render level for the view
public function setTemplateAfter( mixed $templateAfter );
Appends template after controller layout
public function setTemplateBefore( mixed $templateBefore );
Appends template before controller layout
public function start();
Starts rendering process enabling the output buffering