---
title: "Phalcon Mvc"
version: "5.20"
---
> Documentation Index
> Fetch the complete documentation index at: https://docs.phalcon.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Phalcon Mvc
:::info[NOTE]
All classes are prefixed with `Phalcon`
:::
## Mvc\Application
Class
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.
```php
use 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();
```
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- [`Phalcon\Application\AbstractApplication`](/5.20/api/phalcon_application/#applicationabstractapplication)
- **`Phalcon\Mvc\Application`**
`Closure` · `Phalcon\Application\AbstractApplication` · `Phalcon\Di\DiInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Http\ResponseInterface` · `Phalcon\Mvc\Application\Exception` · `Phalcon\Mvc\Application\Exceptions\ContainerRequired` · `Phalcon\Mvc\Application\Exceptions\InvalidModuleDefinition` · `Phalcon\Mvc\Application\Exceptions\ModuleDefinitionPathNotFound` · `Phalcon\Mvc\ModuleDefinitionInterface` · `Phalcon\Mvc\Router\RouteInterface` · `Phalcon\Traits\Php\FileTrait`
### Method Summary
Handles a MVC request
Enables or disables sending cookies by each request handling
Enables or disables sending headers by each request handling
By default. The view is implicitly buffering all the output
### Properties
### Methods
handle()
```php
public function handle( string $uri ): ResponseInterface|bool;
```
Handles a MVC request
sendCookiesOnHandleRequest()
```php
public function sendCookiesOnHandleRequest( bool $sendCookies ): static;
```
Enables or disables sending cookies by each request handling
sendHeadersOnHandleRequest()
```php
public function sendHeadersOnHandleRequest( bool $sendHeaders ): static;
```
Enables or disables sending headers by each request handling
useImplicitView()
```php
public function useImplicitView( bool $implicitView ): static;
```
By default. The view is implicitly buffering all the output
You can full disable the view component using this method
## Mvc\Application\Exception
Class
Phalcon\Mvc\Application\Exception
Exceptions thrown in Phalcon\Mvc\Application class will use this class
- `\Exception`
- [`Phalcon\Application\Exception`](/5.20/api/phalcon_application/#applicationexception)
- **`Phalcon\Mvc\Application\Exception`**
- [`Phalcon\Mvc\Application\Exceptions\ContainerRequired`](#mvcapplicationexceptionscontainerrequired)
- [`Phalcon\Mvc\Application\Exceptions\InvalidModuleDefinition`](#mvcapplicationexceptionsinvalidmoduledefinition)
- [`Phalcon\Mvc\Application\Exceptions\ModuleDefinitionPathNotFound`](#mvcapplicationexceptionsmoduledefinitionpathnotfound)
## Mvc\Application\Exceptions\ContainerRequired
Class
- `\Exception`
- [`Phalcon\Application\Exception`](/5.20/api/phalcon_application/#applicationexception)
- [`Phalcon\Mvc\Application\Exception`](#mvcapplicationexception)
- **`Phalcon\Mvc\Application\Exceptions\ContainerRequired`**
`Phalcon\Mvc\Application\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Application\Exceptions\InvalidModuleDefinition
Class
- `\Exception`
- [`Phalcon\Application\Exception`](/5.20/api/phalcon_application/#applicationexception)
- [`Phalcon\Mvc\Application\Exception`](#mvcapplicationexception)
- **`Phalcon\Mvc\Application\Exceptions\InvalidModuleDefinition`**
`Phalcon\Mvc\Application\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string|null $name = null,
string|null $reason = null
);
```
## Mvc\Application\Exceptions\ModuleDefinitionPathNotFound
Class
- `\Exception`
- [`Phalcon\Application\Exception`](/5.20/api/phalcon_application/#applicationexception)
- [`Phalcon\Mvc\Application\Exception`](#mvcapplicationexception)
- **`Phalcon\Mvc\Application\Exceptions\ModuleDefinitionPathNotFound`**
`Phalcon\Mvc\Application\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $path );
```
## Mvc\Controller
Abstract
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
dispatcher->forward(
[
"controller" => "people",
"action" => "index",
]
);
}
}
```
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Mvc\Controller`** - implements [`Phalcon\Mvc\ControllerInterface`](#mvccontrollerinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
`Phalcon\Di\Injectable` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface`
### Method Summary
Phalcon\Mvc\Controller constructor
Returns the internal event manager
Sets the events manager
Helper method to fire an event
### Methods
__construct()
```php
final public function __construct();
```
Phalcon\Mvc\Controller constructor
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
fireManagerEvent()
```php
protected function fireManagerEvent(
string $eventName,
mixed $data = null,
bool $cancellable = true
): mixed|bool;
```
Helper method to fire an event
## Mvc\ControllerInterface
Interface
Phalcon\Mvc\ControllerInterface
Interface for controller handlers
- **`Phalcon\Mvc\ControllerInterface`**
## Mvc\Controller\BindModelInterface
Interface
Phalcon\Mvc\Controller\BindModelInterface
Interface for Phalcon\Mvc\Controller
- **`Phalcon\Mvc\Controller\BindModelInterface`**
### Method Summary
Return the model name associated with this controller
### Methods
getModelName()
```php
public static function getModelName(): string;
```
Return the model name associated with this controller
## Mvc\Dispatcher
Class
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.
```php
$di = new \Phalcon\Di\Di();
$dispatcher = new \Phalcon\Mvc\Dispatcher();
$dispatcher->setDI($di);
$dispatcher->setControllerName("posts");
$dispatcher->setActionName("index");
$dispatcher->setParams([]);
$controller = $dispatcher->dispatch();
```
- `\stdClass`
- [`Phalcon\Di\AbstractInjectionAware`](/5.20/api/phalcon_di/#diabstractinjectionaware)
- [`Phalcon\Dispatcher\AbstractDispatcher`](/5.20/api/phalcon_dispatcher/#dispatcherabstractdispatcher)
- **`Phalcon\Mvc\Dispatcher`** - implements [`Phalcon\Mvc\DispatcherInterface`](#mvcdispatcherinterface)
`Phalcon\Contracts\Dispatcher\DispatcherTypes` · `Phalcon\Dispatcher\AbstractDispatcher` · `Phalcon\Events\ManagerInterface` · `Phalcon\Http\ResponseInterface` · `Phalcon\Mvc\Dispatcher\Exception` · `Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable`
### Method Summary
Forwards the execution flow to another controller/action.
Returns the active controller in the dispatcher
Possible controller class name that will be located to dispatch the
Gets last dispatched controller name
Returns the latest dispatched controller
Gets previous dispatched controller name
Sets the controller name to be dispatched
Sets the default controller suffix
Sets the default controller name
Handles a user exception
Throws an internal exception
### Properties
### Methods
forward()
```php
public function forward( array $forward ): void;
```
Forwards the execution flow to another controller/action.
```php
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",
]
);
```
getActiveController()
```php
public function getActiveController(): ControllerInterface;
```
Returns the active controller in the dispatcher
getControllerClass()
```php
public function getControllerClass(): string;
```
Possible controller class name that will be located to dispatch the
request
getControllerName()
```php
public function getControllerName(): string;
```
Gets last dispatched controller name
getLastController()
```php
public function getLastController(): ControllerInterface;
```
Returns the latest dispatched controller
getPreviousControllerName()
```php
public function getPreviousControllerName(): string;
```
Gets previous dispatched controller name
Note: This is an Mvc-specific alias for the base
getPreviousHandlerName().
setControllerName()
```php
public function setControllerName( string $controllerName ): DispatcherInterface;
```
Sets the controller name to be dispatched
setControllerSuffix()
```php
public function setControllerSuffix( string $controllerSuffix ): DispatcherInterface;
```
Sets the default controller suffix
setDefaultController()
```php
public function setDefaultController( string $controllerName ): DispatcherInterface;
```
Sets the default controller name
handleException()
```php
protected function handleException( \Exception $exception );
```
Handles a user exception
throwDispatchException()
```php
protected function throwDispatchException(
string $message,
int $exceptionCode = 0
);
```
Throws an internal exception
## Mvc\DispatcherInterface
Interface
Phalcon\Mvc\DispatcherInterface
Interface for Phalcon\Mvc\Dispatcher
- [`Phalcon\Contracts\Dispatcher\Dispatcher`](/5.20/api/phalcon_contracts/#contractsdispatcherdispatcher)
- [`Phalcon\Contracts\Mvc\Dispatcher`](/5.20/api/phalcon_contracts/#contractsmvcdispatcher)
- **`Phalcon\Mvc\DispatcherInterface`**
`Phalcon\Contracts\Mvc\Dispatcher`
## Mvc\Dispatcher\Exception
Class
Phalcon\Mvc\Dispatcher\Exception
Exceptions thrown in Phalcon\Mvc\Dispatcher will use this class
- `\Exception`
- [`Phalcon\Dispatcher\Exception`](/5.20/api/phalcon_dispatcher/#dispatcherexception)
- **`Phalcon\Mvc\Dispatcher\Exception`**
- [`Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable`](#mvcdispatcherexceptionsresponseserviceunavailable)
## Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable
Class
- `\Exception`
- [`Phalcon\Dispatcher\Exception`](/5.20/api/phalcon_dispatcher/#dispatcherexception)
- [`Phalcon\Mvc\Dispatcher\Exception`](#mvcdispatcherexception)
- **`Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable`**
`Phalcon\Mvc\Dispatcher\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\EntityInterface
Interface
Phalcon\Mvc\EntityInterface
Interface for Phalcon\Mvc\Collection and Phalcon\Mvc\Model
- **`Phalcon\Mvc\EntityInterface`**
### Method Summary
Reads an attribute value by its name
Writes an attribute value by its name
### Methods
readAttribute()
```php
public function readAttribute( string $attribute ): mixed|null;
```
Reads an attribute value by its name
writeAttribute()
```php
public function writeAttribute(
string $attribute,
mixed $value
);
```
Writes an attribute value by its name
## Mvc\Micro
Class
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.
```php
$app = new \Phalcon\Mvc\Micro();
$app->get(
"/say/welcome/{name}",
function ($name) {
echo "Welcome $name!
";
}
);
$app->handle("/say/welcome/Phalcon");
```
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Mvc\Micro`** - implements `\ArrayAccess`, [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
`ArrayAccess` · `Closure` · `Phalcon\Cache\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Di\FactoryDefault` · `Phalcon\Di\Injectable` · `Phalcon\Di\ServiceInterface` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\Manager` · `Phalcon\Events\ManagerInterface` · `Phalcon\Http\ResponseInterface` · `Phalcon\Mvc\Micro\Collection` · `Phalcon\Mvc\Micro\CollectionInterface` · `Phalcon\Mvc\Micro\Exception` · `Phalcon\Mvc\Micro\Exceptions\ContainerRequired` · `Phalcon\Mvc\Micro\Exceptions\ErrorHandlerNotCallable` · `Phalcon\Mvc\Micro\Exceptions\HandlerNotCallable` · `Phalcon\Mvc\Micro\Exceptions\InvalidRegisteredHandler` · `Phalcon\Mvc\Micro\Exceptions\MissingCollectionMainHandler` · `Phalcon\Mvc\Micro\Exceptions\NoHandlersToMount` · `Phalcon\Mvc\Micro\Exceptions\NoMatchedRouteHandler` · `Phalcon\Mvc\Micro\Exceptions\NotFoundHandlerNotCallable` · `Phalcon\Mvc\Micro\Exceptions\ResponseHandlerNotCallable` · `Phalcon\Mvc\Micro\LazyLoader` · `Phalcon\Mvc\Micro\MiddlewareInterface` · `Phalcon\Mvc\Model\BinderInterface` · `Phalcon\Mvc\Router\RouteInterface` · `Throwable`
### Method Summary
Phalcon\Mvc\Micro constructor
Appends an 'after' middleware to be called after execute the route
Appends a afterBinding middleware to be called after model binding
Appends a before middleware to be called before execute the route
Maps a route to a handler that only matches if the HTTP method is DELETE
Sets a handler that will be called when an exception is thrown handling
Appends a 'finish' middleware to be called when the request is finished
Maps a route to a handler that only matches if the HTTP method is GET
Return the handler that will be called for the matched route
Returns bound models from binder instance
Returns the internal event manager
Returns the internal handlers attached to the application
Gets model binder
Returns the value returned by the executed handler
Returns the internal router used by the application
Obtains a service from the DI
Obtains a shared service from the DI
Handle the whole request
Checks if a service is registered in the DI
Maps a route to a handler that only matches if the HTTP method is HEAD
Maps a route to a handler without any HTTP method constraint
Mounts a collection of handlers
Sets a handler that will be called when the router does not match any of
Check if a service is registered in the internal services container using
Allows to obtain a shared service in the internal services container
Allows to register a shared service in the internal services container
Removes a service from the internal services container using the array
Maps a route to a handler that only matches if the HTTP method is OPTIONS
Maps a route to a handler that only matches if the HTTP method is PATCH
Maps a route to a handler that only matches if the HTTP method is POST
Maps a route to a handler that only matches if the HTTP method is PUT
Sets externally the handler that must be called by the matched route
Sets the DependencyInjector container
Sets the events manager
Sets model binder
Appends a custom 'response' handler to be called instead of the default
Sets a service from the DI
Stops the middleware execution avoiding than other middlewares be
### Properties
### Methods
__construct()
```php
public function __construct( DiInterface|null $container = null );
```
Phalcon\Mvc\Micro constructor
after()
```php
public function after( mixed $handler ): static;
```
Appends an 'after' middleware to be called after execute the route
afterBinding()
```php
public function afterBinding( mixed $handler ): static;
```
Appends a afterBinding middleware to be called after model binding
before()
```php
public function before( mixed $handler ): static;
```
Appends a before middleware to be called before execute the route
delete()
```php
public function delete(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is DELETE
error()
```php
public function error( mixed $handler ): static;
```
Sets a handler that will be called when an exception is thrown handling
the route
finish()
```php
public function finish( mixed $handler ): static;
```
Appends a 'finish' middleware to be called when the request is finished
get()
```php
public function get(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is GET
getActiveHandler()
```php
public function getActiveHandler();
```
Return the handler that will be called for the matched route
getBoundModels()
```php
public function getBoundModels(): array;
```
Returns bound models from binder instance
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getHandlers()
```php
public function getHandlers(): array;
```
Returns the internal handlers attached to the application
getModelBinder()
```php
public function getModelBinder(): BinderInterface|null;
```
Gets model binder
getReturnedValue()
```php
public function getReturnedValue();
```
Returns the value returned by the executed handler
getRouter()
```php
public function getRouter(): RouterInterface;
```
Returns the internal router used by the application
getService()
```php
public function getService( string $serviceName );
```
Obtains a service from the DI
getSharedService()
```php
public function getSharedService( string $serviceName );
```
Obtains a shared service from the DI
handle()
```php
public function handle( string $uri );
```
Handle the whole request
hasService()
```php
public function hasService( string $serviceName ): bool;
```
Checks if a service is registered in the DI
head()
```php
public function head(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is HEAD
map()
```php
public function map(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler without any HTTP method constraint
mount()
```php
public function mount( CollectionInterface $collection ): static;
```
Mounts a collection of handlers
notFound()
```php
public function notFound( mixed $handler ): static;
```
Sets a handler that will be called when the router does not match any of
the defined routes
offsetExists()
```php
public function offsetExists( mixed $offset ): bool;
```
Check if a service is registered in the internal services container using
the array syntax
offsetGet()
```php
public function offsetGet( mixed $offset ): mixed;
```
Allows to obtain a shared service in the internal services container
using the array syntax
```php
var_dump(
$app["request"]
);
```
offsetSet()
```php
public function offsetSet(
mixed $offset,
mixed $value
): void;
```
Allows to register a shared service in the internal services container
using the array syntax
```php
$app["request"] = new \Phalcon\Http\Request();
```
offsetUnset()
```php
public function offsetUnset( mixed $offset ): void;
```
Removes a service from the internal services container using the array
syntax
options()
```php
public function options(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is OPTIONS
patch()
```php
public function patch(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is PATCH
post()
```php
public function post(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is POST
put()
```php
public function put(
string $routePattern,
mixed $handler
): RouteInterface;
```
Maps a route to a handler that only matches if the HTTP method is PUT
setActiveHandler()
```php
public function setActiveHandler( mixed $activeHandler ): self;
```
Sets externally the handler that must be called by the matched route
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the DependencyInjector container
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
setModelBinder()
```php
public function setModelBinder(
BinderInterface $modelBinder,
mixed $cache = null
): static;
```
Sets model binder
```php
$micro = new Micro($di);
$micro->setModelBinder(
new Binder(),
'cache'
);
```
setResponseHandler()
```php
public function setResponseHandler( mixed $handler ): static;
```
Appends a custom 'response' handler to be called instead of the default
response handler
setService()
```php
public function setService(
string $serviceName,
mixed $definition,
bool $isShared = false
): ServiceInterface;
```
Sets a service from the DI
stop()
```php
public function stop(): void;
```
Stops the middleware execution avoiding than other middlewares be
executed
## Mvc\Micro\Collection
Class
Phalcon\Mvc\Micro\Collection
Groups Micro-Mvc handlers as controllers
```php
$app = new \Phalcon\Mvc\Micro();
$collection = new Collection();
$collection->setHandler(
new PostsController()
);
$collection->get("/posts/edit/{id}", "edit");
$app->mount($collection);
```
- **`Phalcon\Mvc\Micro\Collection`** - implements [`Phalcon\Mvc\Micro\CollectionInterface`](#mvcmicrocollectioninterface)
### Method Summary
Maps a route to a handler that only matches if the HTTP method is DELETE.
Maps a route to a handler that only matches if the HTTP method is GET.
Returns the main handler
Returns the registered handlers
Returns the collection prefix if any
Maps a route to a handler that only matches if the HTTP method is HEAD.
Returns if the main handler must be lazy loaded
Maps a route to a handler.
Maps a route to a handler via methods.
Maps a route to a handler that only matches if the HTTP method is
Maps a route to a handler that only matches if the HTTP method is PATCH.
Maps a route to a handler that only matches if the HTTP method is POST.
Maps a route to a handler that only matches if the HTTP method is PUT.
Sets the main handler.
Sets if the main handler must be lazy loaded
Sets a prefix for all routes added to the collection
Internal function to add a handler to the group.
### Properties
### Methods
delete()
```php
public function delete(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is DELETE.
get()
```php
public function get(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is GET.
getHandler()
```php
public function getHandler(): mixed;
```
Returns the main handler
getHandlers()
```php
public function getHandlers(): array;
```
Returns the registered handlers
getPrefix()
```php
public function getPrefix(): string;
```
Returns the collection prefix if any
head()
```php
public function head(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is HEAD.
isLazy()
```php
public function isLazy(): bool;
```
Returns if the main handler must be lazy loaded
map()
```php
public function map(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler.
mapVia()
```php
public function mapVia(
string $routePattern,
callable $handler,
mixed $method,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler via methods.
```php
$collection->mapVia(
"/test",
"indexAction",
["POST", "GET"],
"test"
);
```
options()
```php
public function options(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is
OPTIONS.
patch()
```php
public function patch(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is PATCH.
post()
```php
public function post(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is POST.
put()
```php
public function put(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is PUT.
setHandler()
```php
public function setHandler(
mixed $handler,
bool $isLazy = false
): CollectionInterface;
```
Sets the main handler.
setLazy()
```php
public function setLazy( bool $isLazy ): CollectionInterface;
```
Sets if the main handler must be lazy loaded
setPrefix()
```php
public function setPrefix( string $prefix ): CollectionInterface;
```
Sets a prefix for all routes added to the collection
addMap()
```php
protected function addMap(
mixed $method,
string $routePattern,
callable $handler,
string|null $name = null
): void;
```
Internal function to add a handler to the group.
## Mvc\Micro\CollectionInterface
Interface
Phalcon\Mvc\Micro\CollectionInterface
Interface for Phalcon\Mvc\Micro\Collection
- **`Phalcon\Mvc\Micro\CollectionInterface`**
### Method Summary
Maps a route to a handler that only matches if the HTTP method is DELETE
Maps a route to a handler that only matches if the HTTP method is GET
Returns the main handler
Returns the registered handlers
Returns the collection prefix if any
Maps a route to a handler that only matches if the HTTP method is HEAD
Returns if the main handler must be lazy loaded
Maps a route to a handler
Maps a route to a handler that only matches if the HTTP method is OPTIONS
Maps a route to a handler that only matches if the HTTP method is PATCH
Maps a route to a handler that only matches if the HTTP method is POST
Maps a route to a handler that only matches if the HTTP method is PUT
Sets the main handler
Sets if the main handler must be lazy loaded
Sets a prefix for all routes added to the collection
### Methods
delete()
```php
public function delete(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is DELETE
get()
```php
public function get(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is GET
getHandler()
```php
public function getHandler(): mixed;
```
Returns the main handler
getHandlers()
```php
public function getHandlers(): array;
```
Returns the registered handlers
getPrefix()
```php
public function getPrefix(): string;
```
Returns the collection prefix if any
head()
```php
public function head(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is HEAD
isLazy()
```php
public function isLazy(): bool;
```
Returns if the main handler must be lazy loaded
map()
```php
public function map(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler
options()
```php
public function options(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is OPTIONS
patch()
```php
public function patch(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is PATCH
post()
```php
public function post(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is POST
put()
```php
public function put(
string $routePattern,
callable $handler,
string|null $name = null
): CollectionInterface;
```
Maps a route to a handler that only matches if the HTTP method is PUT
setHandler()
```php
public function setHandler(
mixed $handler,
bool $isLazy = false
): CollectionInterface;
```
Sets the main handler
setLazy()
```php
public function setLazy( bool $isLazy ): CollectionInterface;
```
Sets if the main handler must be lazy loaded
setPrefix()
```php
public function setPrefix( string $prefix ): CollectionInterface;
```
Sets a prefix for all routes added to the collection
## Mvc\Micro\Exception
Class
Exceptions thrown in Phalcon\Mvc\Micro will use this class
- `\Exception`
- **`Phalcon\Mvc\Micro\Exception`**
- [`Phalcon\Mvc\Micro\Exceptions\ContainerRequired`](#mvcmicroexceptionscontainerrequired)
- [`Phalcon\Mvc\Micro\Exceptions\ErrorHandlerNotCallable`](#mvcmicroexceptionserrorhandlernotcallable)
- [`Phalcon\Mvc\Micro\Exceptions\HandlerNotCallable`](#mvcmicroexceptionshandlernotcallable)
- [`Phalcon\Mvc\Micro\Exceptions\InvalidRegisteredHandler`](#mvcmicroexceptionsinvalidregisteredhandler)
- [`Phalcon\Mvc\Micro\Exceptions\LazyHandlerNotFound`](#mvcmicroexceptionslazyhandlernotfound)
- [`Phalcon\Mvc\Micro\Exceptions\MissingCollectionMainHandler`](#mvcmicroexceptionsmissingcollectionmainhandler)
- [`Phalcon\Mvc\Micro\Exceptions\NoHandlersToMount`](#mvcmicroexceptionsnohandlerstomount)
- [`Phalcon\Mvc\Micro\Exceptions\NoMatchedRouteHandler`](#mvcmicroexceptionsnomatchedroutehandler)
- [`Phalcon\Mvc\Micro\Exceptions\NotFoundHandlerNotCallable`](#mvcmicroexceptionsnotfoundhandlernotcallable)
- [`Phalcon\Mvc\Micro\Exceptions\ResponseHandlerNotCallable`](#mvcmicroexceptionsresponsehandlernotcallable)
## Mvc\Micro\Exceptions\ContainerRequired
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\ContainerRequired`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\ErrorHandlerNotCallable
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\ErrorHandlerNotCallable`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\HandlerNotCallable
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\HandlerNotCallable`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $type );
```
## Mvc\Micro\Exceptions\InvalidRegisteredHandler
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\InvalidRegisteredHandler`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\LazyHandlerNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\LazyHandlerNotFound`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $definition );
```
## Mvc\Micro\Exceptions\MissingCollectionMainHandler
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\MissingCollectionMainHandler`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\NoHandlersToMount
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\NoHandlersToMount`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\NoMatchedRouteHandler
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\NoMatchedRouteHandler`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\NotFoundHandlerNotCallable
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\NotFoundHandlerNotCallable`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\Exceptions\ResponseHandlerNotCallable
Class
- `\Exception`
- [`Phalcon\Mvc\Micro\Exception`](#mvcmicroexception)
- **`Phalcon\Mvc\Micro\Exceptions\ResponseHandlerNotCallable`**
`Phalcon\Mvc\Micro\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Micro\LazyLoader
Class
Phalcon\Mvc\Micro\LazyLoader
Lazy-Load of handlers for Mvc\Micro using auto-loading
- **`Phalcon\Mvc\Micro\LazyLoader`**
`Phalcon\Mvc\Micro\Exceptions\LazyHandlerNotFound` · `Phalcon\Mvc\Model\BinderInterface`
### Method Summary
Phalcon\Mvc\Micro\LazyLoader constructor
Calling __call method
### Properties
### Methods
__construct()
```php
public function __construct( string $definition );
```
Phalcon\Mvc\Micro\LazyLoader constructor
callMethod()
```php
public function callMethod(
string $method,
mixed $arguments,
BinderInterface|null $modelBinder = null
);
```
Calling __call method
getDefinition()
```php
public function getDefinition(): string;
```
getHandler()
```php
public function getHandler(): object|null;
```
## Mvc\Micro\MiddlewareInterface
Interface
Allows to implement Phalcon\Mvc\Micro middleware in classes
- **`Phalcon\Mvc\Micro\MiddlewareInterface`**
`Phalcon\Mvc\Micro`
### Method Summary
Calls the middleware
### Methods
call()
```php
public function call( Micro $application );
```
Calls the middleware
## Mvc\Model
Abstract
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.
```php
$invoice = new Invoices();
$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;
if ($invoice->save() === false) {
echo "Umh, We can store invoices: ";
$messages = $invoice->getMessages();
foreach ($messages as $message) {
echo $message;
}
} else {
echo "Great, a new invoice was saved successfully!";
}
```
Magic property and method resolution:
`__get($property)` resolves in order: a relation alias (returning unsaved
`dirtyRelated` records first, then a non-reusable single related model held
in the `related` cache - resultsets and reusable relations are never served
from that cache - otherwise the freshly fetched related records); then a
`get()` getter when one exists; otherwise it raises an
"undefined property" notice and returns null.
`__call()` / `__callStatic($method, $arguments)` resolve the `findBy`,
`findFirstBy`, and `countBy` magic finders through
`invokeFinder()`. The instance `__call()` additionally tries relation getters
and a behavior/listener `missingMethod()` hook. An unresolved method throws
`Phalcon\Mvc\Model\Exceptions\MethodNotFound`.
@template T of static
- `\stdClass`
- [`Phalcon\Di\AbstractInjectionAware`](/5.20/api/phalcon_di/#diabstractinjectionaware)
- **`Phalcon\Mvc\Model`** - implements [`Phalcon\Mvc\EntityInterface`](#mvcentityinterface), [`Phalcon\Mvc\ModelInterface`](#mvcmodelinterface), [`Phalcon\Mvc\Model\ResultInterface`](#mvcmodelresultinterface), `\JsonSerializable`
`JsonSerializable` · `Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Db\Column` · `Phalcon\Db\DialectInterface` · `Phalcon\Db\Enum` · `Phalcon\Db\Geometry\WkbParser` · `Phalcon\Db\RawValue` · `Phalcon\Di\AbstractInjectionAware` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Filter\Validation\ValidationInterface` · `Phalcon\Messages\Message` · `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\BehaviorInterface` · `Phalcon\Mvc\Model\Criteria` · `Phalcon\Mvc\Model\CriteriaInterface` · `Phalcon\Mvc\Model\Eager\Loader` · `Phalcon\Mvc\Model\Eager\PathTree` · `Phalcon\Mvc\Model\Exception` · `Phalcon\Mvc\Model\Exceptions\BelongsToRequiresObject` · `Phalcon\Mvc\Model\Exceptions\BindTypeNotDefined` · `Phalcon\Mvc\Model\Exceptions\CannotResolveAttribute` · `Phalcon\Mvc\Model\Exceptions\ColumnNotInMap` · `Phalcon\Mvc\Model\Exceptions\ColumnNotInTableColumns` · `Phalcon\Mvc\Model\Exceptions\ColumnNotInTableMap` · `Phalcon\Mvc\Model\Exceptions\DataTypeNotDefined` · `Phalcon\Mvc\Model\Exceptions\IdentityNotInColumnMap` · `Phalcon\Mvc\Model\Exceptions\IdentityNotInTableColumns` · `Phalcon\Mvc\Model\Exceptions\InvalidDumpResultKey` · `Phalcon\Mvc\Model\Exceptions\InvalidEagerParameter` · `Phalcon\Mvc\Model\Exceptions\InvalidFindParameters` · `Phalcon\Mvc\Model\Exceptions\InvalidModelsManagerService` · `Phalcon\Mvc\Model\Exceptions\InvalidModelsMetadataService` · `Phalcon\Mvc\Model\Exceptions\MethodNotFound` · `Phalcon\Mvc\Model\Exceptions\ModelOrmServicesUnavailable` · `Phalcon\Mvc\Model\Exceptions\PrimaryKeyAttributeNotSet` · `Phalcon\Mvc\Model\Exceptions\PrimaryKeyRequired` · `Phalcon\Mvc\Model\Exceptions\PropertyNotAccessible` · `Phalcon\Mvc\Model\Exceptions\RecordCannotRefresh` · `Phalcon\Mvc\Model\Exceptions\RecordNotPersisted` · `Phalcon\Mvc\Model\Exceptions\RelationNotDefined` · `Phalcon\Mvc\Model\Exceptions\RelationRequiresObjectOrArray` · `Phalcon\Mvc\Model\Exceptions\SnapshotsDisabled` · `Phalcon\Mvc\Model\Exceptions\StaticMethodRequiresOneArgument` · `Phalcon\Mvc\Model\Exceptions\UnsupportedEagerHydration` · `Phalcon\Mvc\Model\Exceptions\UnsupportedEagerResultset` · `Phalcon\Mvc\Model\Exceptions\UpdateSnapshotDisabled` · `Phalcon\Mvc\Model\Hydration\CloneResultMapHydrate` · `Phalcon\Mvc\Model\ManagerInterface` · `Phalcon\Mvc\Model\MetaDataInterface` · `Phalcon\Mvc\Model\Query` · `Phalcon\Mvc\Model\QueryInterface` · `Phalcon\Mvc\Model\Query\Builder` · `Phalcon\Mvc\Model\Query\BuilderInterface` · `Phalcon\Mvc\Model\Relation` · `Phalcon\Mvc\Model\RelationInterface` · `Phalcon\Mvc\Model\ResultInterface` · `Phalcon\Mvc\Model\Resultset` · `Phalcon\Mvc\Model\ResultsetInterface` · `Phalcon\Mvc\Model\Resultset\Simple` · `Phalcon\Mvc\Model\TransactionInterface` · `Phalcon\Mvc\Model\ValidationFailed` · `Phalcon\Support\Collection` · `Phalcon\Support\Collection\CollectionInterface` · `Phalcon\Support\Settings` · `ReflectionClass` · `ReflectionProperty`
### Method Summary
Handles method calls when a method is not implemented
Handles method calls when a static method is not implemented
Phalcon\Mvc\Model constructor
Magic method to get related records using the relation alias as a
Magic method to check if a property is a valid relation
Serializes a model
Magic method to assign values to the the model
Unserializes an array to the model
Setups a behavior in a model
Appends a customized message on the validation process
Append messages to this model from another Model.
Assigns values to a model from an array
Returns the average value on a column for a result-set of rows matching
Assigns values to a model from an array returning a new model
Assigns values to a model from an array, returning a new model.
Returns an hydrated result based on the data and the column map
Counts how many records match the specified conditions.
Inserts a model instance. If the instance already exists in the
Deletes a model instance. Returning true on success or false otherwise.
Inserted or updates model instance, expects a visited list of objects.
Returns a simple representation of the object that can be used with
Query for a set of records that match the specified conditions
Query the first record that matches the specified conditions
Fires an event, implicitly calls behaviors and listeners in the events
Fires an event, implicitly calls behaviors and listeners in the events
Returns a list of changed values.
Returns one of the DIRTY_STATE_* constants telling if the record exists
Returns the custom events manager or null if there is no custom events manager
Returns array of validation messages
Returns the models manager related to the entity instance
\{@inheritdoc\}
Returns the internal old snapshot data
Returns the type of the latest operation performed by the ORM
Gets the connection used to read data for the model
Returns the DependencyInjection connection service name used to read data
Returns related records based on defined relations
Returns schema name where the mapped table is located
Returns the internal snapshot data
Returns the table name mapped in the model
Returns a list of updated values.
Gets the connection used to write data to the model
Returns the DependencyInjection connection service name used to write
Check if a specific attribute has changed
Checks if the object has internal snapshot data
Check if a specific attribute was updated
Checks if saved related records have already been loaded.
Serializes the object for json_encode
Returns the maximum value of a column for a result-set of rows that match
Returns the minimum value of a column for a result-set of rows that match
Create a criteria for a specific model
Reads an attribute value by its name
Refreshes the model attributes re-querying the record from the database
Inserts or updates a model instance. Returning true on success or false
Serializes the object ignoring connections, services, related objects or
Sets the DependencyInjection connection service name
Sets the dirty state of the object using one of the DIRTY_STATE_* constants
Sets a custom events manager
Sets the record's old snapshot data.
Sets the DependencyInjection connection service name used to read data
Stores related records in the relation cache, so that a subsequent
Sets the record's snapshot data.
Marks one or more many-to-many relationships to be synchronized (or not)
Sets a transaction related to the Model instance
Sets the DependencyInjection connection service name used to write data
Enables/disables options in the ORM.
Skips the current operation forcing a success state
Calculates the sum on a column for a result-set of rows that match the
Returns the instance as an array representation
Unserializes the object from a serialized string
Updates a model instance. If the instance does not exist in the
Check whether validation process has generated any messages
Writes an attribute value by its name
Sets a list of attributes that must be skipped from the
Setup a reverse 1-1 or n-1 relation between two models
Cancel the current operation
Reads "belongs to" relations and check the virtual foreign keys when
Reads both "hasMany" and "hasOne" relations and checks the virtual
Reads both "hasMany" and "hasOne" relations and checks the virtual
Collects previously queried (belongs-to, has-one and has-one-through)
Sends a pre-build INSERT SQL statement to the relational database system
Sends a pre-build UPDATE SQL statement to the relational database system
Returns related records defined relations depending on the method name.
Generate a PHQL SELECT statement for an aggregate
Checks whether the current record already exists
Setup a 1-n relation between two models
Setup an n-n relation between two models, through an intermediate
Setup a 1-1 relation between two models
Setup a 1-1 relation between two models, through an intermediate
Try to check if the query must invoke a finder
Sets if the model must keep the original record snapshot in memory
Check for, and attempt to use, possible setter.
Executes internal events after save a record
Save the related records assigned in the has-one/has-many relations
Executes internal hooks before save a record
Saves related records that must be stored prior to save the master record
Sets schema name where the mapped table is located
Sets the table name to which model should be mapped
Sets a list of attributes that must be skipped from the
Sets a list of attributes that must be skipped from the
Sets a list of attributes that must be skipped from the
Sets if a model must use dynamic update instead of the all-field update
Executes validators on every validation call
### Constants
### Properties
Per-save many-to-many sync overrides, keyed by lowercased relation
alias (or "*" wildcard) => bool. Cleared after each save().
### Methods
__call()
```php
public function __call(
string $method,
array $arguments
);
```
Handles method calls when a method is not implemented
__callStatic()
```php
public static function __callStatic(
string $method,
array $arguments
);
```
Handles method calls when a static method is not implemented
__construct()
```php
final public function __construct(
mixed $data = null,
DiInterface|null $container = null,
ManagerInterface|null $modelsManager = null
);
```
Phalcon\Mvc\Model constructor
__get()
```php
public function __get( string $property );
```
Magic method to get related records using the relation alias as a
property
__isset()
```php
public function __isset( string $property ): bool;
```
Magic method to check if a property is a valid relation
__serialize()
```php
public function __serialize(): array;
```
Serializes a model
__set()
```php
public function __set(
string $property,
mixed $value
);
```
Magic method to assign values to the the model
__unserialize()
```php
public function __unserialize( array $data ): void;
```
Unserializes an array to the model
addBehavior()
```php
public function addBehavior( BehaviorInterface $behavior ): void;
```
Setups a behavior in a model
```php
use Phalcon\Mvc\Model;
use Phalcon\Mvc\Model\Behavior\Timestampable;
class Invoices 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",
],
]
)
);
}
}
```
appendMessage()
```php
public function appendMessage( MessageInterface $message ): ModelInterface;
```
Appends a customized message on the validation process
```php
use Phalcon\Mvc\Model;
use Phalcon\Messages\Message as Message;
class Invoices extends Model
{
public function beforeSave()
{
if ($this->name === "Peter") {
$message = new Message(
"Sorry, but an invoice cannot be named Peter"
);
$this->appendMessage($message);
}
}
}
```
appendMessagesFrom()
```php
public inline function appendMessagesFrom( mixed $model ): void;
```
Append messages to this model from another Model.
assign()
```php
public function assign(
array $data,
mixed $whiteList = null,
mixed $dataColumnMap = null
): ModelInterface;
```
Assigns values to a model from an array
```php
$invoice->assign(
[
"type" => "mechanical",
"name" => "Test Invoice",
"year" => 1952,
]
);
// Assign by db row, column map needed
$invoice->assign(
$dbRow,
[
"db_type" => "type",
"db_name" => "name",
"db_year" => "year",
]
);
// Allow assign only name and year
$invoice->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);
$invoice->assign(
$_POST,
[
"name",
"year",
]
);
```
average()
```php
public static function average( array $parameters = [] ): float|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.
```php
// What's the average price of invoices?
$average = Invoices::average(
[
"column" => "inv_total",
]
);
echo "The average price is ", $average, "\n";
// What's the average price of paid invoices?
$average = Invoices::average(
[
"inv_status_flag = 1",
"column" => "inv_total",
]
);
echo "The average price of paid invoices is ", $average, "\n";
```
cloneResult()
```php
public static function cloneResult(
ModelInterface $base,
array $data,
int $dirtyState = 0
): ModelInterface;
```
Assigns values to a model from an array returning a new model
```php
$invoice = Phalcon\Mvc\Model::cloneResult(
new Invoices(),
[
"type" => "mechanical",
"name" => "Test Invoice",
"year" => 1952,
]
);
```
cloneResultMap()
```php
public static function cloneResultMap(
mixed $base,
array $data,
mixed $columnMap,
int $dirtyState = 0,
bool|null $keepSnapshots = null
): ModelInterface;
```
Assigns values to a model from an array, returning a new model.
```php
$invoice = \Phalcon\Mvc\Model::cloneResultMap(
new Invoices(),
[
"type" => "mechanical",
"name" => "Test Invoice",
"year" => 1952,
]
);
```
cloneResultMapHydrate()
```php
public static function cloneResultMapHydrate(
array $data,
mixed $columnMap,
int $hydrationMode
);
```
Returns an hydrated result based on the data and the column map
count()
```php
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.
```php
// How many invoices are there?
$number = Invoices::count();
echo "There are ", $number, "\n";
// How many paid invoices are there?
$number = Invoices::count("inv_status_flag = 1");
echo "There are ", $number, " paid invoices\n";
```
create()
```php
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.
```php
// Creating a new invoice
$invoice = new Invoices();
$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;
$invoice->create();
// Passing an array to create
$invoice = new Invoices();
$invoice->assign(
[
"type" => "mechanical",
"name" => "Test Invoice",
"year" => 1952,
]
);
$invoice->create();
```
delete()
```php
public function delete(): bool;
```
Deletes a model instance. Returning true on success or false otherwise.
```php
$invoice = Invoices::findFirst("id=100");
$invoice->delete();
$invoices = Invoices::find("inv_status_flag = 1");
foreach ($invoices as $invoice) {
$invoice->delete();
}
```
doSave()
```php
public function doSave( CollectionInterface $visited ): bool;
```
Inserted or updates model instance, expects a visited list of objects.
dump()
```php
public function dump(): array;
```
Returns a simple representation of the object that can be used with
`var_dump()`
```php
var_dump(
$invoice->dump()
);
```
find()
```php
public static function find( mixed $parameters = null ): ResultsetInterface;
```
Query for a set of records that match the specified conditions
```php
// How many invoices are there?
$invoices = Invoices::find();
echo "There are ", count($invoices), "\n";
// How many paid invoices are there?
$invoices = Invoices::find(
"inv_status_flag = 1"
);
echo "There are ", count($invoices), "\n";
// Get and print virtual invoices ordered by name
$invoices = Invoices::find(
[
"type = 'virtual'",
"order" => "name",
]
);
foreach ($invoices as $invoice) {
echo $invoice->inv_title, "\n";
}
// Get first 100 virtual invoices ordered by name
$invoices = Invoices::find(
[
"type = 'virtual'",
"order" => "name",
"limit" => 100,
]
);
foreach ($invoices as $invoice) {
echo $invoice->inv_title, "\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();
$newInvoices = new Invoices();
$newInvoices->setTransaction($myTransaction);
$newInvoices->assign(
[
'name' => 'test',
'type' => 'mechanical',
'year' => 1944,
]
);
$newInvoices->save();
$resultInsideTransaction = Invoices::find(
[
'name' => 'test',
Model::TRANSACTION_INDEX => $myTransaction,
]
);
$resultOutsideTransaction = Invoices::find(['name' => 'test']);
foreach ($setInsideTransaction as $invoice) {
echo $invoice->inv_title, "\n";
}
foreach ($setOutsideTransaction as $invoice) {
echo $invoice->inv_title, "\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 invoices
$firstNewInvoices = new Invoices();
$firstNewInvoices->setTransaction($myTransaction1);
$firstNewInvoices->assign(
[
'name' => 'first-transaction-invoice',
'type' => 'mechanical',
'year' => 1944,
]
);
$firstNewInvoices->save();
$secondNewInvoices = new Invoices();
$secondNewInvoices->setTransaction($myTransaction2);
$secondNewInvoices->assign(
[
'name' => 'second-transaction-invoice',
'type' => 'fictional',
'year' => 1984,
]
);
$secondNewInvoices->save();
// this transaction will find the invoice.
$resultInFirstTransaction = Invoices::find(
[
'name' => 'first-transaction-invoice',
Model::TRANSACTION_INDEX => $myTransaction1,
]
);
// this transaction won't find the invoice.
$resultInSecondTransaction = Invoices::find(
[
'name' => 'first-transaction-invoice',
Model::TRANSACTION_INDEX => $myTransaction2,
]
);
// this transaction won't find the invoice.
$resultOutsideAnyExplicitTransaction = Invoices::find(
[
'name' => 'first-transaction-invoice',
]
);
// this transaction won't find the invoice.
$resultInFirstTransaction = Invoices::find(
[
'name' => 'second-transaction-invoice',
Model::TRANSACTION_INDEX => $myTransaction2,
]
);
// this transaction will find the invoice.
$resultInSecondTransaction = Invoices::find(
[
'name' => 'second-transaction-invoice',
Model::TRANSACTION_INDEX => $myTransaction1,
]
);
// this transaction won't find the invoice.
$resultOutsideAnyExplicitTransaction = Invoices::find(
[
'name' => 'second-transaction-invoice',
]
);
$transaction1->rollback();
$transaction2->rollback();
```
findFirst()
```php
public static function findFirst( mixed $parameters = null ): mixed|null;
```
Query the first record that matches the specified conditions
```php
// What's the first invoice in invoices table?
$invoice = Invoices::findFirst();
echo "The invoice name is ", $invoice->inv_title;
// What's the first paid invoice in invoices table?
$invoice = Invoices::findFirst(
"inv_status_flag = 1"
);
echo "The first paid invoice name is ", $invoice->inv_title;
// Get first virtual invoice ordered by name
$invoice = Invoices::findFirst(
[
"type = 'virtual'",
"order" => "name",
]
);
echo "The first virtual invoice name is ", $invoice->inv_title;
// behavior with transaction
$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();
$newInvoices = new Invoices();
$newInvoices->setTransaction($myTransaction);
$newInvoices->assign(
[
'name' => 'test',
'type' => 'mechanical',
'year' => 1944,
]
);
$newInvoices->save();
$findsAInvoices = Invoices::findFirst(
[
'name' => 'test',
Model::TRANSACTION_INDEX => $myTransaction,
]
);
$doesNotFindAInvoices = Invoices::findFirst(
[
'name' => 'test',
]
);
var_dump($findAInvoices);
var_dump($doesNotFindAInvoices);
$transaction->commit();
$doesFindTheInvoicesNow = Invoices::findFirst(
[
'name' => 'test',
]
);
```
fireEvent()
```php
public function fireEvent( string $eventName ): bool;
```
Fires an event, implicitly calls behaviors and listeners in the events
manager are notified
fireEventCancel()
```php
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
getChangedFields()
```php
public function getChangedFields(): array;
```
Returns a list of changed values.
```php
$invoices = Invoices::findFirst();
print_r($invoices->getChangedFields()); // []
$invoices->deleted = 'Y';
$invoices->getChangedFields();
print_r($invoices->getChangedFields()); // ["deleted"]
```
getDirtyState()
```php
public function getDirtyState(): int;
```
Returns one of the DIRTY_STATE_* constants telling if the record exists
in the database or not
getEventsManager()
```php
public function getEventsManager(): EventsManagerInterface|null;
```
Returns the custom events manager or null if there is no custom events manager
getMessages()
```php
public function getMessages( mixed $filter = null ): MessageInterface[];
```
Returns array of validation messages
```php
$invoice = new Invoices();
$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;
if ($invoice->save() === false) {
echo "Umh, We can't store invoices right now ";
$messages = $invoice->getMessages();
foreach ($messages as $message) {
echo $message;
}
} else {
echo "Great, a new invoice was saved successfully!";
}
```
getModelsManager()
```php
public function getModelsManager(): ManagerInterface;
```
Returns the models manager related to the entity instance
```php
public function getModelsMetaData(): MetaDataInterface;
```
\{@inheritdoc\}
getOldSnapshotData()
```php
public function getOldSnapshotData(): array;
```
Returns the internal old snapshot data
getOperationMade()
```php
public function getOperationMade(): int;
```
Returns the type of the latest operation performed by the ORM
Returns one of the OP_* class constants
getReadConnection()
```php
final public function getReadConnection(): AdapterInterface;
```
Gets the connection used to read data for the model
getReadConnectionService()
```php
final public function getReadConnectionService(): string;
```
Returns the DependencyInjection connection service name used to read data
related the model
```php
public function getRelated(
string $alias,
mixed $arguments = null
);
```
Returns related records based on defined relations
getSchema()
```php
final public function getSchema(): string|null;
```
Returns schema name where the mapped table is located
getSnapshotData()
```php
public function getSnapshotData(): array;
```
Returns the internal snapshot data
getSource()
```php
final public function getSource(): string;
```
Returns the table name mapped in the model
getTransaction()
```php
public function getTransaction(): TransactionInterface|null;
```
getUpdatedFields()
```php
public function getUpdatedFields(): array;
```
Returns a list of updated values.
```php
$invoices = Invoices::findFirst();
print_r($invoices->getChangedFields()); // []
$invoices->deleted = 'Y';
$invoices->getChangedFields();
print_r($invoices->getChangedFields()); // ["deleted"]
$invoices->save();
print_r($invoices->getChangedFields()); // []
print_r($invoices->getUpdatedFields()); // ["deleted"]
```
getWriteConnection()
```php
final public function getWriteConnection(): AdapterInterface;
```
Gets the connection used to write data to the model
getWriteConnectionService()
```php
final public function getWriteConnectionService(): string;
```
Returns the DependencyInjection connection service name used to write
data related to the model
hasChanged()
```php
public function hasChanged(
mixed $fieldName = null,
bool $allFields = false
): bool;
```
Check if a specific attribute has changed
This only works if the model is keeping data snapshots
```php
$invoice = new Invoices();
$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;
$invoice->create();
$invoice->inv_status_flag = "hydraulic";
$hasChanged = $invoice->hasChanged("type"); // returns true
$hasChanged = $invoice->hasChanged(["type", "name"]); // returns true
$hasChanged = $invoice->hasChanged(["type", "name"], true); // returns false
```
hasSnapshotData()
```php
public function hasSnapshotData(): bool;
```
Checks if the object has internal snapshot data
hasUpdated()
```php
public function hasUpdated(
mixed $fieldName = null,
bool $allFields = false
): bool;
```
Check if a specific attribute was updated
This only works if the model is keeping data snapshots
isRelationshipLoaded()
```php
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.
```php
$invoice = Invoices::findFirst();
var_dump($invoice->isRelationshipLoaded('ordersProducts')); // false
$invoicesParts = $invoice->getOrdersProducts(['id > 0']);
var_dump($invoice->isRelationshipLoaded('ordersProducts')); // false
$invoicesParts = $invoice->getOrdersProducts(); // or $invoice->ordersProducts
var_dump($invoice->isRelationshipLoaded('ordersProducts')); // true
$invoice->ordersProducts = [new OrdersProducts()];
var_dump($invoice->isRelationshipLoaded('ordersProducts')); // false
```
jsonSerialize()
```php
public function jsonSerialize(): array;
```
Serializes the object for json_encode
```php
echo json_encode($invoice);
```
maximum()
```php
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
```php
// What is the maximum invoice id?
$id = Invoices::maximum(
[
"column" => "id",
]
);
echo "The maximum invoice id is: ", $id, "\n";
// What is the maximum id of paid invoices?
$sum = Invoices::maximum(
[
"inv_status_flag = 1",
"column" => "id",
]
);
echo "The maximum invoice id of paid invoices is ", $id, "\n";
```
minimum()
```php
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
```php
// What is the minimum invoice id?
$id = Invoices::minimum(
[
"column" => "id",
]
);
echo "The minimum invoice id is: ", $id;
// What is the minimum id of paid invoices?
$sum = Invoices::minimum(
[
"inv_status_flag = 1",
"column" => "id",
]
);
echo "The minimum invoice id of paid invoices is ", $id;
```
query()
```php
public static function query( DiInterface|null $container = null ): CriteriaInterface;
```
Create a criteria for a specific model
readAttribute()
```php
public function readAttribute( string $attribute ): mixed|null;
```
Reads an attribute value by its name
```php
echo $invoice->readAttribute("name");
```
refresh()
```php
public function refresh(): ModelInterface;
```
Refreshes the model attributes re-querying the record from the database
save()
```php
public function save(): bool;
```
Inserts or updates a model instance. Returning true on success or false
otherwise.
```php
// Creating a new invoice
$invoice = new Invoices();
$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;
$invoice->save();
// Updating an invoice name
$invoice = Invoices::findFirst("id = 100");
$invoice->inv_title = "Biomass";
$invoice->save();
```
serialize()
```php
public function serialize(): string|null;
```
Serializes the object ignoring connections, services, related objects or
static properties
setConnectionService()
```php
final public function setConnectionService( string $connectionService ): void;
```
Sets the DependencyInjection connection service name
setDirtyState()
```php
public function setDirtyState( int $dirtyState ): ModelInterface|bool;
```
Sets the dirty state of the object using one of the DIRTY_STATE_* constants
setEventsManager()
```php
public function setEventsManager( EventsManagerInterface $eventsManager );
```
Sets a custom events manager
setOldSnapshotData()
```php
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
setReadConnectionService()
```php
final public function setReadConnectionService( string $connectionService ): void;
```
Sets the DependencyInjection connection service name used to read data
```php
public function setRelated(
string $alias,
mixed $records
): ModelInterface;
```
Stores related records in the relation cache, so that a subsequent
getRelated() or property access returns them without querying.
This is the write side of the cache getRelated() already reads. It does
not mark the record dirty: the value lands in `related`, never in
`dirtyRelated`, so save() is unaffected.
setSnapshotData()
```php
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
setSync()
```php
public function setSync(
mixed $elements = null,
bool $enabled = true
): ModelInterface;
```
Marks one or more many-to-many relationships to be synchronized (or not)
on the next save() call, overriding the relation's `sync` option for that
save only. The flag is cleared after save().
When syncing is enabled, intermediate rows for related records no longer
present in the assigned array are deleted.
```php
// Sync only the "tags" relationship on this save
$post->setSync("tags")->save();
// Sync every many-to-many relationship on this save
$post->setSync()->save();
// Disable syncing for every relationship on this save
$post->setSync("*", false)->save();
// Disable syncing for specific relationships on this save
$post->setSync(["tags", "categories"], false)->save();
```
setTransaction()
```php
public function setTransaction( TransactionInterface $transaction ): ModelInterface;
```
Sets a transaction related to the Model instance
```php
use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
try {
$txManager = new TxManager();
$transaction = $txManager->get();
$invoice = new Invoices();
$invoice->setTransaction($transaction);
$invoice->inv_title = "WALL·E";
$invoice->created_at = date("Y-m-d");
if ($invoice->save() === false) {
$transaction->rollback("Can't save invoice");
}
$invoicePart = new OrdersProducts();
$invoicePart->setTransaction($transaction);
$invoicePart->type = "head";
if ($invoicePart->save() === false) {
$transaction->rollback("Invoices part cannot be saved");
}
$transaction->commit();
} catch (TxFailed $e) {
echo "Failed, reason: ", $e->getMessage();
}
```
setWriteConnectionService()
```php
final public function setWriteConnectionService( string $connectionService ): void;
```
Sets the DependencyInjection connection service name used to write data
setup()
```php
public static function setup( array $options ): void;
```
Enables/disables options in the ORM.
The options are written to process-global `Phalcon\Support\Settings`
(`orm.*` flags) and therefore affect every model in the process at once.
Call this once during bootstrap; it is not per-model or per-container
configuration, and one application's `setup()` reconfigures the ORM for
every other user in the same process.
skipOperation()
```php
public function skipOperation( bool $skip ): void;
```
Skips the current operation forcing a success state
sum()
```php
public static function sum( mixed $parameters = null ): float|ResultsetInterface;
```
Calculates the sum on a column for a result-set of rows that match the
specified conditions
```php
// How much are all invoices?
$sum = Invoices::sum(
[
"column" => "inv_total",
]
);
echo "The total price of invoices is ", $sum, "\n";
// How much are paid invoices?
$sum = Invoices::sum(
[
"inv_status_flag = 1",
"column" => "inv_total",
]
);
echo "The total price of paid invoices is ", $sum, "\n";
```
toArray()
```php
public function toArray(
mixed $columns = null,
mixed $useGetter = true
): array;
```
Returns the instance as an array representation
```php
print_r(
$invoice->toArray()
);
```
unserialize()
```php
public function unserialize( string $data ): void;
```
Unserializes the object from a serialized string
update()
```php
public function update(): bool;
```
Updates a model instance. If the instance does not exist in the
persistence it will throw an exception. Returning `true` on success or
`false` otherwise.
```php
inv_total = 120;
$invoice->update();
```
!!! warning "NOTE"
When retrieving the record with `findFirst()`, you need to get the full
object back (no `columns` definition) but also retrieve it using the
primary key. If not, the ORM will issue an `INSERT` instead of `UPDATE`.
validationHasFailed()
```php
public function validationHasFailed(): bool;
```
Check whether validation process has generated any messages
```php
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);
}
}
```
writeAttribute()
```php
public function writeAttribute(
string $attribute,
mixed $value
): void;
```
Writes an attribute value by its name
```php
$invoice->writeAttribute("name", "Rosey");
```
allowEmptyStringValues()
```php
protected function allowEmptyStringValues( array $attributes ): void;
```
Sets a list of attributes that must be skipped from the
generated UPDATE statement
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->allowEmptyStringValues(
[
"name",
]
);
}
}
```
belongsTo()
```php
protected function belongsTo(
mixed $fields,
string $referenceModel,
mixed $referencedFields,
array $options = []
): Relation;
```
Setup a reverse 1-1 or n-1 relation between two models
```php
class OrdersProducts extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->belongsTo(
"oxp_ord_id",
Invoices::class,
"id"
);
}
}
```
cancelOperation()
```php
protected function cancelOperation();
```
Cancel the current operation
checkForeignKeysRestrict()
```php
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
checkForeignKeysReverseCascade()
```php
final protected function checkForeignKeysReverseCascade(): bool;
```
Reads both "hasMany" and "hasOne" relations and checks the virtual
foreign keys (cascade) when deleting records
checkForeignKeysReverseRestrict()
```php
final protected function checkForeignKeysReverseRestrict(): bool;
```
Reads both "hasMany" and "hasOne" relations and checks the virtual
foreign keys (restrict) when deleting records
```php
protected function collectRelatedToSave(): array;
```
Collects previously queried (belongs-to, has-one and has-one-through)
related records along with freshly added one
doLowInsert()
```php
protected function doLowInsert(
MetaDataInterface $metaData,
AdapterInterface $connection,
mixed $table,
mixed $identityField
): bool;
```
Sends a pre-build INSERT SQL statement to the relational database system
doLowUpdate()
```php
protected function doLowUpdate(
MetaDataInterface $metaData,
AdapterInterface $connection,
mixed $table
): bool;
```
Sends a pre-build UPDATE SQL statement to the relational database system
```php
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.
groupResult()
```php
protected static function groupResult(
string $functionName,
string $alias,
mixed $parameters = null
): mixed;
```
Generate a PHQL SELECT statement for an aggregate
has()
```php
protected function has(
MetaDataInterface $metaData,
AdapterInterface $connection
): bool;
```
Checks whether the current record already exists
hasMany()
```php
protected function hasMany(
mixed $fields,
string $referenceModel,
mixed $referencedFields,
array $options = []
): Relation;
```
Setup a 1-n relation between two models
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasMany(
"id",
OrdersProducts::class,
"oxp_ord_id"
);
}
}
```
hasManyToMany()
```php
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
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
// Setup a many-to-many relation to Parts through OrdersProducts
$this->hasManyToMany(
"id",
OrdersProducts::class,
"oxp_ord_id",
"oxp_prd_id",
Products::class,
"id",
);
}
}
```
hasOne()
```php
protected function hasOne(
mixed $fields,
string $referenceModel,
mixed $referencedFields,
array $options = []
): Relation;
```
Setup a 1-1 relation between two models
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->hasOne(
"id",
InvoicesDescription::class,
"oxp_ord_id"
);
}
}
```
hasOneThrough()
```php
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
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
// Setup a 1-1 relation to one item from Parts through OrdersProducts
$this->hasOneThrough(
"id",
OrdersProducts::class,
"oxp_ord_id",
"oxp_prd_id",
Products::class,
"id",
);
}
}
```
invokeFinder()
```php
protected final static function invokeFinder(
string $method,
array $arguments
);
```
Try to check if the query must invoke a finder
keepSnapshots()
```php
protected function keepSnapshots( bool $keepSnapshot ): void;
```
Sets if the model must keep the original record snapshot in memory
```php
use Phalcon\Mvc\Model;
class Invoices extends Model
{
public function initialize()
{
$this->keepSnapshots(true);
}
}
```
possibleSetter()
```php
final protected function possibleSetter(
string $property,
mixed $value
): bool;
```
Check for, and attempt to use, possible setter.
postSave()
```php
protected function postSave(
bool $success,
bool $exists
): bool;
```
Executes internal events after save a record
postSaveRelatedRecords()
```php
protected function postSaveRelatedRecords(
AdapterInterface $connection,
mixed $related,
CollectionInterface $visited
): bool;
```
Save the related records assigned in the has-one/has-many relations
preSave()
```php
protected function preSave(
MetaDataInterface $metaData,
bool $exists,
mixed $identityField
): bool;
```
Executes internal hooks before save a record
```php
protected function preSaveRelatedRecords(
AdapterInterface $connection,
mixed $related,
CollectionInterface $visited
): bool;
```
Saves related records that must be stored prior to save the master record
setSchema()
```php
final protected function setSchema( string $schema ): ModelInterface;
```
Sets schema name where the mapped table is located
setSource()
```php
final protected function setSource( string $source ): ModelInterface;
```
Sets the table name to which model should be mapped
skipAttributes()
```php
protected function skipAttributes( array $attributes ): void;
```
Sets a list of attributes that must be skipped from the
generated INSERT/UPDATE statement
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributes(
[
"price",
]
);
}
}
```
skipAttributesOnCreate()
```php
protected function skipAttributesOnCreate( array $attributes ): void;
```
Sets a list of attributes that must be skipped from the
generated INSERT statement
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnCreate(
[
"created_at",
]
);
}
}
```
skipAttributesOnUpdate()
```php
protected function skipAttributesOnUpdate( array $attributes ): void;
```
Sets a list of attributes that must be skipped from the
generated UPDATE statement
```php
class Invoices extends \Phalcon\Mvc\Model
{
public function initialize()
{
$this->skipAttributesOnUpdate(
[
"modified_in",
]
);
}
}
```
useDynamicUpdate()
```php
protected function useDynamicUpdate( bool $dynamicUpdate ): void;
```
Sets if a model must use dynamic update instead of the all-field update
```php
use Phalcon\Mvc\Model;
class Invoices extends Model
{
public function initialize()
{
$this->useDynamicUpdate(true);
}
}
```
validate()
```php
protected function validate( ValidationInterface $validator ): bool;
```
Executes validators on every validation call
```php
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);
}
}
```
## Mvc\ModelInterface
Interface
Phalcon\Mvc\ModelInterface
Interface for Phalcon\Mvc\Model
@template T
- **`Phalcon\Mvc\ModelInterface`**
`Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\Model\CriteriaInterface` · `Phalcon\Mvc\Model\MetaDataInterface` · `Phalcon\Mvc\Model\ResultInterface` · `Phalcon\Mvc\Model\Resultset` · `Phalcon\Mvc\Model\ResultsetInterface` · `Phalcon\Mvc\Model\TransactionInterface`
### Method Summary
Appends a customized message on the validation process
Assigns values to a model from an array
Allows to calculate the average value on a column matching the specified
Assigns values to a model from an array returning a new model
Assigns values to a model from an array returning a new model
Returns an hydrated result based on the data and the column map
Allows to count how many records match the specified conditions
Inserts a model instance. If the instance already exists in the
Deletes a model instance. Returning true on success or false otherwise.
Allows to query a set of records that match the specified conditions.
Allows to query the first record that match the specified conditions
Fires an event, implicitly calls behaviors and listeners in the events
Fires an event, implicitly calls behaviors and listeners in the events
Returns one of the DIRTY_STATE_* constants telling if the record exists
Returns array of validation messages
Returns the models meta-data service related to the entity instance.
Returns the type of the latest operation performed by the ORM
Gets internal database connection
Returns DependencyInjection connection service used to read data
Returns related records based on defined relations
Returns schema name where table mapped is located
Returns table name mapped in the model
Gets internal database connection
Returns DependencyInjection connection service used to write data
Allows to get the maximum value of a column that match the specified
Allows to get the minimum value of a column that match the specified
Create a criteria for a specific model
Refreshes the model attributes re-querying the record from the database
Inserts or updates a model instance. Returning true on success or false
Sets both read/write connection services
Sets the dirty state of the object using one of the DIRTY_STATE_*
Sets the DependencyInjection connection service used to read data
Sets the record's snapshot data. This method is used internally to set
Marks one or more many-to-many relationships to be synchronized (or not)
Sets a transaction related to the Model instance
Sets the DependencyInjection connection service used to write data
Skips the current operation forcing a success state
Allows to calculate a sum on a column that match the specified conditions
Updates a model instance. If the instance does not exist in the
Check whether validation process has generated any messages
### Methods
appendMessage()
```php
public function appendMessage( MessageInterface $message ): ModelInterface;
```
Appends a customized message on the validation process
assign()
```php
public function assign(
array $data,
mixed $whiteList = null,
mixed $dataColumnMap = null
): ModelInterface;
```
Assigns values to a model from an array
average()
```php
public static function average( array $parameters = [] ): float|ResultsetInterface;
```
Allows to calculate the average value on a column matching the specified
conditions
cloneResult()
```php
public static function cloneResult(
ModelInterface $base,
array $data,
int $dirtyState = 0
): ModelInterface;
```
Assigns values to a model from an array returning a new model
cloneResultMap()
```php
public static function cloneResultMap(
mixed $base,
array $data,
mixed $columnMap,
int $dirtyState = 0,
bool $keepSnapshots = false
): ModelInterface;
```
Assigns values to a model from an array returning a new model
cloneResultMapHydrate()
```php
public static function cloneResultMapHydrate(
array $data,
mixed $columnMap,
int $hydrationMode
);
```
Returns an hydrated result based on the data and the column map
count()
```php
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.
create()
```php
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.
delete()
```php
public function delete(): bool;
```
Deletes a model instance. Returning true on success or false otherwise.
find()
```php
public static function find( mixed $parameters = null );
```
Allows to query a set of records that match the specified conditions.
This is one of four ways to express a query against a model, each with an
intended lane:
- find-parameter arrays (this method) for simple lookups;
- `Phalcon\Mvc\Model\Query\Builder` as the canonical programmatic API;
- `Phalcon\Mvc\Model\Criteria` as request-bound convenience;
- raw PHQL via `Phalcon\Mvc\Model\Query` for everything else.
findFirst()
```php
public static function findFirst( mixed $parameters = null ): mixed|null;
```
Allows to query the first record that match the specified conditions
TODO: Current method signature must be reviewed in v5. As it must return only ?ModelInterface (it also returns Row).
@see https://github.com/phalcon/cphalcon/issues/15212
@see https://github.com/phalcon/cphalcon/issues/15883
fireEvent()
```php
public function fireEvent( string $eventName ): bool;
```
Fires an event, implicitly calls behaviors and listeners in the events
manager are notified
fireEventCancel()
```php
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
getDirtyState()
```php
public function getDirtyState(): int;
```
Returns one of the DIRTY_STATE_* constants telling if the record exists
in the database or not
getMessages()
```php
public function getMessages(): MessageInterface[];
```
Returns array of validation messages
```php
public function getModelsMetaData(): MetaDataInterface;
```
Returns the models meta-data service related to the entity instance.
getOperationMade()
```php
public function getOperationMade(): int;
```
Returns the type of the latest operation performed by the ORM
Returns one of the OP_* class constants
getReadConnection()
```php
public function getReadConnection(): AdapterInterface;
```
Gets internal database connection
getReadConnectionService()
```php
public function getReadConnectionService(): string;
```
Returns DependencyInjection connection service used to read data
```php
public function getRelated(
string $alias,
mixed $arguments = null
);
```
Returns related records based on defined relations
getSchema()
```php
public function getSchema(): string|null;
```
Returns schema name where table mapped is located
getSource()
```php
public function getSource(): string;
```
Returns table name mapped in the model
getWriteConnection()
```php
public function getWriteConnection(): AdapterInterface;
```
Gets internal database connection
getWriteConnectionService()
```php
public function getWriteConnectionService(): string;
```
Returns DependencyInjection connection service used to write data
maximum()
```php
public static function maximum( mixed $parameters = null ): mixed;
```
Allows to get the maximum value of a column that match the specified
conditions
minimum()
```php
public static function minimum( mixed $parameters = null ): mixed;
```
Allows to get the minimum value of a column that match the specified
conditions
query()
```php
public static function query( DiInterface|null $container = null ): CriteriaInterface;
```
Create a criteria for a specific model
refresh()
```php
public function refresh(): ModelInterface;
```
Refreshes the model attributes re-querying the record from the database
save()
```php
public function save(): bool;
```
Inserts or updates a model instance. Returning true on success or false
otherwise.
setConnectionService()
```php
public function setConnectionService( string $connectionService ): void;
```
Sets both read/write connection services
setDirtyState()
```php
public function setDirtyState( int $dirtyState ): ModelInterface|bool;
```
Sets the dirty state of the object using one of the DIRTY_STATE_*
constants
setReadConnectionService()
```php
public function setReadConnectionService( string $connectionService ): void;
```
Sets the DependencyInjection connection service used to read data
setSnapshotData()
```php
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
setSync()
```php
public function setSync(
mixed $elements = null,
bool $enabled = true
): ModelInterface;
```
Marks one or more many-to-many relationships to be synchronized (or not)
on the next save() call.
setTransaction()
```php
public function setTransaction( TransactionInterface $transaction ): ModelInterface;
```
Sets a transaction related to the Model instance
setWriteConnectionService()
```php
public function setWriteConnectionService( string $connectionService ): void;
```
Sets the DependencyInjection connection service used to write data
skipOperation()
```php
public function skipOperation( bool $skip ): void;
```
Skips the current operation forcing a success state
sum()
```php
public static function sum( mixed $parameters = null ): float|ResultsetInterface;
```
Allows to calculate a sum on a column that match the specified conditions
update()
```php
public function update(): bool;
```
Updates a model instance. If the instance does not exist in the
persistence it will throw an exception. Returning true on success or
false otherwise.
validationHasFailed()
```php
public function validationHasFailed(): bool;
```
Check whether validation process has generated any messages
## Mvc\Model\Behavior
Abstract
Phalcon\Mvc\Model\Behavior
This is an optional base class for ORM behaviors
- **`Phalcon\Mvc\Model\Behavior`** - implements [`Phalcon\Mvc\Model\BehaviorInterface`](#mvcmodelbehaviorinterface)
- [`Phalcon\Mvc\Model\Behavior\SoftDelete`](#mvcmodelbehaviorsoftdelete)
- [`Phalcon\Mvc\Model\Behavior\Timestampable`](#mvcmodelbehaviortimestampable)
`Phalcon\Mvc\ModelInterface`
### Method Summary
Phalcon\Mvc\Model\Behavior
Acts as fallbacks when a missing method is called on the model
This method receives the notifications from the EventsManager
Returns the behavior options related to an event
Checks whether the behavior must take action on certain event
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Phalcon\Mvc\Model\Behavior
missingMethod()
```php
public function missingMethod(
ModelInterface $model,
string $method,
array $arguments = []
);
```
Acts as fallbacks when a missing method is called on the model
notify()
```php
public function notify(
string $type,
ModelInterface $model
);
```
This method receives the notifications from the EventsManager
getOptions()
```php
protected function getOptions( string|null $eventName = null );
```
Returns the behavior options related to an event
mustTakeAction()
```php
protected function mustTakeAction( string $eventName ): bool;
```
Checks whether the behavior must take action on certain event
## Mvc\Model\BehaviorInterface
Interface
Phalcon\Mvc\Model\BehaviorInterface
Interface for Phalcon\Mvc\Model\Behavior
- **`Phalcon\Mvc\Model\BehaviorInterface`**
`Phalcon\Mvc\ModelInterface`
### Method Summary
Calls a method when it's missing in the model
This method receives the notifications from the EventsManager
### Methods
missingMethod()
```php
public function missingMethod(
ModelInterface $model,
string $method,
array $arguments = []
);
```
Calls a method when it's missing in the model
notify()
```php
public function notify(
string $type,
ModelInterface $model
);
```
This method receives the notifications from the EventsManager
## Mvc\Model\Behavior\Exceptions\MissingRequiredOption
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Behavior\Exceptions\MissingRequiredOption`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $option );
```
## Mvc\Model\Behavior\SoftDelete
Class
Phalcon\Mvc\Model\Behavior\SoftDelete
Instead of permanently delete a record it marks the record as deleted
changing the value of a flag column
- [`Phalcon\Mvc\Model\Behavior`](#mvcmodelbehavior)
- **`Phalcon\Mvc\Model\Behavior\SoftDelete`**
`Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Behavior` · `Phalcon\Mvc\Model\Behavior\Exceptions\MissingRequiredOption` · `Phalcon\Mvc\Model\Exception` · `Phalcon\Support\Settings`
### Method Summary
Listens for notifications from the models manager
### Methods
notify()
```php
public function notify(
string $type,
ModelInterface $model
);
```
Listens for notifications from the models manager
## Mvc\Model\Behavior\Timestampable
Class
Phalcon\Mvc\Model\Behavior\Timestampable
Allows to automatically update a model’s attribute saving the datetime when a
record is created or updated
- [`Phalcon\Mvc\Model\Behavior`](#mvcmodelbehavior)
- **`Phalcon\Mvc\Model\Behavior\Timestampable`**
`Closure` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Behavior` · `Phalcon\Mvc\Model\Behavior\Exceptions\MissingRequiredOption` · `Phalcon\Mvc\Model\Exception`
### Method Summary
Listens for notifications from the models manager
### Methods
notify()
```php
public function notify(
string $type,
ModelInterface $model
);
```
Listens for notifications from the models manager
## Mvc\Model\Binder
Class
Phalcon\Mvc\Model\Binder
This is an class for binding models into params for handler
- **`Phalcon\Mvc\Model\Binder`** - implements [`Phalcon\Mvc\Model\BinderInterface`](#mvcmodelbinderinterface)
`Closure` · `Phalcon\Cache\Adapter\AdapterInterface` · `Phalcon\Mvc\Controller\BindModelInterface` · `Phalcon\Mvc\Model` · `Phalcon\Mvc\Model\Binder\BindableInterface` · `Phalcon\Mvc\Model\Exceptions\HandlerMustImplementBindable` · `Phalcon\Mvc\Model\Exceptions\InvalidGetModelNameReturn` · `Phalcon\Mvc\Model\Exceptions\MissingMethodName` · `Phalcon\Mvc\Model\Exceptions\MissingModelClassName` · `ReflectionFunction` · `ReflectionMethod` · `ReflectionNamedType`
### Method Summary
Phalcon\Mvc\Model\Binder constructor
Bind models into params in proper handler
Return the active bound models
Sets cache instance
Return the array for original values
Gets cache instance
Find the model by param value.
Get params classes from cache by key
Get modified params for handler using reflection
### Properties
Array for storing active bound models
Cache object used for caching parameters for model binding
Internal cache for caching parameters for model binding during request
Array for original values
### Methods
__construct()
```php
public function __construct( AdapterInterface|null $cache = null );
```
Phalcon\Mvc\Model\Binder constructor
bindToHandler()
```php
public function bindToHandler(
object $handler,
array $params,
string $cacheKey,
string|null $methodName = null
): array;
```
Bind models into params in proper handler
getBoundModels()
```php
public function getBoundModels(): array;
```
Return the active bound models
getCache()
```php
public function getCache(): AdapterInterface;
```
Sets cache instance
getOriginalValues()
```php
public function getOriginalValues(): array;
```
Return the array for original values
setCache()
```php
public function setCache( AdapterInterface $cache ): BinderInterface;
```
Gets cache instance
findBoundModel()
```php
protected function findBoundModel(
mixed $paramValue,
string $className
): mixed|bool;
```
Find the model by param value.
getParamsFromCache()
```php
protected function getParamsFromCache( string $cacheKey ): array|null;
```
Get params classes from cache by key
getParamsFromReflection()
```php
protected function getParamsFromReflection(
object $handler,
array $params,
string $cacheKey,
string $methodName
): array;
```
Get modified params for handler using reflection
## Mvc\Model\BinderInterface
Interface
Phalcon\Mvc\Model\BinderInterface
Interface for Phalcon\Mvc\Model\Binder
- **`Phalcon\Mvc\Model\BinderInterface`**
`Phalcon\Cache\Adapter\AdapterInterface`
### Method Summary
Bind models into params in proper handler
Gets active bound models
Gets cache instance
Sets cache instance
### Methods
bindToHandler()
```php
public function bindToHandler(
object $handler,
array $params,
string $cacheKey,
string|null $methodName = null
): array;
```
Bind models into params in proper handler
getBoundModels()
```php
public function getBoundModels(): array;
```
Gets active bound models
getCache()
```php
public function getCache(): AdapterInterface;
```
Gets cache instance
setCache()
```php
public function setCache( AdapterInterface $cache ): BinderInterface;
```
Sets cache instance
## Mvc\Model\Binder\BindableInterface
Interface
Phalcon\Mvc\Model\Binder\BindableInterface
Interface for bindable classes
- **`Phalcon\Mvc\Model\Binder\BindableInterface`**
### Method Summary
Return the model name or models names and parameters keys associated with
### Methods
getModelName()
```php
public function getModelName(): string|array;
```
Return the model name or models names and parameters keys associated with
this class
## Mvc\Model\Criteria
Class
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.
```php
where("inv_cst_id = :customerId:")
->andWhere("inv_created_date < '2000-01-01'")
->bind(["customerId" => 1])
->limit(5, 10)
->orderBy("inv_title")
->execute();
```
- **`Phalcon\Mvc\Model\Criteria`** - implements [`Phalcon\Mvc\Model\CriteriaInterface`](#mvcmodelcriteriainterface), [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface)
`Phalcon\Db\Column` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\Model\Exceptions\InvalidModelName` · `Phalcon\Mvc\Model\Query\BuilderInterface`
### Method Summary
Appends a condition to the current conditions using an AND operator
Appends a BETWEEN condition to the current conditions
Sets the bound parameters in the criteria
Sets the bind types in the criteria
Sets the cache options in the criteria
Sets the columns to be queried. The columns can be either a `string` or
Adds the conditions parameter to the criteria
Creates a query builder from criteria.
Sets SELECT DISTINCT / SELECT ALL flag
Pre-loads the named relations when the criteria is executed
Executes a find using the parameters built with the criteria
Adds the "for_update" parameter to the criteria
Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
Returns the columns to be queried
Returns the conditions parameter in the criteria
Returns the DependencyInjector container
Returns the group clause in the criteria
Returns the having clause in the criteria
Returns the limit parameter in the criteria, which will be
Returns an internal model name on which the criteria will be applied
Returns the order clause in the criteria
Returns all the parameters defined in the criteria
Returns the conditions parameter in the criteria
Adds the group-by clause to the criteria
Adds the having clause to the criteria
Appends an IN condition to the current conditions
Adds an INNER join to the query
Adds an INNER join to the query
Adds a LEFT join to the query
Adds the limit parameter to the criteria.
Appends a NOT BETWEEN condition to the current conditions
Appends a NOT IN condition to the current conditions
Appends a condition to the current conditions using an OR operator
Adds the order-by clause to the criteria
Adds a RIGHT join to the query
Sets the DependencyInjector container
Set a model on which the query will be executed
Adds the "shared_lock" parameter to the criteria
Sets the conditions parameter in the criteria
### Properties
### Methods
andWhere()
```php
public function andWhere(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Appends a condition to the current conditions using an AND operator
betweenWhere()
```php
public function betweenWhere(
string $expr,
mixed $minimum,
mixed $maximum
): CriteriaInterface;
```
Appends a BETWEEN condition to the current conditions
```php
$criteria->betweenWhere("price", 100.25, 200.50);
```
bind()
```php
public function bind(
array $bindParams,
bool $merge = false
): CriteriaInterface;
```
Sets the bound parameters in the criteria
This method replaces all previously set bound parameters
bindTypes()
```php
public function bindTypes( array $bindTypes ): CriteriaInterface;
```
Sets the bind types in the criteria
This method replaces all previously set bound parameters
cache()
```php
public function cache( array $cache ): CriteriaInterface;
```
Sets the cache options in the criteria
This method replaces all previously set cache options
columns()
```php
public function columns( mixed $columns ): CriteriaInterface;
```
Sets the columns to be queried. The columns can be either a `string` or
an `array` of strings. If the argument is a (single, non-embedded) string,
its content can specify one or more columns, separated by commas, the same
way that one uses the SQL select statement. You can use aliases, aggregate
functions, etc. If you need to reference other models you will need to
reference them with their namespaces.
When using an array as a parameter, you will need to specify one field
per array element. If a non-numeric key is defined in the array, it will
be used as the alias in the query
```php
columns("id, category");
// Array, one column per element
$criteria->columns(
[
"inv_id",
"inv_total",
]
);
// Array with named key. The name of the key acts as an
// alias (`AS` clause)
$criteria->columns(
[
"inv_cst_id",
"total_invoices" => "COUNT(*)",
]
);
// Different models
$criteria->columns(
[
"\Phalcon\Models\Invoices.*",
"\Phalcon\Models\Customers.cst_name_first",
"\Phalcon\Models\Customers.cst_name_last",
]
);
```
conditions()
```php
public function conditions( string $conditions ): CriteriaInterface;
```
Adds the conditions parameter to the criteria
createBuilder()
```php
public function createBuilder(): BuilderInterface;
```
Creates a query builder from criteria.
```php
where("inv_cst_id = :customerId:")
->bind(["customerId" => 1])
->createBuilder();
```
distinct()
```php
public function distinct( mixed $distinct ): CriteriaInterface;
```
Sets SELECT DISTINCT / SELECT ALL flag
eager()
```php
public function eager( array $paths ): Criteria;
```
Pre-loads the named relations when the criteria is executed
```php
$invoices = Invoices::query()
->eager(["customer"])
->where("inv_total > 100")
->execute();
```
execute() forwards the parameters to Model::find(), which owns the
loading, so this is a pass-through and takes the same shape: an array of
dot-delimited relation paths, optionally `path => options`.
Returns the concrete criteria rather than the interface because the
method is deliberately not part of CriteriaInterface - adding it there
would break every userland implementation.
execute()
```php
public function execute(): ResultsetInterface;
```
Executes a find using the parameters built with the criteria
forUpdate()
```php
public function forUpdate( bool $forUpdate = true ): CriteriaInterface;
```
Adds the "for_update" parameter to the criteria
```php
public static function fromInput(
DiInterface $container,
string $modelName,
array $data,
string $operator = "AND"
): CriteriaInterface;
```
Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
getColumns()
```php
public function getColumns(): string|array|null;
```
Returns the columns to be queried
getConditions()
```php
public function getConditions(): string|null;
```
Returns the conditions parameter in the criteria
getDI()
```php
public function getDI(): DiInterface;
```
Returns the DependencyInjector container
getGroupBy()
```php
public function getGroupBy();
```
Returns the group clause in the criteria
getHaving()
```php
public function getHaving();
```
Returns the having clause in the criteria
getLimit()
```php
public function getLimit(): int|array|null;
```
Returns the limit parameter in the criteria, which will be
- An integer if 'limit' was set without an 'offset'
- An array with 'number' and 'offset' keys if an offset was set with the limit
- NULL if limit has not been set
getModelName()
```php
public function getModelName(): string;
```
Returns an internal model name on which the criteria will be applied
getOrderBy()
```php
public function getOrderBy(): string|null;
```
Returns the order clause in the criteria
getParams()
```php
public function getParams(): array;
```
Returns all the parameters defined in the criteria
getWhere()
```php
public function getWhere(): string|null;
```
Returns the conditions parameter in the criteria
groupBy()
```php
public function groupBy( mixed $group ): CriteriaInterface;
```
Adds the group-by clause to the criteria
having()
```php
public function having( mixed $having ): CriteriaInterface;
```
Adds the having clause to the criteria
inWhere()
```php
public function inWhere(
string $expr,
array $values
): CriteriaInterface;
```
Appends an IN condition to the current conditions
```php
$criteria->inWhere("id", [1, 2, 3]);
```
innerJoin()
```php
public function innerJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds an INNER join to the query
```php
innerJoin(
Invoices::class
);
$criteria->innerJoin(
Invoices::class,
"inv_cst_id = Customers.cst_id"
);
$criteria->innerJoin(
Invoices::class,
"i.inv_cst_id = Customers.cst_id",
"i"
);
```
join()
```php
public function join(
string $model,
mixed $conditions = null,
mixed $alias = null,
mixed $type = null
): CriteriaInterface;
```
Adds an INNER join to the query
```php
join(
Invoices::class
);
$criteria->join(
Invoices::class,
"inv_cst_id = Customers.cst_id"
);
$criteria->join(
Invoices::class,
"i.inv_cst_id = Customers.cst_id",
"i"
);
$criteria->join(
Invoices::class,
"i.inv_cst_id = Customers.cst_id",
"i",
"LEFT"
);
```
leftJoin()
```php
public function leftJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds a LEFT join to the query
```php
leftJoin(
Invoices::class,
"i.inv_cst_id = Customers.cst_id",
"i"
);
```
limit()
```php
public function limit(
int $limit,
int $offset = 0
): CriteriaInterface;
```
Adds the limit parameter to the criteria.
```php
$criteria->limit(100);
$criteria->limit(100, 200);
$criteria->limit("100", "200");
```
notBetweenWhere()
```php
public function notBetweenWhere(
string $expr,
mixed $minimum,
mixed $maximum
): CriteriaInterface;
```
Appends a NOT BETWEEN condition to the current conditions
```php
$criteria->notBetweenWhere("price", 100.25, 200.50);
```
notInWhere()
```php
public function notInWhere(
string $expr,
array $values
): CriteriaInterface;
```
Appends a NOT IN condition to the current conditions
```php
$criteria->notInWhere("id", [1, 2, 3]);
```
orWhere()
```php
public function orWhere(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Appends a condition to the current conditions using an OR operator
orderBy()
```php
public function orderBy( string $orderColumns ): CriteriaInterface;
```
Adds the order-by clause to the criteria
rightJoin()
```php
public function rightJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds a RIGHT join to the query
```php
rightJoin(
Invoices::class,
"i.inv_cst_id = Customers.cst_id",
"i"
);
```
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the DependencyInjector container
setModelName()
```php
public function setModelName( string $modelName ): CriteriaInterface;
```
Set a model on which the query will be executed
sharedLock()
```php
public function sharedLock( bool $sharedLock = true ): CriteriaInterface;
```
Adds the "shared_lock" parameter to the criteria
where()
```php
public function where(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Sets the conditions parameter in the criteria
## Mvc\Model\CriteriaInterface
Interface
Phalcon\Mvc\Model\CriteriaInterface
Interface for Phalcon\Mvc\Model\Criteria
- **`Phalcon\Mvc\Model\CriteriaInterface`**
`Phalcon\Di\DiInterface`
### Method Summary
Appends a condition to the current conditions using an AND operator
Appends a BETWEEN condition to the current conditions
Sets the bound parameters in the criteria
Sets the bind types in the criteria
Sets the cache options in the criteria
Adds the conditions parameter to the criteria
Sets SELECT DISTINCT / SELECT ALL flag
Executes a find using the parameters built with the criteria
Sets the "for_update" parameter to the criteria
Returns the columns to be queried
Returns the conditions parameter in the criteria
Returns the group clause in the criteria
Returns the having clause in the criteria
Returns the limit parameter in the criteria, which will be
Returns an internal model name on which the criteria will be applied
Returns the order parameter in the criteria
Returns all the parameters defined in the criteria
Returns the conditions parameter in the criteria
Adds the group-by clause to the criteria
Adds the having clause to the criteria
Appends an IN condition to the current conditions
Adds an INNER join to the query
Adds a LEFT join to the query
Sets the limit parameter to the criteria
Appends a NOT BETWEEN condition to the current conditions
Appends a NOT IN condition to the current conditions
Appends a condition to the current conditions using an OR operator
Adds the order-by parameter to the criteria
Adds a RIGHT join to the query
Set a model on which the query will be executed
Sets the "shared_lock" parameter to the criteria
Sets the conditions parameter in the criteria
### Methods
andWhere()
```php
public function andWhere(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Appends a condition to the current conditions using an AND operator
betweenWhere()
```php
public function betweenWhere(
string $expr,
mixed $minimum,
mixed $maximum
): CriteriaInterface;
```
Appends a BETWEEN condition to the current conditions
```php
$criteria->betweenWhere("price", 100.25, 200.50);
```
bind()
```php
public function bind( array $bindParams ): CriteriaInterface;
```
Sets the bound parameters in the criteria
This method replaces all previously set bound parameters
bindTypes()
```php
public function bindTypes( array $bindTypes ): CriteriaInterface;
```
Sets the bind types in the criteria
This method replaces all previously set bound parameters
cache()
```php
public function cache( array $cache ): CriteriaInterface;
```
Sets the cache options in the criteria
This method replaces all previously set cache options
conditions()
```php
public function conditions( string $conditions ): CriteriaInterface;
```
Adds the conditions parameter to the criteria
distinct()
```php
public function distinct( mixed $distinct ): CriteriaInterface;
```
Sets SELECT DISTINCT / SELECT ALL flag
execute()
```php
public function execute(): ResultsetInterface;
```
Executes a find using the parameters built with the criteria
forUpdate()
```php
public function forUpdate( bool $forUpdate = true ): CriteriaInterface;
```
Sets the "for_update" parameter to the criteria
getColumns()
```php
public function getColumns(): string|array|null;
```
Returns the columns to be queried
getConditions()
```php
public function getConditions(): string|null;
```
Returns the conditions parameter in the criteria
getGroupBy()
```php
public function getGroupBy();
```
Returns the group clause in the criteria
getHaving()
```php
public function getHaving();
```
Returns the having clause in the criteria
getLimit()
```php
public function getLimit(): int|array|null;
```
Returns the limit parameter in the criteria, which will be
- An integer if 'limit' was set without an 'offset'
- An array with 'number' and 'offset' keys if an offset was set with the limit
- NULL if limit has not been set
getModelName()
```php
public function getModelName(): string;
```
Returns an internal model name on which the criteria will be applied
getOrderBy()
```php
public function getOrderBy(): string|null;
```
Returns the order parameter in the criteria
getParams()
```php
public function getParams(): array;
```
Returns all the parameters defined in the criteria
getWhere()
```php
public function getWhere(): string|null;
```
Returns the conditions parameter in the criteria
groupBy()
```php
public function groupBy( mixed $group ): CriteriaInterface;
```
Adds the group-by clause to the criteria
having()
```php
public function having( mixed $having ): CriteriaInterface;
```
Adds the having clause to the criteria
inWhere()
```php
public function inWhere(
string $expr,
array $values
): CriteriaInterface;
```
Appends an IN condition to the current conditions
```php
$criteria->inWhere("id", [1, 2, 3]);
```
innerJoin()
```php
public function innerJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds an INNER join to the query
```php
$criteria->innerJoin(
Orders::class
);
$criteria->innerJoin(
Orders::class,
"r.ord_id = OrdersProducts.oxp_ord_id"
);
$criteria->innerJoin(
Orders::class,
"r.ord_id = OrdersProducts.oxp_ord_id",
"r"
);
```
leftJoin()
```php
public function leftJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds a LEFT join to the query
```php
$criteria->leftJoin(
Orders::class,
"r.ord_id = OrdersProducts.oxp_ord_id",
"r"
);
```
limit()
```php
public function limit(
int $limit,
int $offset = 0
): CriteriaInterface;
```
Sets the limit parameter to the criteria
notBetweenWhere()
```php
public function notBetweenWhere(
string $expr,
mixed $minimum,
mixed $maximum
): CriteriaInterface;
```
Appends a NOT BETWEEN condition to the current conditions
```php
$criteria->notBetweenWhere("price", 100.25, 200.50);
```
notInWhere()
```php
public function notInWhere(
string $expr,
array $values
): CriteriaInterface;
```
Appends a NOT IN condition to the current conditions
```php
$criteria->notInWhere("id", [1, 2, 3]);
```
orWhere()
```php
public function orWhere(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Appends a condition to the current conditions using an OR operator
orderBy()
```php
public function orderBy( string $orderColumns ): CriteriaInterface;
```
Adds the order-by parameter to the criteria
rightJoin()
```php
public function rightJoin(
string $model,
mixed $conditions = null,
mixed $alias = null
): CriteriaInterface;
```
Adds a RIGHT join to the query
```php
$criteria->rightJoin(
Orders::class,
"r.ord_id = OrdersProducts.oxp_ord_id",
"r"
);
```
setModelName()
```php
public function setModelName( string $modelName ): CriteriaInterface;
```
Set a model on which the query will be executed
sharedLock()
```php
public function sharedLock( bool $sharedLock = true ): CriteriaInterface;
```
Sets the "shared_lock" parameter to the criteria
where()
```php
public function where(
string $conditions,
mixed $bindParams = null,
mixed $bindTypes = null
): CriteriaInterface;
```
Sets the conditions parameter in the criteria
## Mvc\Model\Eager\Loader
Class
Loads model relations in bulk - a bounded number of queries per relation
node rather than one per record - and applies the result to records as they
are hydrated.
- **`Phalcon\Mvc\Model\Eager\Loader`**
`Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exceptions\EagerRowLimitExceeded` · `Phalcon\Mvc\Model\Exceptions\MissingEagerKeyColumn` · `Phalcon\Mvc\Model\Exceptions\UnknownEagerRelation` · `Phalcon\Mvc\Model\Manager` · `Phalcon\Mvc\Model\ManagerInterface` · `Phalcon\Mvc\Model\Relation` · `Phalcon\Mvc\Model\RelationInterface` · `Phalcon\Mvc\Model\Resultset\Simple`
### Method Summary
Applies a pre-built eager map to a single record.
Builds the lookup key for a set of key-field values.
Loads a relation tree for a root resultset.
Builds one level of the map.
Builds a single map node: one query, indexed by the referenced field.
Through-relations in two steps rather than a join.
Distinct, non-null local key tuples across the parent set.
One query per relation node. An empty key set issues none at all -
Relation fields are declared as a string for a single column and an
Lookup key for an already-hydrated record.
### Constants
Maximum number of rows a single relation node may return before the load
is refused. Guards against a to-many hop that follows a to-one hop, which
can fan out to an entire table.
### Properties
### Methods
__construct()
```php
public function __construct( ManagerInterface $manager );
```
apply()
```php
public static function apply(
mixed $record,
array $eagerMap
): void;
```
Applies a pre-built eager map to a single record.
Shared by Resultset\Simple::current(), which stamps records as they are
hydrated, and by the loader itself, which stamps instances it retains.
Both Model and Row implement readAttribute(), so key extraction is
uniform; only the write differs. A Row is what a column-restricted
select produces, and it has no relation cache.
buildKey()
```php
public static function buildKey( array $values ): string;
```
Builds the lookup key for a set of key-field values.
Always a string. A single value is cast, which also neutralizes the
PostgreSQL-integer / MySQL-string mismatch for the same column. Multiple
values are length-prefixed so ["a|b", "c"] cannot collide with
["a", "b|c"].
loadResultset()
```php
public function loadResultset(
Simple $resultset,
string $modelName,
array $tree
): void;
```
Loads a relation tree for a root resultset.
The resultset is materialized first: at this point the statement has run
but no row has been consumed, so fetching every row costs nothing extra
and gives the key values without a second pass over the cursor.
buildMap()
```php
protected function buildMap(
array $parents,
string $modelName,
array $tree
): array;
```
Builds one level of the map.
buildNode()
```php
protected function buildNode(
RelationInterface $relation,
string $alias,
array $parents,
array $node
): array;
```
Builds a single map node: one query, indexed by the referenced field.
buildThroughNode()
```php
protected function buildThroughNode(
RelationInterface $relation,
string $alias,
array $parents,
array $node
): array;
```
Through-relations in two steps rather than a join.
Step one fetches (parentKey, referencedKey) pairs from the intermediate
model; step two fetches the referenced rows for the keys those pairs
collected. The pairs then attribute referenced rows back to parents
without a synthetic column in the select list, and without the row
multiplication an inner join would cause.
collectKeys()
```php
protected function collectKeys(
array $parents,
array $fields,
string $alias
): array;
```
Distinct, non-null local key tuples across the parent set.
fetchReferenced()
```php
protected function fetchReferenced(
RelationInterface $relation,
string $alias,
array $keys,
array $options
): Simple;
```
One query per relation node. An empty key set issues none at all -
WHERE IN () is a syntax error and there is nothing to attribute.
normalizeFields()
```php
protected function normalizeFields( mixed $fields ): array;
```
Relation fields are declared as a string for a single column and an
array for a composite key. Normalizing removes that fork everywhere
downstream.
recordKey()
```php
protected function recordKey(
mixed $record,
array $fields
): string;
```
Lookup key for an already-hydrated record.
## Mvc\Model\Eager\PathTree
Class
Turns the `eager` find parameter into a tree.
Elements are either a bare path string or `path => options`. A path implies
every one of its prefixes and prefixes are merged, so ["customer",
"customer.country"] and ["customer.country"] produce the same two-node tree.
The number of queries an eager load costs follows the number of nodes in
this tree, not the number of elements supplied.
- **`Phalcon\Mvc\Model\Eager\PathTree`**
`Phalcon\Mvc\Model\Exceptions\InvalidEagerPath` · `Phalcon\Mvc\Model\Exceptions\UnsupportedEagerOption`
### Method Summary
### Constants
Longest path accepted. Depth alone is not what makes an eager load
expensive, but an unbounded path is never intentional.
### Methods
parse()
```php
public static function parse( array $spec ): array;
```
## Mvc\Model\Exception
Class
Phalcon\Mvc\Model\Exception
Exceptions thrown in Phalcon\Mvc\Model\* classes will use this class
- `\Exception`
- **`Phalcon\Mvc\Model\Exception`**
- [`Phalcon\Mvc\Model\Behavior\Exceptions\MissingRequiredOption`](#mvcmodelbehaviorexceptionsmissingrequiredoption)
- [`Phalcon\Mvc\Model\Exceptions\BelongsToRequiresObject`](#mvcmodelexceptionsbelongstorequiresobject)
- [`Phalcon\Mvc\Model\Exceptions\BindTypeNotDefined`](#mvcmodelexceptionsbindtypenotdefined)
- [`Phalcon\Mvc\Model\Exceptions\CannotResolveAttribute`](#mvcmodelexceptionscannotresolveattribute)
- [`Phalcon\Mvc\Model\Exceptions\ColumnNotInMap`](#mvcmodelexceptionscolumnnotinmap)
- [`Phalcon\Mvc\Model\Exceptions\ColumnNotInTableColumns`](#mvcmodelexceptionscolumnnotintablecolumns)
- [`Phalcon\Mvc\Model\Exceptions\ColumnNotInTableMap`](#mvcmodelexceptionscolumnnotintablemap)
- [`Phalcon\Mvc\Model\Exceptions\CorruptColumnType`](#mvcmodelexceptionscorruptcolumntype)
- [`Phalcon\Mvc\Model\Exceptions\CursorIsImmutable`](#mvcmodelexceptionscursorisimmutable)
- [`Phalcon\Mvc\Model\Exceptions\DataTypeNotDefined`](#mvcmodelexceptionsdatatypenotdefined)
- [`Phalcon\Mvc\Model\Exceptions\EagerRowLimitExceeded`](#mvcmodelexceptionseagerrowlimitexceeded)
- [`Phalcon\Mvc\Model\Exceptions\HandlerMustImplementBindable`](#mvcmodelexceptionshandlermustimplementbindable)
- [`Phalcon\Mvc\Model\Exceptions\IdentityNotInColumnMap`](#mvcmodelexceptionsidentitynotincolumnmap)
- [`Phalcon\Mvc\Model\Exceptions\IdentityNotInTableColumns`](#mvcmodelexceptionsidentitynotintablecolumns)
- [`Phalcon\Mvc\Model\Exceptions\IndexNotInCursor`](#mvcmodelexceptionsindexnotincursor)
- [`Phalcon\Mvc\Model\Exceptions\IndexNotInRow`](#mvcmodelexceptionsindexnotinrow)
- [`Phalcon\Mvc\Model\Exceptions\InvalidConnectionService`](#mvcmodelexceptionsinvalidconnectionservice)
- [`Phalcon\Mvc\Model\Exceptions\InvalidContainer`](#mvcmodelexceptionsinvalidcontainer)
- [`Phalcon\Mvc\Model\Exceptions\InvalidDumpResultKey`](#mvcmodelexceptionsinvaliddumpresultkey)
- [`Phalcon\Mvc\Model\Exceptions\InvalidEagerParameter`](#mvcmodelexceptionsinvalideagerparameter)
- [`Phalcon\Mvc\Model\Exceptions\InvalidEagerPath`](#mvcmodelexceptionsinvalideagerpath)
- [`Phalcon\Mvc\Model\Exceptions\InvalidFindParameters`](#mvcmodelexceptionsinvalidfindparameters)
- [`Phalcon\Mvc\Model\Exceptions\InvalidGetModelNameReturn`](#mvcmodelexceptionsinvalidgetmodelnamereturn)
- [`Phalcon\Mvc\Model\Exceptions\InvalidModelName`](#mvcmodelexceptionsinvalidmodelname)
- [`Phalcon\Mvc\Model\Exceptions\InvalidModelsManagerService`](#mvcmodelexceptionsinvalidmodelsmanagerservice)
- [`Phalcon\Mvc\Model\Exceptions\InvalidModelsMetadataService`](#mvcmodelexceptionsinvalidmodelsmetadataservice)
- [`Phalcon\Mvc\Model\Exceptions\InvalidResultsetCacheService`](#mvcmodelexceptionsinvalidresultsetcacheservice)
- [`Phalcon\Mvc\Model\Exceptions\InvalidReturnedRecord`](#mvcmodelexceptionsinvalidreturnedrecord)
- [`Phalcon\Mvc\Model\Exceptions\InvalidSerializationData`](#mvcmodelexceptionsinvalidserializationdata)
- [`Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable`](#mvcmodelexceptionsmanagerormservicesunavailable)
- [`Phalcon\Mvc\Model\Exceptions\MethodNotFound`](#mvcmodelexceptionsmethodnotfound)
- [`Phalcon\Mvc\Model\Exceptions\MissingEagerKeyColumn`](#mvcmodelexceptionsmissingeagerkeycolumn)
- [`Phalcon\Mvc\Model\Exceptions\MissingMethodName`](#mvcmodelexceptionsmissingmethodname)
- [`Phalcon\Mvc\Model\Exceptions\MissingModelClassName`](#mvcmodelexceptionsmissingmodelclassname)
- [`Phalcon\Mvc\Model\Exceptions\ModelCouldNotLoad`](#mvcmodelexceptionsmodelcouldnotload)
- [`Phalcon\Mvc\Model\Exceptions\ModelOrmServicesUnavailable`](#mvcmodelexceptionsmodelormservicesunavailable)
- [`Phalcon\Mvc\Model\Exceptions\PrimaryKeyAttributeNotSet`](#mvcmodelexceptionsprimarykeyattributenotset)
- [`Phalcon\Mvc\Model\Exceptions\PrimaryKeyRequired`](#mvcmodelexceptionsprimarykeyrequired)
- [`Phalcon\Mvc\Model\Exceptions\PropertyNotAccessible`](#mvcmodelexceptionspropertynotaccessible)
- [`Phalcon\Mvc\Model\Exceptions\RecordCannotRefresh`](#mvcmodelexceptionsrecordcannotrefresh)
- [`Phalcon\Mvc\Model\Exceptions\RecordNotPersisted`](#mvcmodelexceptionsrecordnotpersisted)
- [`Phalcon\Mvc\Model\Exceptions\ReferencedFieldsMismatch`](#mvcmodelexceptionsreferencedfieldsmismatch)
- [`Phalcon\Mvc\Model\Exceptions\RelationAliasMustBeString`](#mvcmodelexceptionsrelationaliasmustbestring)
- [`Phalcon\Mvc\Model\Exceptions\RelationNotDefined`](#mvcmodelexceptionsrelationnotdefined)
- [`Phalcon\Mvc\Model\Exceptions\RelationRequiresObjectOrArray`](#mvcmodelexceptionsrelationrequiresobjectorarray)
- [`Phalcon\Mvc\Model\Exceptions\ResultsetColumnNotInMap`](#mvcmodelexceptionsresultsetcolumnnotinmap)
- [`Phalcon\Mvc\Model\Exceptions\RowIsImmutable`](#mvcmodelexceptionsrowisimmutable)
- [`Phalcon\Mvc\Model\Exceptions\SnapshotsDisabled`](#mvcmodelexceptionssnapshotsdisabled)
- [`Phalcon\Mvc\Model\Exceptions\StaticMethodRequiresOneArgument`](#mvcmodelexceptionsstaticmethodrequiresoneargument)
- [`Phalcon\Mvc\Model\Exceptions\UnknownEagerRelation`](#mvcmodelexceptionsunknowneagerrelation)
- [`Phalcon\Mvc\Model\Exceptions\UnknownRelationType`](#mvcmodelexceptionsunknownrelationtype)
- [`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerHydration`](#mvcmodelexceptionsunsupportedeagerhydration)
- [`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerOption`](#mvcmodelexceptionsunsupportedeageroption)
- [`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerResultset`](#mvcmodelexceptionsunsupportedeagerresultset)
- [`Phalcon\Mvc\Model\Exceptions\UpdateSnapshotDisabled`](#mvcmodelexceptionsupdatesnapshotdisabled)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\CannotObtainTableColumns`](#mvcmodelmetadataexceptionscannotobtaintablecolumns)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\ColumnMapNotArray`](#mvcmodelmetadataexceptionscolumnmapnotarray)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\ContainerRequired`](#mvcmodelmetadataexceptionscontainerrequired)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\CorruptedMetaData`](#mvcmodelmetadataexceptionscorruptedmetadata)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\InvalidContainer`](#mvcmodelmetadataexceptionsinvalidcontainer)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\InvalidMetaDataForModel`](#mvcmodelmetadataexceptionsinvalidmetadataformodel)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataDirectoryNotWritable`](#mvcmodelmetadataexceptionsmetadatadirectorynotwritable)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataStrategyFailed`](#mvcmodelmetadataexceptionsmetadatastrategyfailed)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\NoAnnotationsForClass`](#mvcmodelmetadataexceptionsnoannotationsforclass)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\NoPropertyAnnotationsForClass`](#mvcmodelmetadataexceptionsnopropertyannotationsforclass)
- [`Phalcon\Mvc\Model\MetaData\Exceptions\TableNotInDatabase`](#mvcmodelmetadataexceptionstablenotindatabase)
- [`Phalcon\Mvc\Model\Query\Exceptions\AmbiguousColumn`](#mvcmodelqueryexceptionsambiguouscolumn)
- [`Phalcon\Mvc\Model\Query\Exceptions\AmbiguousJoinRelation`](#mvcmodelqueryexceptionsambiguousjoinrelation)
- [`Phalcon\Mvc\Model\Query\Exceptions\BindParameterNotInPlaceholders`](#mvcmodelqueryexceptionsbindparameternotinplaceholders)
- [`Phalcon\Mvc\Model\Query\Exceptions\BindTypeRequiresArray`](#mvcmodelqueryexceptionsbindtyperequiresarray)
- [`Phalcon\Mvc\Model\Query\Exceptions\BindValueRequired`](#mvcmodelqueryexceptionsbindvaluerequired)
- [`Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderColumnNotInMap`](#mvcmodelqueryexceptionsbuilderbuildercolumnnotinmap)
- [`Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderConditionInvalid`](#mvcmodelqueryexceptionsbuilderbuilderconditioninvalid)
- [`Phalcon\Mvc\Model\Query\Exceptions\Builder\ModelRequired`](#mvcmodelqueryexceptionsbuildermodelrequired)
- [`Phalcon\Mvc\Model\Query\Exceptions\Builder\NoPrimaryKey`](#mvcmodelqueryexceptionsbuildernoprimarykey)
- [`Phalcon\Mvc\Model\Query\Exceptions\Builder\OperatorNotAvailable`](#mvcmodelqueryexceptionsbuilderoperatornotavailable)
- [`Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInDomain`](#mvcmodelqueryexceptionscolumnnotindomain)
- [`Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInSelectedModels`](#mvcmodelqueryexceptionscolumnnotinselectedmodels)
- [`Phalcon\Mvc\Model\Query\Exceptions\CorruptedAst`](#mvcmodelqueryexceptionscorruptedast)
- [`Phalcon\Mvc\Model\Query\Exceptions\CorruptedDeleteAst`](#mvcmodelqueryexceptionscorrupteddeleteast)
- [`Phalcon\Mvc\Model\Query\Exceptions\CorruptedInsertAst`](#mvcmodelqueryexceptionscorruptedinsertast)
- [`Phalcon\Mvc\Model\Query\Exceptions\CorruptedSelectAst`](#mvcmodelqueryexceptionscorruptedselectast)
- [`Phalcon\Mvc\Model\Query\Exceptions\CorruptedUpdateAst`](#mvcmodelqueryexceptionscorruptedupdateast)
- [`Phalcon\Mvc\Model\Query\Exceptions\DeleteMultipleNotSupported`](#mvcmodelqueryexceptionsdeletemultiplenotsupported)
- [`Phalcon\Mvc\Model\Query\Exceptions\DuplicateAlias`](#mvcmodelqueryexceptionsduplicatealias)
- [`Phalcon\Mvc\Model\Query\Exceptions\EmptyArrayPlaceholderValue`](#mvcmodelqueryexceptionsemptyarrayplaceholdervalue)
- [`Phalcon\Mvc\Model\Query\Exceptions\InsertColumnCountMismatch`](#mvcmodelqueryexceptionsinsertcolumncountmismatch)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidCachedResultset`](#mvcmodelqueryexceptionsinvalidcachedresultset)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidCachingOptions`](#mvcmodelqueryexceptionsinvalidcachingoptions)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidColumnDefinition`](#mvcmodelqueryexceptionsinvalidcolumndefinition)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedManager`](#mvcmodelqueryexceptionsinvalidinjectedmanager)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedMetadata`](#mvcmodelqueryexceptionsinvalidinjectedmetadata)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidQueryCacheService`](#mvcmodelqueryexceptionsinvalidquerycacheservice)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetClass`](#mvcmodelqueryexceptionsinvalidresultsetclass)
- [`Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetRowClass`](#mvcmodelqueryexceptionsinvalidresultsetrowclass)
- [`Phalcon\Mvc\Model\Query\Exceptions\JoinAliasAlreadyUsed`](#mvcmodelqueryexceptionsjoinaliasalreadyused)
- [`Phalcon\Mvc\Model\Query\Exceptions\JoinFieldCountMismatch`](#mvcmodelqueryexceptionsjoinfieldcountmismatch)
- [`Phalcon\Mvc\Model\Query\Exceptions\MissingCacheKey`](#mvcmodelqueryexceptionsmissingcachekey)
- [`Phalcon\Mvc\Model\Query\Exceptions\MissingMetaData`](#mvcmodelqueryexceptionsmissingmetadata)
- [`Phalcon\Mvc\Model\Query\Exceptions\MissingModelAttribute`](#mvcmodelqueryexceptionsmissingmodelattribute)
- [`Phalcon\Mvc\Model\Query\Exceptions\MissingModelsManager`](#mvcmodelqueryexceptionsmissingmodelsmanager)
- [`Phalcon\Mvc\Model\Query\Exceptions\MixedDatabaseSystems`](#mvcmodelqueryexceptionsmixeddatabasesystems)
- [`Phalcon\Mvc\Model\Query\Exceptions\ModelSourceNotFound`](#mvcmodelqueryexceptionsmodelsourcenotfound)
- [`Phalcon\Mvc\Model\Query\Exceptions\ModelsListNotLoaded`](#mvcmodelqueryexceptionsmodelslistnotloaded)
- [`Phalcon\Mvc\Model\Query\Exceptions\MultipleSqlStatementsNotSupported`](#mvcmodelqueryexceptionsmultiplesqlstatementsnotsupported)
- [`Phalcon\Mvc\Model\Query\Exceptions\NoModelForAlias`](#mvcmodelqueryexceptionsnomodelforalias)
- [`Phalcon\Mvc\Model\Query\Exceptions\PhqlColumnNotInMap`](#mvcmodelqueryexceptionsphqlcolumnnotinmap)
- [`Phalcon\Mvc\Model\Query\Exceptions\ReadConnectionMissing`](#mvcmodelqueryexceptionsreadconnectionmissing)
- [`Phalcon\Mvc\Model\Query\Exceptions\RelationshipNotFound`](#mvcmodelqueryexceptionsrelationshipnotfound)
- [`Phalcon\Mvc\Model\Query\Exceptions\ResultsetClassNotFound`](#mvcmodelqueryexceptionsresultsetclassnotfound)
- [`Phalcon\Mvc\Model\Query\Exceptions\ResultsetNonCacheable`](#mvcmodelqueryexceptionsresultsetnoncacheable)
- [`Phalcon\Mvc\Model\Query\Exceptions\ResultsetRowClassNotFound`](#mvcmodelqueryexceptionsresultsetrowclassnotfound)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownBindType`](#mvcmodelqueryexceptionsunknownbindtype)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownColumnType`](#mvcmodelqueryexceptionsunknowncolumntype)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownJoinType`](#mvcmodelqueryexceptionsunknownjointype)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownModelOrAlias`](#mvcmodelqueryexceptionsunknownmodeloralias)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpression`](#mvcmodelqueryexceptionsunknownphqlexpression)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpressionType`](#mvcmodelqueryexceptionsunknownphqlexpressiontype)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlStatement`](#mvcmodelqueryexceptionsunknownphqlstatement)
- [`Phalcon\Mvc\Model\Query\Exceptions\UnsafeIdentifier`](#mvcmodelqueryexceptionsunsafeidentifier)
- [`Phalcon\Mvc\Model\Query\Exceptions\UpdateMultipleNotSupported`](#mvcmodelqueryexceptionsupdatemultiplenotsupported)
- [`Phalcon\Mvc\Model\Query\Exceptions\WriteConnectionMissing`](#mvcmodelqueryexceptionswriteconnectionmissing)
- [`Phalcon\Mvc\Model\Transaction\Exception`](#mvcmodeltransactionexception)
- [`Phalcon\Mvc\Model\ValidationFailed`](#mvcmodelvalidationfailed)
## Mvc\Model\Exceptions\BelongsToRequiresObject
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\BelongsToRequiresObject`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $className,
string $relationName
);
```
## Mvc\Model\Exceptions\BindTypeNotDefined
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\BindTypeNotDefined`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $column,
string $className
);
```
## Mvc\Model\Exceptions\CannotResolveAttribute
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\CannotResolveAttribute`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $attribute,
string $className
);
```
## Mvc\Model\Exceptions\ColumnNotInMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ColumnNotInMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $column,
string $className
);
```
## Mvc\Model\Exceptions\ColumnNotInTableColumns
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ColumnNotInTableColumns`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $column,
string $className
);
```
## Mvc\Model\Exceptions\ColumnNotInTableMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ColumnNotInTableMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $column,
string $className
);
```
## Mvc\Model\Exceptions\CorruptColumnType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\CorruptColumnType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\CursorIsImmutable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\CursorIsImmutable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\DataTypeNotDefined
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\DataTypeNotDefined`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $column,
string $className
);
```
## Mvc\Model\Exceptions\EagerRowLimitExceeded
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\EagerRowLimitExceeded`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $modelName,
int $rowCount,
int $limit
);
```
## Mvc\Model\Exceptions\HandlerMustImplementBindable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\HandlerMustImplementBindable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\IdentityNotInColumnMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\IdentityNotInColumnMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $identityField,
string $className
);
```
## Mvc\Model\Exceptions\IdentityNotInTableColumns
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\IdentityNotInTableColumns`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $identityField,
string $className
);
```
## Mvc\Model\Exceptions\IndexNotInCursor
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\IndexNotInCursor`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\IndexNotInRow
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\IndexNotInRow`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidConnectionService
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidConnectionService`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidContainer
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidContainer`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidDumpResultKey
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidDumpResultKey`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\InvalidEagerParameter
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidEagerParameter`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidEagerPath
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidEagerPath`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $path );
```
## Mvc\Model\Exceptions\InvalidFindParameters
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidFindParameters`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\InvalidGetModelNameReturn
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidGetModelNameReturn`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidModelName
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidModelName`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidModelsManagerService
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidModelsManagerService`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\InvalidModelsMetadataService
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidModelsMetadataService`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\InvalidResultsetCacheService
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidResultsetCacheService`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidReturnedRecord
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidReturnedRecord`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\InvalidSerializationData
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\InvalidSerializationData`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\ManagerOrmServicesUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\MethodNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\MethodNotFound`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $method,
string $modelName
);
```
## Mvc\Model\Exceptions\MissingEagerKeyColumn
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\MissingEagerKeyColumn`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $alias,
string $column
);
```
## Mvc\Model\Exceptions\MissingMethodName
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\MissingMethodName`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\MissingModelClassName
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\MissingModelClassName`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $paramKey );
```
## Mvc\Model\Exceptions\ModelCouldNotLoad
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ModelCouldNotLoad`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $modelName );
```
## Mvc\Model\Exceptions\ModelOrmServicesUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ModelOrmServicesUnavailable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\PrimaryKeyAttributeNotSet
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\PrimaryKeyAttributeNotSet`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $attribute,
string $className
);
```
## Mvc\Model\Exceptions\PrimaryKeyRequired
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\PrimaryKeyRequired`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\PropertyNotAccessible
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\PropertyNotAccessible`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $property,
string $className
);
```
## Mvc\Model\Exceptions\RecordCannotRefresh
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RecordCannotRefresh`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\RecordNotPersisted
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RecordNotPersisted`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\ReferencedFieldsMismatch
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ReferencedFieldsMismatch`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $relationType,
string $entityName,
string $referencedEntity
);
```
## Mvc\Model\Exceptions\RelationAliasMustBeString
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RelationAliasMustBeString`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $relationType,
string $entityName,
string $referencedEntity
);
```
## Mvc\Model\Exceptions\RelationNotDefined
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RelationNotDefined`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $className,
string $alias
);
```
## Mvc\Model\Exceptions\RelationRequiresObjectOrArray
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RelationRequiresObjectOrArray`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $className,
string $relationName
);
```
## Mvc\Model\Exceptions\ResultsetColumnNotInMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\ResultsetColumnNotInMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $key );
```
## Mvc\Model\Exceptions\RowIsImmutable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\RowIsImmutable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\SnapshotsDisabled
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\SnapshotsDisabled`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\StaticMethodRequiresOneArgument
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\StaticMethodRequiresOneArgument`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $method,
string $className
);
```
## Mvc\Model\Exceptions\UnknownEagerRelation
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UnknownEagerRelation`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $modelName,
string $alias
);
```
## Mvc\Model\Exceptions\UnknownRelationType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UnknownRelationType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\UnsupportedEagerHydration
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerHydration`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Exceptions\UnsupportedEagerOption
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerOption`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $option );
```
## Mvc\Model\Exceptions\UnsupportedEagerResultset
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UnsupportedEagerResultset`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Exceptions\UpdateSnapshotDisabled
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Exceptions\UpdateSnapshotDisabled`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Hydration\CaseInsensitiveColumnMap
Class
- **`Phalcon\Mvc\Model\Hydration\CaseInsensitiveColumnMap`**
### Method Summary
Attempts to find key case-insensitively
### Methods
caseInsensitiveColumnMap()
```php
public static function caseInsensitiveColumnMap(
mixed $columnMap,
mixed $key
): string;
```
Attempts to find key case-insensitively
## Mvc\Model\Hydration\CloneResultMapHydrate
Class
- **`Phalcon\Mvc\Model\Hydration\CloneResultMapHydrate`**
`Phalcon\Mvc\Model` · `Phalcon\Mvc\Model\Exceptions\ColumnNotInMap` · `Phalcon\Mvc\Model\Resultset` · `Phalcon\Support\Settings`
### Method Summary
Returns an hydrated result based on the data and the column map
### Methods
cloneResultMapHydrate()
```php
public static function cloneResultMapHydrate(
array $data,
mixed $columnMap,
int $hydrationMode,
string $calledClass = "Phalcon\\Mvc\\Model"
);
```
Returns an hydrated result based on the data and the column map
## Mvc\Model\Manager
Class
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.
```php
use Phalcon\Di\Di;
use Phalcon\Mvc\Model\Manager as ModelsManager;
$di = new Di();
$di->set(
"modelsManager",
function() {
return new ModelsManager();
}
);
$invoice = new Invoices($di);
```
- **`Phalcon\Mvc\Model\Manager`** - implements [`Phalcon\Mvc\Model\ManagerInterface`](#mvcmodelmanagerinterface), [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
`Phalcon\Contracts\Mvc\Model\Relation\CacheKeyProvider` · `Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exceptions\InvalidConnectionService` · `Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable` · `Phalcon\Mvc\Model\Exceptions\ModelCouldNotLoad` · `Phalcon\Mvc\Model\Exceptions\ReferencedFieldsMismatch` · `Phalcon\Mvc\Model\Exceptions\RelationAliasMustBeString` · `Phalcon\Mvc\Model\Exceptions\UnknownRelationType` · `Phalcon\Mvc\Model\Query\Builder` · `Phalcon\Mvc\Model\Query\BuilderInterface` · `Phalcon\Mvc\Model\Query\StatusInterface` · `Phalcon\Support\Settings` · `ReflectionClass` · `ReflectionProperty`
### Method Summary
Destroys the current PHQL cache
Binds a behavior to a model
Setup a relation reverse many to one between two models
Setup a relation 1-n between two models
Setups a relation n-m between two models
Setup a 1-1 relation between two models
Setups a relation 1-1 between two models using an intermediate model
Clears the internal reusable list
Creates a Phalcon\Mvc\Model\Query\Builder
Creates a Phalcon\Mvc\Model\Query without execute it
Creates a Phalcon\Mvc\Model\Query and execute it
Checks whether a model has a belongsTo relation with another model
Checks whether a model has a hasMany relation with another model
Checks whether a model has a hasManyToMany relation with another model
Checks whether a model has a hasOne relation with another model
Checks whether a model has a hasOneThrough relation with another model
Gets all the belongsTo relations defined in a model
Gets belongsTo related records from a model
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
Returns the connection service name used to read or write data related to
Returns a custom events manager related to a model or null if there is
Returns the DependencyInjector container
Returns the internal event manager
Gets hasMany relations defined on a model
Gets hasMany related records from a model
Gets hasManyToMany relations defined on a model
Gets hasOne relations defined on a model
Gets hasOne relations defined on a model
Gets belongsTo related records from a model
Gets hasOneThrough relations defined on a model
Get last initialized model
Returns the last query created or executed in the models manager
Returns the prefix for all model sources.
Returns the mapped schema for a model
Returns the mapped source for a model
Returns the connection to read data related to a model
Returns the connection service name used to read data related to a model
Returns a relation by its alias
Helper method to query records based on a relation definition
Query all the relationships defined on a model
Query the first relationship defined between two models
Returns a reusable object from the internal list
Returns the connection to write data related to a model
Returns the connection service name used to write data related to a model
Checks whether a model has a belongsTo relation with another model
Checks whether a model has a hasMany relation with another model
Checks whether a model has a hasManyToMany relation with another model
Checks whether a model has a hasOne relation with another model
Checks whether a model has a hasOneThrough relation with another model
Initializes a model in the model manager
Check whether a model is already initialized
Checks if a model is keeping snapshots for the queried records
Checks if a model is using dynamic update instead of all-field update
Check whether a model property is declared as public.
Sets if a model must keep snapshots
Loads a model throwing an exception if it does not exist
Merge two arrays of find parameters
Dispatch an event to the listeners and behaviors
Receives events generated in the models and dispatches them to an
Marks the model's write connection service as written-to for the
Removes a behavior from a model
Clears the per-request sticky write tracking. Call this between
Sets both write and read connection service for a model
Sets a custom events manager for a specific model
Sets the DependencyInjector container
Sets a global events manager
Sets the prefix for all model sources.
Sets the mapped schema for a model
Sets the mapped source for a model
Sets read connection service for a model
Stores a reusable record in the internal list
Enables or disables sticky connections. When enabled, once a model has
Sets write connection service for a model
Sets if a model must use dynamic update instead of the all-field update
Returns the connection to read or write data related to a model
### Properties
Models' behaviors
Belongs to relations
All the relationships by model
Write connection services that have been written to during the current
request cycle. Used by the sticky mechanism to route reads to the write
connection after a write.
Does the model use dynamic update, instead of updating all rows?
Has many relations
Has many relations by model
Has many-Through relations
Has many-Through relations by model
Has one relations
Has one relations by model
Has one through relations
Has one through relations by model
Mark initialized models
Last model initialized
Last query created/executed
Stores a list of reusable instances
Whether reads should stick to the write connection after a write has
occurred during the current request cycle.
### Methods
__destruct()
```php
public function __destruct();
```
Destroys the current PHQL cache
addBehavior()
```php
public function addBehavior(
ModelInterface $model,
BehaviorInterface $behavior
): void;
```
Binds a behavior to a model
addBelongsTo()
```php
public function addBelongsTo(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a relation reverse many to one between two models
addHasMany()
```php
public function addHasMany(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a relation 1-n between two models
addHasManyToMany()
```php
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
addHasOne()
```php
public function addHasOne(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a 1-1 relation between two models
addHasOneThrough()
```php
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
clearReusableObjects()
```php
public function clearReusableObjects(): void;
```
Clears the internal reusable list
createBuilder()
```php
public function createBuilder( mixed $params = null ): BuilderInterface;
```
Creates a Phalcon\Mvc\Model\Query\Builder
createQuery()
```php
public function createQuery( string $phql ): QueryInterface;
```
Creates a Phalcon\Mvc\Model\Query without execute it
executeQuery()
```php
public function executeQuery(
string $phql,
mixed $placeholders = null,
mixed $types = null
): mixed;
```
Creates a Phalcon\Mvc\Model\Query and execute it
```php
$model = new Invoices();
$manager = $model->getModelsManager();
// \Phalcon\Mvc\Model\Resultset\Simple
$manager->executeQuery('SELECT * FROM Invoices');
// \Phalcon\Mvc\Model\Resultset\Complex
$manager->executeQuery('SELECT COUNT(inv_status_flag) FROM Invoices GROUP BY inv_status_flag');
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('INSERT INTO Invoices (inv_id) VALUES (1)');
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('UPDATE Invoices SET inv_id = 0 WHERE inv_id = :id:', ['id' => 1]);
// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('DELETE FROM Invoices WHERE inv_id = :id:', ['id' => 1]);
```
existsBelongsTo()
```php
public function existsBelongsTo(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a belongsTo relation with another model
existsHasMany()
```php
public function existsHasMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasMany relation with another model
existsHasManyToMany()
```php
public function existsHasManyToMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasManyToMany relation with another model
existsHasOne()
```php
public function existsHasOne(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOne relation with another model
existsHasOneThrough()
```php
public function existsHasOneThrough(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOneThrough relation with another model
getBelongsTo()
```php
public function getBelongsTo( ModelInterface $model ): RelationInterface[]|array;
```
Gets all the belongsTo relations defined in a model
```php
$relations = $modelsManager->getBelongsTo(
new Invoices()
);
```
getBelongsToRecords()
```php
public function getBelongsToRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ResultsetInterface|bool;
```
Gets belongsTo related records from a model
getBuilder()
```php
public function getBuilder(): BuilderInterface|null;
```
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
getConnectionService()
```php
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
getCustomEventsManager()
```php
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
getDI()
```php
public function getDI(): DiInterface;
```
Returns the DependencyInjector container
getEventsManager()
```php
public function getEventsManager(): EventsManagerInterface|null;
```
Returns the internal event manager
getHasMany()
```php
public function getHasMany( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasMany relations defined on a model
getHasManyRecords()
```php
public function getHasManyRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ResultsetInterface|bool;
```
Gets hasMany related records from a model
getHasManyToMany()
```php
public function getHasManyToMany( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasManyToMany relations defined on a model
getHasOne()
```php
public function getHasOne( ModelInterface $model ): array;
```
Gets hasOne relations defined on a model
getHasOneAndHasMany()
```php
public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];
```
Gets hasOne relations defined on a model
getHasOneRecords()
```php
public function getHasOneRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ModelInterface|bool;
```
Gets belongsTo related records from a model
getHasOneThrough()
```php
public function getHasOneThrough( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasOneThrough relations defined on a model
getLastInitialized()
```php
public function getLastInitialized(): ModelInterface|null;
```
Get last initialized model
getLastQuery()
```php
public function getLastQuery(): QueryInterface;
```
Returns the last query created or executed in the models manager
getModelPrefix()
```php
public function getModelPrefix(): string;
```
Returns the prefix for all model sources.
getModelSchema()
```php
public function getModelSchema( ModelInterface $model ): string|null;
```
Returns the mapped schema for a model
getModelSource()
```php
public function getModelSource( ModelInterface $model ): string;
```
Returns the mapped source for a model
getReadConnection()
```php
public function getReadConnection( ModelInterface $model ): AdapterInterface;
```
Returns the connection to read data related to a model
getReadConnectionService()
```php
public function getReadConnectionService( ModelInterface $model ): string;
```
Returns the connection service name used to read data related to a model
getRelationByAlias()
```php
public function getRelationByAlias(
string $modelName,
string $alias
): RelationInterface|bool;
```
Returns a relation by its alias
getRelationRecords()
```php
public function getRelationRecords(
RelationInterface $relation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
);
```
Helper method to query records based on a relation definition
getRelations()
```php
public function getRelations( string $modelName ): RelationInterface[];
```
Query all the relationships defined on a model
getRelationsBetween()
```php
public function getRelationsBetween(
string $first,
string $second
): RelationInterface[]|bool;
```
Query the first relationship defined between two models
getReusableRecords()
```php
public function getReusableRecords(
string $modelName,
string $key
);
```
Returns a reusable object from the internal list
getWriteConnection()
```php
public function getWriteConnection( ModelInterface $model ): AdapterInterface;
```
Returns the connection to write data related to a model
getWriteConnectionService()
```php
public function getWriteConnectionService( ModelInterface $model ): string;
```
Returns the connection service name used to write data related to a model
hasBelongsTo()
```php
public function hasBelongsTo(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a belongsTo relation with another model
hasHasMany()
```php
public function hasHasMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasMany relation with another model
hasHasManyToMany()
```php
public function hasHasManyToMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasManyToMany relation with another model
hasHasOne()
```php
public function hasHasOne(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOne relation with another model
hasHasOneThrough()
```php
public function hasHasOneThrough(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOneThrough relation with another model
initialize()
```php
public function initialize( ModelInterface $model ): bool;
```
Initializes a model in the model manager
isInitialized()
```php
public function isInitialized( string $className ): bool;
```
Check whether a model is already initialized
isKeepingSnapshots()
```php
public function isKeepingSnapshots( ModelInterface $model ): bool;
```
Checks if a model is keeping snapshots for the queried records
isUsingDynamicUpdate()
```php
public function isUsingDynamicUpdate( ModelInterface $model ): bool;
```
Checks if a model is using dynamic update instead of all-field update
isVisibleModelProperty()
```php
final public function isVisibleModelProperty(
ModelInterface $model,
string $property
): bool;
```
Check whether a model property is declared as public.
```php
$isPublic = $manager->isVisibleModelProperty(
new Invoices(),
"name"
);
```
keepSnapshots()
```php
public function keepSnapshots(
ModelInterface $model,
bool $keepSnapshots
): void;
```
Sets if a model must keep snapshots
load()
```php
public function load( string $modelName ): ModelInterface;
```
Loads a model throwing an exception if it does not exist
mergeFindParameters()
```php
final public static function mergeFindParameters(
mixed $findParamsOne,
mixed $findParamsTwo
): array;
```
Merge two arrays of find parameters
The order matters. Conditions coming from key 0 or "conditions" are
ANDed in argument order; `bind` and `bindTypes` are merged for the
second argument only and assigned outright for the first. Pass the
parameters whose bindings must survive as the second argument.
Static because it reads nothing but its arguments, and public so bulk
loaders can reuse the merge instead of duplicating these semantics.
missingMethod()
```php
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
notifyEvent()
```php
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
registerWrite()
```php
public function registerWrite( ModelInterface $model ): void;
```
Marks the model's write connection service as written-to for the
current request cycle. Used by the sticky mechanism to route
subsequent reads to the write connection.
removeBehavior()
```php
public function removeBehavior(
ModelInterface $model,
string $behaviorClass
): void;
```
Removes a behavior from a model
resetConnectionState()
```php
public function resetConnectionState(): void;
```
Clears the per-request sticky write tracking. Call this between
requests in long-running runtimes (e.g. Swoole, RoadRunner) where the
manager instance is reused across requests.
setConnectionService()
```php
public function setConnectionService(
ModelInterface $model,
string $connectionService
): void;
```
Sets both write and read connection service for a model
setCustomEventsManager()
```php
public function setCustomEventsManager(
ModelInterface $model,
EventsManagerInterface $eventsManager
): void;
```
Sets a custom events manager for a specific model
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the DependencyInjector container
setEventsManager()
```php
public function setEventsManager( EventsManagerInterface $eventsManager ): void;
```
Sets a global events manager
setModelPrefix()
```php
public function setModelPrefix( string $prefix ): void;
```
Sets the prefix for all model sources.
```php
use Phalcon\Mvc\Model\Manager;
$di->set(
"modelsManager",
function () {
$modelsManager = new Manager();
$modelsManager->setModelPrefix("wp_");
return $modelsManager;
}
);
$invoices = new Invoices();
echo $invoices->getSource(); // wp_co_invoices
```
$param string $prefix
setModelSchema()
```php
public function setModelSchema(
ModelInterface $model,
string $schema
): void;
```
Sets the mapped schema for a model
setModelSource()
```php
public function setModelSource(
ModelInterface $model,
string $source
): void;
```
Sets the mapped source for a model
setReadConnectionService()
```php
public function setReadConnectionService(
ModelInterface $model,
string $connectionService
): void;
```
Sets read connection service for a model
setReusableRecords()
```php
public function setReusableRecords(
string $modelName,
string $key,
mixed $records
): void;
```
Stores a reusable record in the internal list
setSticky()
```php
public function setSticky( bool $sticky ): void;
```
Enables or disables sticky connections. When enabled, once a model has
written to its write connection during the current request cycle, any
further reads for that write service use the write connection.
setWriteConnectionService()
```php
public function setWriteConnectionService(
ModelInterface $model,
string $connectionService
): void;
```
Sets write connection service for a model
useDynamicUpdate()
```php
public function useDynamicUpdate(
ModelInterface $model,
bool $dynamicUpdate
): void;
```
Sets if a model must use dynamic update instead of the all-field update
getConnection()
```php
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.
## Mvc\Model\ManagerInterface
Interface
Phalcon\Mvc\Model\ManagerInterface
Interface for Phalcon\Mvc\Model\Manager
- **`Phalcon\Mvc\Model\ManagerInterface`**
`Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Query\BuilderInterface` · `Phalcon\Mvc\Model\Query\StatusInterface`
### Method Summary
Binds a behavior to a model
Setup a relation reverse 1-1 between two models
Setup a relation 1-n between two models
Setups a relation n-m between two models
Setup a 1-1 relation between two models
Setups a 1-1 relation between two models using an intermediate table
Clears the internal reusable list
Creates a Phalcon\Mvc\Model\Query\Builder
Creates a Phalcon\Mvc\Model\Query without execute it
Creates a Phalcon\Mvc\Model\Query and execute it
Gets belongsTo relations defined on a model
Gets belongsTo related records from a model
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
Gets hasMany relations defined on a model
Gets hasMany related records from a model
Gets hasManyToMany relations defined on a model
Gets hasOne relations defined on a model
Gets hasOne relations defined on a model
Gets hasOne related records from a model
Gets hasOneThrough relations defined on a model
Get last initialized model
Returns the last query created or executed in the models manager
Returns the mapped schema for a model
Returns the mapped source for a model
Returns the connection to read data related to a model
Returns the connection service name used to read data related to a model
Returns a relation by its alias
Helper method to query records based on a relation definition
Query all the relationships defined on a model
Query the relations between two models
Returns a reusable object from the internal list
Returns the connection to write data related to a model
Returns the connection service name used to write data related to a model
Checks whether a model has a belongsTo relation with another model
Checks whether a model has a hasMany relation with another model
Checks whether a model has a hasManyToMany relation with another model
Checks whether a model has a hasOne relation with another model
Checks whether a model has a hasOneThrough relation with another model
Initializes a model in the model manager
Check of a model is already initialized
Checks if a model is keeping snapshots for the queried records
Checks if a model is using dynamic update instead of all-field update
Check whether a model property is declared as public.
Sets if a model must keep snapshots
Loads a model throwing an exception if it does not exist
Dispatch an event to the listeners and behaviors
Receives events generated in the models and dispatches them to an events-manager if available
Marks the model's write connection service as written-to for the
Removes a behavior from a model
Clears the per-request sticky write tracking
Sets both write and read connection service for a model
Sets the mapped schema for a model
Sets the mapped source for a model
Sets read connection service for a model
Stores a reusable record in the internal list
Enables or disables sticky connections
Sets write connection service for a model
Sets if a model must use dynamic update instead of the all-field update
### Methods
addBehavior()
```php
public function addBehavior(
ModelInterface $model,
BehaviorInterface $behavior
): void;
```
Binds a behavior to a model
addBelongsTo()
```php
public function addBelongsTo(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a relation reverse 1-1 between two models
addHasMany()
```php
public function addHasMany(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a relation 1-n between two models
addHasManyToMany()
```php
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
addHasOne()
```php
public function addHasOne(
ModelInterface $model,
mixed $fields,
string $referencedModel,
mixed $referencedFields,
array $options = []
): RelationInterface;
```
Setup a 1-1 relation between two models
addHasOneThrough()
```php
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
clearReusableObjects()
```php
public function clearReusableObjects(): void;
```
Clears the internal reusable list
createBuilder()
```php
public function createBuilder( mixed $params = null ): BuilderInterface;
```
Creates a Phalcon\Mvc\Model\Query\Builder
createQuery()
```php
public function createQuery( string $phql ): QueryInterface;
```
Creates a Phalcon\Mvc\Model\Query without execute it
executeQuery()
```php
public function executeQuery(
string $phql,
mixed $placeholders = null,
mixed $types = null
): mixed;
```
Creates a Phalcon\Mvc\Model\Query and execute it
getBelongsTo()
```php
public function getBelongsTo( ModelInterface $model ): RelationInterface[]|array;
```
Gets belongsTo relations defined on a model
getBelongsToRecords()
```php
public function getBelongsToRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ResultsetInterface|bool;
```
Gets belongsTo related records from a model
getBuilder()
```php
public function getBuilder(): BuilderInterface|null;
```
Returns the newly created Phalcon\Mvc\Model\Query\Builder or null
getHasMany()
```php
public function getHasMany( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasMany relations defined on a model
getHasManyRecords()
```php
public function getHasManyRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ResultsetInterface|bool;
```
Gets hasMany related records from a model
getHasManyToMany()
```php
public function getHasManyToMany( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasManyToMany relations defined on a model
getHasOne()
```php
public function getHasOne( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasOne relations defined on a model
getHasOneAndHasMany()
```php
public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];
```
Gets hasOne relations defined on a model
getHasOneRecords()
```php
public function getHasOneRecords(
string $modelName,
string $modelRelation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
): ModelInterface|bool;
```
Gets hasOne related records from a model
getHasOneThrough()
```php
public function getHasOneThrough( ModelInterface $model ): RelationInterface[]|array;
```
Gets hasOneThrough relations defined on a model
getLastInitialized()
```php
public function getLastInitialized(): ModelInterface|null;
```
Get last initialized model
getLastQuery()
```php
public function getLastQuery(): QueryInterface;
```
Returns the last query created or executed in the models manager
getModelSchema()
```php
public function getModelSchema( ModelInterface $model ): string|null;
```
Returns the mapped schema for a model
getModelSource()
```php
public function getModelSource( ModelInterface $model ): string;
```
Returns the mapped source for a model
getReadConnection()
```php
public function getReadConnection( ModelInterface $model ): AdapterInterface;
```
Returns the connection to read data related to a model
getReadConnectionService()
```php
public function getReadConnectionService( ModelInterface $model ): string;
```
Returns the connection service name used to read data related to a model
getRelationByAlias()
```php
public function getRelationByAlias(
string $modelName,
string $alias
): RelationInterface|bool;
```
Returns a relation by its alias
getRelationRecords()
```php
public function getRelationRecords(
RelationInterface $relation,
ModelInterface $record,
mixed $parameters = null,
string|null $method = null
);
```
Helper method to query records based on a relation definition
getRelations()
```php
public function getRelations( string $modelName ): RelationInterface[];
```
Query all the relationships defined on a model
getRelationsBetween()
```php
public function getRelationsBetween(
string $first,
string $second
): RelationInterface[]|bool;
```
Query the relations between two models
getReusableRecords()
```php
public function getReusableRecords(
string $modelName,
string $key
);
```
Returns a reusable object from the internal list
getWriteConnection()
```php
public function getWriteConnection( ModelInterface $model ): AdapterInterface;
```
Returns the connection to write data related to a model
getWriteConnectionService()
```php
public function getWriteConnectionService( ModelInterface $model ): string;
```
Returns the connection service name used to write data related to a model
hasBelongsTo()
```php
public function hasBelongsTo(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a belongsTo relation with another model
hasHasMany()
```php
public function hasHasMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasMany relation with another model
hasHasManyToMany()
```php
public function hasHasManyToMany(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasManyToMany relation with another model
hasHasOne()
```php
public function hasHasOne(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOne relation with another model
hasHasOneThrough()
```php
public function hasHasOneThrough(
string $modelName,
string $modelRelation
): bool;
```
Checks whether a model has a hasOneThrough relation with another model
initialize()
```php
public function initialize( ModelInterface $model );
```
Initializes a model in the model manager
isInitialized()
```php
public function isInitialized( string $className ): bool;
```
Check of a model is already initialized
isKeepingSnapshots()
```php
public function isKeepingSnapshots( ModelInterface $model ): bool;
```
Checks if a model is keeping snapshots for the queried records
isUsingDynamicUpdate()
```php
public function isUsingDynamicUpdate( ModelInterface $model ): bool;
```
Checks if a model is using dynamic update instead of all-field update
isVisibleModelProperty()
```php
public function isVisibleModelProperty(
ModelInterface $model,
string $property
): bool;
```
Check whether a model property is declared as public.
```php
$isPublic = $manager->isVisibleModelProperty(
new Invoices(),
"name"
);
```
keepSnapshots()
```php
public function keepSnapshots(
ModelInterface $model,
bool $keepSnapshots
): void;
```
Sets if a model must keep snapshots
load()
```php
public function load( string $modelName ): ModelInterface;
```
Loads a model throwing an exception if it does not exist
missingMethod()
```php
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
notifyEvent()
```php
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
registerWrite()
```php
public function registerWrite( ModelInterface $model ): void;
```
Marks the model's write connection service as written-to for the
current request cycle (sticky connections)
removeBehavior()
```php
public function removeBehavior(
ModelInterface $model,
string $behaviorClass
): void;
```
Removes a behavior from a model
resetConnectionState()
```php
public function resetConnectionState(): void;
```
Clears the per-request sticky write tracking
setConnectionService()
```php
public function setConnectionService(
ModelInterface $model,
string $connectionService
): void;
```
Sets both write and read connection service for a model
setModelSchema()
```php
public function setModelSchema(
ModelInterface $model,
string $schema
): void;
```
Sets the mapped schema for a model
setModelSource()
```php
public function setModelSource(
ModelInterface $model,
string $source
): void;
```
Sets the mapped source for a model
setReadConnectionService()
```php
public function setReadConnectionService(
ModelInterface $model,
string $connectionService
): void;
```
Sets read connection service for a model
setReusableRecords()
```php
public function setReusableRecords(
string $modelName,
string $key,
mixed $records
): void;
```
Stores a reusable record in the internal list
setSticky()
```php
public function setSticky( bool $sticky ): void;
```
Enables or disables sticky connections
setWriteConnectionService()
```php
public function setWriteConnectionService(
ModelInterface $model,
string $connectionService
);
```
Sets write connection service for a model
useDynamicUpdate()
```php
public function useDynamicUpdate(
ModelInterface $model,
bool $dynamicUpdate
): void;
```
Sets if a model must use dynamic update instead of the all-field update
## Mvc\Model\MetaData
Abstract
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:
```php
$metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
$attributes = $metaData->getAttributes(
new Invoices()
);
print_r($attributes);
```
Each model's metadata is stored as two positional arrays addressed by two
constant families. Both families count from 0 and therefore share numeric
values, so a metadata array is only meaningful together with the family that
indexes it. The metadata cache adapters persist these arrays verbatim, so the
slot layout is a stored format: reordering a slot invalidates existing
caches.
Attribute metadata array (`MODELS_*` family):
| Slot | Constant | Contents |
|------|-----------------------------------|-------------------------------------------------|
| 0 | `MODELS_ATTRIBUTES` | All mapped attribute (column) names |
| 1 | `MODELS_PRIMARY_KEY` | Primary-key attributes |
| 2 | `MODELS_NON_PRIMARY_KEY` | Non-primary-key attributes |
| 3 | `MODELS_NOT_NULL` | Attributes declared `NOT NULL` |
| 4 | `MODELS_DATA_TYPES` | attribute => column data type |
| 5 | `MODELS_DATA_TYPES_NUMERIC` | Attributes with a numeric type |
| 6 | `MODELS_DATE_AT` | Reserved (declared, currently unused) |
| 7 | `MODELS_DATE_IN` | Reserved (declared, currently unused) |
| 8 | `MODELS_IDENTITY_COLUMN` | The auto-increment identity attribute |
| 9 | `MODELS_DATA_TYPES_BIND` | attribute => PDO bind type |
| 10 | `MODELS_AUTOMATIC_DEFAULT_INSERT` | Attributes omitted from `INSERT` (DB-defaulted) |
| 11 | `MODELS_AUTOMATIC_DEFAULT_UPDATE` | Attributes omitted from `UPDATE` (DB-defaulted) |
| 12 | `MODELS_DEFAULT_VALUES` | attribute => default value |
| 13 | `MODELS_EMPTY_STRING_VALUES` | Attributes that keep `''` instead of `NULL` |
Column-map array (`MODELS_COLUMN_MAP` family), present only when a column map
is defined:
| Slot | Constant | Contents |
|------|-----------------------------|---------------------|
| 0 | `MODELS_COLUMN_MAP` | column => attribute |
| 1 | `MODELS_REVERSE_COLUMN_MAP` | attribute => column |
- **`Phalcon\Mvc\Model\MetaData`** - implements [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface), [`Phalcon\Mvc\Model\MetaDataInterface`](#mvcmodelmetadatainterface)
- [`Phalcon\Mvc\Model\MetaData\Apcu`](#mvcmodelmetadataapcu)
- [`Phalcon\Mvc\Model\MetaData\Libmemcached`](#mvcmodelmetadatalibmemcached)
- [`Phalcon\Mvc\Model\MetaData\Memory`](#mvcmodelmetadatamemory)
- [`Phalcon\Mvc\Model\MetaData\Redis`](#mvcmodelmetadataredis)
- [`Phalcon\Mvc\Model\MetaData\Stream`](#mvcmodelmetadatastream)
`Phalcon\Cache\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\MetaData\Exceptions\ContainerRequired` · `Phalcon\Mvc\Model\MetaData\Exceptions\CorruptedMetaData` · `Phalcon\Mvc\Model\MetaData\Exceptions\InvalidMetaDataForModel` · `Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataStrategyFailed` · `Phalcon\Mvc\Model\MetaData\Strategy\Introspection` · `Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface` · `Phalcon\Support\Settings` · `Phalcon\Traits\Support\Helper\Arr\GetTrait`
### Method Summary
Return the internal cache adapter
Returns table attributes names (fields)
Returns attributes that must be ignored from the INSERT SQL generation
Returns attributes that must be ignored from the UPDATE SQL generation
Returns attributes and their bind data types
Returns the column map if any
Returns a ColumnMap Unique key for meta-data is created using className
Returns the DependencyInjector container
Returns attributes and their data types
Returns attributes which types are numerical
Returns attributes (which have default values) and their default values
Returns attributes allow empty strings
Returns the name of identity field (if one is present)
Returns a MetaData Unique key for meta-data is created using className
Returns the model UniqueID based on model and array row primary key(s) value(s)
Returns an array of fields which are not part of the primary key
Returns an array of not null attributes
Returns an array of fields which are part of the primary key
Returns the reverse column map if any
Return the strategy to obtain the meta-data
Check if a model has certain attribute
Checks if the internal meta-data container is empty
Compares if two models are the same in memory
Reads metadata from the adapter
Reads the ordered/reversed column map for certain model
Reads column-map information for certain model using a MODEL_* constant
Reads the complete meta-data for certain model
Reads meta-data for certain model
Resets internal meta-data in order to regenerate it
Set the attributes that must be ignored from the INSERT SQL generation
Set the attributes that must be ignored from the UPDATE SQL generation
Sets the DependencyInjector container
Set the attributes that allow empty string values
Set the meta-data extraction strategy
Writes the metadata to adapter
Writes meta-data for certain model using a MODEL_* constant
Initialize old behavior for compatability
Initialize ColumnMap for a certain table
Initialize the metadata for certain table
### Constants
### Properties
Holds metadata index writes that arrived before the model's metadata was
properly initialized (e.g. skipAttributes() called in a parent model's
initialize() while the child's source had not yet been set). Applied
inside initializeMetaData() after the real schema is loaded.
### Methods
```php
public function getAdapter(): CacheAdapterInterface|null;
```
Return the internal cache adapter
```php
public function getAttributes( ModelInterface $model ): array;
```
Returns table attributes names (fields)
```php
print_r(
$metaData->getAttributes(
new Invoices()
)
);
```
```php
public function getAutomaticCreateAttributes( ModelInterface $model ): array;
```
Returns attributes that must be ignored from the INSERT SQL generation
```php
print_r(
$metaData->getAutomaticCreateAttributes(
new Invoices()
)
);
```
```php
public function getAutomaticUpdateAttributes( ModelInterface $model ): array;
```
Returns attributes that must be ignored from the UPDATE SQL generation
```php
print_r(
$metaData->getAutomaticUpdateAttributes(
new Invoices()
)
);
```
```php
public function getBindTypes( ModelInterface $model ): array;
```
Returns attributes and their bind data types
```php
print_r(
$metaData->getBindTypes(
new Invoices()
)
);
```
```php
public function getColumnMap( ModelInterface $model ): array|null;
```
Returns the column map if any
```php
print_r(
$metaData->getColumnMap(
new Invoices()
)
);
```
```php
public final function getColumnMapUniqueKey( ModelInterface $model ): string|null;
```
Returns a ColumnMap Unique key for meta-data is created using className
```php
public function getDI(): DiInterface;
```
Returns the DependencyInjector container
```php
public function getDataTypes( ModelInterface $model ): array;
```
Returns attributes and their data types
```php
print_r(
$metaData->getDataTypes(
new Invoices()
)
);
```
```php
public function getDataTypesNumeric( ModelInterface $model ): array;
```
Returns attributes which types are numerical
```php
print_r(
$metaData->getDataTypesNumeric(
new Invoices()
)
);
```
```php
public function getDefaultValues( ModelInterface $model ): array;
```
Returns attributes (which have default values) and their default values
```php
print_r(
$metaData->getDefaultValues(
new Invoices()
)
);
```
```php
public function getEmptyStringAttributes( ModelInterface $model ): array;
```
Returns attributes allow empty strings
```php
print_r(
$metaData->getEmptyStringAttributes(
new Invoices()
)
);
```
```php
public function getIdentityField( ModelInterface $model ): bool|string|null;
```
Returns the name of identity field (if one is present)
```php
print_r(
$metaData->getIdentityField(
new Invoices()
)
);
```
```php
public final function getMetaDataUniqueKey( ModelInterface $model ): string|null;
```
Returns a MetaData Unique key for meta-data is created using className
```php
public function getModelUUID(
ModelInterface $model,
array $row
): string|null;
```
Returns the model UniqueID based on model and array row primary key(s) value(s)
```php
public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;
```
Returns an array of fields which are not part of the primary key
```php
print_r(
$metaData->getNonPrimaryKeyAttributes(
new Invoices()
)
);
```
```php
public function getNotNullAttributes( ModelInterface $model ): array;
```
Returns an array of not null attributes
```php
print_r(
$metaData->getNotNullAttributes(
new Invoices()
)
);
```
```php
public function getPrimaryKeyAttributes( ModelInterface $model ): array;
```
Returns an array of fields which are part of the primary key
```php
print_r(
$metaData->getPrimaryKeyAttributes(
new Invoices()
)
);
```
```php
public function getReverseColumnMap( ModelInterface $model ): array|null;
```
Returns the reverse column map if any
```php
print_r(
$metaData->getReverseColumnMap(
new Invoices()
)
);
```
```php
public function getStrategy(): StrategyInterface;
```
Return the strategy to obtain the meta-data
```php
public function hasAttribute(
ModelInterface $model,
string $attribute
): bool;
```
Check if a model has certain attribute
```php
var_dump(
$metaData->hasAttribute(
new Invoices(),
"name"
)
);
```
```php
public function isEmpty(): bool;
```
Checks if the internal meta-data container is empty
```php
var_dump(
$metaData->isEmpty()
);
```
```php
public function modelEquals(
ModelInterface $first,
ModelInterface $other
): bool;
```
Compares if two models are the same in memory
```php
public function read( mixed $key ): array|null;
```
Reads metadata from the adapter
```php
final public function readColumnMap( ModelInterface $model ): array|null;
```
Reads the ordered/reversed column map for certain model
```php
print_r(
$metaData->readColumnMap(
new Invoices()
)
);
```
```php
final public function readColumnMapIndex(
ModelInterface $model,
int $index
): array|null;
```
Reads column-map information for certain model using a MODEL_* constant
```php
print_r(
$metaData->readColumnMapIndex(
new Invoices(),
MetaData::MODELS_REVERSE_COLUMN_MAP
)
);
```
```php
final public function readMetaData( ModelInterface $model ): array|null;
```
Reads the complete meta-data for certain model
```php
print_r(
$metaData->readMetaData(
new Invoices()
)
);
```
```php
final public function readMetaDataIndex(
ModelInterface $model,
int $index
): array|string|null;
```
Reads meta-data for certain model
```php
print_r(
$metaData->readMetaDataIndex(
new Invoices(),
0
)
);
```
```php
public function reset(): void;
```
Resets internal meta-data in order to regenerate it
```php
$metaData->reset();
```
```php
public function setAutomaticCreateAttributes(
ModelInterface $model,
array $attributes
): void;
```
Set the attributes that must be ignored from the INSERT SQL generation
```php
$metaData->setAutomaticCreateAttributes(
new Invoices(),
[
"created_at" => true,
]
);
```
```php
public function setAutomaticUpdateAttributes(
ModelInterface $model,
array $attributes
): void;
```
Set the attributes that must be ignored from the UPDATE SQL generation
```php
$metaData->setAutomaticUpdateAttributes(
new Invoices(),
[
"modified_at" => true,
]
);
```
```php
public function setDI( DiInterface $container ): void;
```
Sets the DependencyInjector container
```php
public function setEmptyStringAttributes(
ModelInterface $model,
array $attributes
): void;
```
Set the attributes that allow empty string values
```php
$metaData->setEmptyStringAttributes(
new Invoices(),
[
"name" => true,
]
);
```
```php
public function setStrategy( StrategyInterface $strategy ): void;
```
Set the meta-data extraction strategy
```php
public function write(
string $key,
array $data
): void;
```
Writes the metadata to adapter
```php
final public function writeMetaDataIndex(
ModelInterface $model,
int $index,
mixed $data
): void;
```
Writes meta-data for certain model using a MODEL_* constant
```php
print_r(
$metaData->writeColumnMapIndex(
new Invoices(),
MetaData::MODELS_REVERSE_COLUMN_MAP,
[
"leName" => "name",
]
)
);
```
```php
final protected function initialize(
ModelInterface $model,
mixed $key,
mixed $table,
mixed $schema
);
```
Initialize old behavior for compatability
```php
final protected function initializeColumnMap(
ModelInterface $model,
mixed $key
): bool;
```
Initialize ColumnMap for a certain table
```php
final protected function initializeMetaData(
ModelInterface $model,
mixed $key
): bool;
```
Initialize the metadata for certain table
## Mvc\Model\MetaDataInterface
Interface
Phalcon\Mvc\Model\MetaDataInterface
Interface for Phalcon\Mvc\Model\MetaData
- **`Phalcon\Mvc\Model\MetaDataInterface`**
`Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface`
### Method Summary
Returns table attributes names (fields)
Returns attributes that must be ignored from the INSERT SQL generation
Returns attributes that must be ignored from the UPDATE SQL generation
Returns attributes and their bind data types
Returns the column map if any
Returns attributes and their data types
Returns attributes which types are numerical
Returns attributes (which have default values) and their default values
Returns attributes allow empty strings
Returns the name of identity field (if one is present)
Returns an array of fields which are not part of the primary key
Returns an array of not null attributes
Returns an array of fields which are part of the primary key
Returns the reverse column map if any
Return the strategy to obtain the meta-data
Check if a model has certain attribute
Checks if the internal meta-data container is empty
Reads meta-data from the adapter
Reads the ordered/reversed column map for certain model
Reads column-map information for certain model using a MODEL_* constant
Reads meta-data for certain model
Reads meta-data for certain model using a MODEL_* constant
Resets internal meta-data in order to regenerate it
Set the attributes that must be ignored from the INSERT SQL generation
Set the attributes that must be ignored from the UPDATE SQL generation
Set the attributes that allow empty string values
Set the meta-data extraction strategy
Writes meta-data to the adapter
Writes meta-data for certain model using a MODEL_* constant
### Methods
```php
public function getAttributes( ModelInterface $model ): array;
```
Returns table attributes names (fields)
```php
public function getAutomaticCreateAttributes( ModelInterface $model ): array;
```
Returns attributes that must be ignored from the INSERT SQL generation
```php
public function getAutomaticUpdateAttributes( ModelInterface $model ): array;
```
Returns attributes that must be ignored from the UPDATE SQL generation
```php
public function getBindTypes( ModelInterface $model ): array;
```
Returns attributes and their bind data types
```php
public function getColumnMap( ModelInterface $model ): array|null;
```
Returns the column map if any
```php
public function getDataTypes( ModelInterface $model ): array;
```
Returns attributes and their data types
```php
public function getDataTypesNumeric( ModelInterface $model ): array;
```
Returns attributes which types are numerical
```php
public function getDefaultValues( ModelInterface $model ): array;
```
Returns attributes (which have default values) and their default values
```php
public function getEmptyStringAttributes( ModelInterface $model ): array;
```
Returns attributes allow empty strings
```php
public function getIdentityField( ModelInterface $model ): bool|string|null;
```
Returns the name of identity field (if one is present)
```php
public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;
```
Returns an array of fields which are not part of the primary key
```php
public function getNotNullAttributes( ModelInterface $model ): array;
```
Returns an array of not null attributes
```php
public function getPrimaryKeyAttributes( ModelInterface $model ): array;
```
Returns an array of fields which are part of the primary key
```php
public function getReverseColumnMap( ModelInterface $model ): array|null;
```
Returns the reverse column map if any
```php
public function getStrategy(): StrategyInterface;
```
Return the strategy to obtain the meta-data
```php
public function hasAttribute(
ModelInterface $model,
string $attribute
): bool;
```
Check if a model has certain attribute
```php
public function isEmpty(): bool;
```
Checks if the internal meta-data container is empty
```php
public function read( string $key ): array|null;
```
Reads meta-data from the adapter
```php
public function readColumnMap( ModelInterface $model ): array|null;
```
Reads the ordered/reversed column map for certain model
```php
public function readColumnMapIndex(
ModelInterface $model,
int $index
): array|null;
```
Reads column-map information for certain model using a MODEL_* constant
```php
public function readMetaData( ModelInterface $model ): array|null;
```
Reads meta-data for certain model
```php
public function readMetaDataIndex(
ModelInterface $model,
int $index
): array|string|null;
```
Reads meta-data for certain model using a MODEL_* constant
```php
public function reset();
```
Resets internal meta-data in order to regenerate it
```php
public function setAutomaticCreateAttributes(
ModelInterface $model,
array $attributes
);
```
Set the attributes that must be ignored from the INSERT SQL generation
```php
public function setAutomaticUpdateAttributes(
ModelInterface $model,
array $attributes
);
```
Set the attributes that must be ignored from the UPDATE SQL generation
```php
public function setEmptyStringAttributes(
ModelInterface $model,
array $attributes
): void;
```
Set the attributes that allow empty string values
```php
public function setStrategy( StrategyInterface $strategy );
```
Set the meta-data extraction strategy
```php
public function write(
string $key,
array $data
): void;
```
Writes meta-data to the adapter
```php
public function writeMetaDataIndex(
ModelInterface $model,
int $index,
mixed $data
);
```
Writes meta-data for certain model using a MODEL_* constant
## Mvc\Model\MetaData\Apcu
Class
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')
```php
$metaData = new \Phalcon\Mvc\Model\MetaData\Apcu(
[
"prefix" => "my-app-id",
"lifetime" => 86400,
]
);
```
- [`Phalcon\Mvc\Model\MetaData`](#mvcmodelmetadata)
- **`Phalcon\Mvc\Model\MetaData\Apcu`**
`Phalcon\Cache\AdapterFactory` · `Phalcon\Mvc\Model\MetaData`
### Method Summary
Phalcon\Mvc\Model\MetaData\Apcu constructor
### Methods
```php
public function __construct(
AdapterFactory $factory,
array|null $options = null
);
```
Phalcon\Mvc\Model\MetaData\Apcu constructor
## Mvc\Model\MetaData\Exceptions\CannotObtainTableColumns
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\CannotObtainTableColumns`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct(
string $completeTable,
string $className
);
```
## Mvc\Model\MetaData\Exceptions\ColumnMapNotArray
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\ColumnMapNotArray`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\MetaData\Exceptions\ContainerRequired
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\ContainerRequired`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\MetaData\Exceptions\CorruptedMetaData
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\CorruptedMetaData`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\MetaData\Exceptions\InvalidContainer
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\InvalidContainer`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\MetaData\Exceptions\InvalidMetaDataForModel
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\InvalidMetaDataForModel`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct( string $modelName );
```
## Mvc\Model\MetaData\Exceptions\MetaDataDirectoryNotWritable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataDirectoryNotWritable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\MetaData\Exceptions\MetaDataStrategyFailed
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataStrategyFailed`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct( string $message );
```
## Mvc\Model\MetaData\Exceptions\NoAnnotationsForClass
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\NoAnnotationsForClass`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct( string $className );
```
## Mvc\Model\MetaData\Exceptions\NoPropertyAnnotationsForClass
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\NoPropertyAnnotationsForClass`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct( string $className );
```
## Mvc\Model\MetaData\Exceptions\TableNotInDatabase
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\MetaData\Exceptions\TableNotInDatabase`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct(
string $completeTable,
string $className
);
```
## Mvc\Model\MetaData\Libmemcached
Class
Phalcon\Mvc\Model\MetaData\Libmemcached
Stores model meta-data in the Memcache.
By default meta-data is stored for 48 hours (172800 seconds)
- [`Phalcon\Mvc\Model\MetaData`](#mvcmodelmetadata)
- **`Phalcon\Mvc\Model\MetaData\Libmemcached`**
`Phalcon\Cache\AdapterFactory` · `Phalcon\Mvc\Model\MetaData`
### Method Summary
Phalcon\Mvc\Model\MetaData\Libmemcached constructor
Flush Memcache data and resets internal meta-data in order to regenerate it
### Methods
```php
public function __construct(
AdapterFactory $factory,
array $options = []
);
```
Phalcon\Mvc\Model\MetaData\Libmemcached constructor
```php
public function reset(): void;
```
Flush Memcache data and resets internal meta-data in order to regenerate it
## Mvc\Model\MetaData\Memory
Class
Phalcon\Mvc\Model\MetaData\Memory
Stores model meta-data in memory. Data will be erased when the request finishes
- [`Phalcon\Mvc\Model\MetaData`](#mvcmodelmetadata)
- **`Phalcon\Mvc\Model\MetaData\Memory`**
`Phalcon\Mvc\Model\MetaData`
### Method Summary
Reads the meta-data from temporal memory
Writes the meta-data to temporal memory
### Methods
```php
public function read( mixed $key ): array|null;
```
Reads the meta-data from temporal memory
```php
public function write(
mixed $key,
array $data
): void;
```
Writes the meta-data to temporal memory
## Mvc\Model\MetaData\Redis
Class
Phalcon\Mvc\Model\MetaData\Redis
Stores model meta-data in the Redis.
By default meta-data is stored for 48 hours (172800 seconds)
```php
use Phalcon\Mvc\Model\MetaData\Redis;
$metaData = new Redis(
[
"host" => "127.0.0.1",
"port" => 6379,
"persistent" => 0,
"lifetime" => 172800,
"index" => 2,
]
);
```
- [`Phalcon\Mvc\Model\MetaData`](#mvcmodelmetadata)
- **`Phalcon\Mvc\Model\MetaData\Redis`**
`Phalcon\Cache\AdapterFactory` · `Phalcon\Mvc\Model\MetaData`
### Method Summary
Phalcon\Mvc\Model\MetaData\Redis constructor
Flush Redis data and resets internal meta-data in order to regenerate it
### Methods
```php
public function __construct(
AdapterFactory $factory,
array $options = []
);
```
Phalcon\Mvc\Model\MetaData\Redis constructor
```php
public function reset(): void;
```
Flush Redis data and resets internal meta-data in order to regenerate it
## Mvc\Model\MetaData\Strategy\Annotations
Class
- **`Phalcon\Mvc\Model\MetaData\Strategy\Annotations`** - implements [`Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface`](#mvcmodelmetadatastrategystrategyinterface)
`Phalcon\Db\Column` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\MetaData` · `Phalcon\Mvc\Model\MetaData\Exceptions\InvalidContainer` · `Phalcon\Mvc\Model\MetaData\Exceptions\NoAnnotationsForClass` · `Phalcon\Mvc\Model\MetaData\Exceptions\NoPropertyAnnotationsForClass`
### Method Summary
Read the model's column map, this can't be inferred
The meta-data is obtained by reading the column descriptions from the database information schema
### Methods
```php
final public function getColumnMaps(
ModelInterface $model,
DiInterface $container
): array;
```
Read the model's column map, this can't be inferred
```php
final public function getMetaData(
ModelInterface $model,
DiInterface $container
): array;
```
The meta-data is obtained by reading the column descriptions from the database information schema
## Mvc\Model\MetaData\Strategy\Introspection
Class
Queries the table meta-data in order to introspect the model's metadata
- **`Phalcon\Mvc\Model\MetaData\Strategy\Introspection`** - implements [`Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface`](#mvcmodelmetadatastrategystrategyinterface)
`Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\MetaData` · `Phalcon\Mvc\Model\MetaData\Exceptions\CannotObtainTableColumns` · `Phalcon\Mvc\Model\MetaData\Exceptions\ColumnMapNotArray` · `Phalcon\Mvc\Model\MetaData\Exceptions\TableNotInDatabase`
### Method Summary
Read the model's column map, this can't be inferred
The meta-data is obtained by reading the column descriptions from the database information schema
### Methods
```php
final public function getColumnMaps(
ModelInterface $model,
DiInterface $container
): array;
```
Read the model's column map, this can't be inferred
```php
final public function getMetaData(
ModelInterface $model,
DiInterface $container
): array;
```
The meta-data is obtained by reading the column descriptions from the database information schema
## Mvc\Model\MetaData\Strategy\StrategyInterface
Interface
- **`Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface`**
`Phalcon\Di\DiInterface` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Read the model's column map, this can't be inferred
The meta-data is obtained by reading the column descriptions from the database information schema
### Methods
```php
public function getColumnMaps(
ModelInterface $model,
DiInterface $container
): array;
```
Read the model's column map, this can't be inferred
@todo Not implemented
```php
public function getMetaData(
ModelInterface $model,
DiInterface $container
): array;
```
The meta-data is obtained by reading the column descriptions from the database information schema
## Mvc\Model\MetaData\Stream
Class
Phalcon\Mvc\Model\MetaData\Stream
Stores model meta-data in PHP files.
```php
$metaData = new \Phalcon\Mvc\Model\MetaData\Files(
[
"metaDataDir" => "app/cache/metadata/",
]
);
```
- [`Phalcon\Mvc\Model\MetaData`](#mvcmodelmetadata)
- **`Phalcon\Mvc\Model\MetaData\Stream`**
`Phalcon\Mvc\Model\MetaData` · `Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataDirectoryNotWritable` · `Phalcon\Support\Settings` · `Phalcon\Traits\Php\FileTrait`
### Method Summary
Phalcon\Mvc\Model\MetaData\Files constructor
Reads meta-data from files
Writes the meta-data to files
### Properties
### Methods
```php
public function __construct( array $options = [] );
```
Phalcon\Mvc\Model\MetaData\Files constructor
```php
public function read( mixed $key ): array|null;
```
Reads meta-data from files
```php
public function write(
mixed $key,
array $data
): void;
```
Writes the meta-data to files
## Mvc\Model\Query
Class
Phalcon\Mvc\Model\Query
This class takes a PHQL intermediate representation and executes it.
```php
$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 = 'SELECT * FROM Invoices';
$myTransaction = new Transaction($di);
$myTransaction->begin();
$newInvoice = new Invoices();
$newInvoice->setTransaction($myTransaction);
$newInvoice->inv_status_flag = 1;
$newInvoice->inv_title = "Test Invoice";
$newInvoice->inv_total = 100;
$newInvoice->save();
$queryWithTransaction = new Query($phql, $di);
$queryWithTransaction->setTransaction($myTransaction);
$resultWithEntries = $queryWithTransaction->execute();
$queryWithOutTransaction = new Query($phql, $di);
$resultWithOutEntries = $queryWithTransaction->execute();
```
- **`Phalcon\Mvc\Model\Query`** - implements [`Phalcon\Mvc\Model\QueryInterface`](#mvcmodelqueryinterface), [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface)
`Phalcon\Cache\CacheInterface` · `Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Db\Column` · `Phalcon\Db\DialectInterface` · `Phalcon\Db\RawValue` · `Phalcon\Db\ResultInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Query\Exceptions\AmbiguousColumn` · `Phalcon\Mvc\Model\Query\Exceptions\AmbiguousJoinRelation` · `Phalcon\Mvc\Model\Query\Exceptions\BindParameterNotInPlaceholders` · `Phalcon\Mvc\Model\Query\Exceptions\BindTypeRequiresArray` · `Phalcon\Mvc\Model\Query\Exceptions\BindValueRequired` · `Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInDomain` · `Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInSelectedModels` · `Phalcon\Mvc\Model\Query\Exceptions\CorruptedAst` · `Phalcon\Mvc\Model\Query\Exceptions\CorruptedDeleteAst` · `Phalcon\Mvc\Model\Query\Exceptions\CorruptedInsertAst` · `Phalcon\Mvc\Model\Query\Exceptions\CorruptedSelectAst` · `Phalcon\Mvc\Model\Query\Exceptions\CorruptedUpdateAst` · `Phalcon\Mvc\Model\Query\Exceptions\DeleteMultipleNotSupported` · `Phalcon\Mvc\Model\Query\Exceptions\DuplicateAlias` · `Phalcon\Mvc\Model\Query\Exceptions\EmptyArrayPlaceholderValue` · `Phalcon\Mvc\Model\Query\Exceptions\InsertColumnCountMismatch` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidCachedResultset` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidCachingOptions` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidColumnDefinition` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedManager` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedMetadata` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidQueryCacheService` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetClass` · `Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetRowClass` · `Phalcon\Mvc\Model\Query\Exceptions\JoinAliasAlreadyUsed` · `Phalcon\Mvc\Model\Query\Exceptions\JoinFieldCountMismatch` · `Phalcon\Mvc\Model\Query\Exceptions\MissingCacheKey` · `Phalcon\Mvc\Model\Query\Exceptions\MissingMetaData` · `Phalcon\Mvc\Model\Query\Exceptions\MissingModelAttribute` · `Phalcon\Mvc\Model\Query\Exceptions\MissingModelsManager` · `Phalcon\Mvc\Model\Query\Exceptions\MixedDatabaseSystems` · `Phalcon\Mvc\Model\Query\Exceptions\ModelSourceNotFound` · `Phalcon\Mvc\Model\Query\Exceptions\ModelsListNotLoaded` · `Phalcon\Mvc\Model\Query\Exceptions\MultipleSqlStatementsNotSupported` · `Phalcon\Mvc\Model\Query\Exceptions\NoModelForAlias` · `Phalcon\Mvc\Model\Query\Exceptions\PhqlColumnNotInMap` · `Phalcon\Mvc\Model\Query\Exceptions\ReadConnectionMissing` · `Phalcon\Mvc\Model\Query\Exceptions\RelationshipNotFound` · `Phalcon\Mvc\Model\Query\Exceptions\ResultsetClassNotFound` · `Phalcon\Mvc\Model\Query\Exceptions\ResultsetNonCacheable` · `Phalcon\Mvc\Model\Query\Exceptions\ResultsetRowClassNotFound` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownBindType` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownColumnType` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownJoinType` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownModelOrAlias` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpression` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpressionType` · `Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlStatement` · `Phalcon\Mvc\Model\Query\Exceptions\UnsafeIdentifier` · `Phalcon\Mvc\Model\Query\Exceptions\UpdateMultipleNotSupported` · `Phalcon\Mvc\Model\Query\Exceptions\WriteConnectionMissing` · `Phalcon\Mvc\Model\Query\Lang` · `Phalcon\Mvc\Model\Query\Status` · `Phalcon\Mvc\Model\Query\StatusInterface` · `Phalcon\Mvc\Model\ResultsetInterface` · `Phalcon\Mvc\Model\Resultset\Complex` · `Phalcon\Mvc\Model\Resultset\Simple` · `Phalcon\Support\Settings`
### Method Summary
Phalcon\Mvc\Model\Query constructor
Sets the cache parameters of the query
Destroys the internal PHQL cache
Executes a parsed PHQL statement
Returns default bind params
Returns default bind types
Returns the current cache backend instance
Returns the current cache options
Returns the dependency injection container
Returns the intermediate representation of the PHQL statement
Returns the class that will be used to hydrate rows that are not mapped
Executes the query returning the first result
Returns an associative array with the SQL to be generated by the internal PHQL,
Gets the type of PHQL statement executed
Check if the query is programmed to get only the first row in the
Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang
Set default bind parameters
Set default bind parameters
Sets the dependency injection container
Allows to set the IR to be executed
Sets the class used to hydrate rows that are not mapped to a model
Set SHARED LOCK clause
allows to wrap a transaction around all queries
Sets the type of PHQL statement to be executed
Tells to the query if only the first row in the resultset must be
Executes the DELETE intermediate representation producing a
Executes the INSERT intermediate representation producing a
Executes the SELECT intermediate representation producing a
Executes the UPDATE intermediate representation producing a
Resolves an expression in a single call argument
Resolves an expression in a single call argument
Resolves an expression from its intermediate code into an array
Resolves an expression in a single call argument
Returns a processed group clause for a SELECT statement
Resolves a JOIN clause checking if the associated models exist
Resolves a JOIN type
Processes the JOINs in the query returning an internal representation for
Returns a processed limit clause for a SELECT statement
Resolves joins involving many-to-many relations
Returns a processed order clause for a SELECT statement
Replaces the model's name to its source name in a qualified-name
Gets the read connection from the model if there is no transaction set
Query the records on which the UPDATE/DELETE operation will be done
Resolves a column from its intermediate representation into an array
Resolves joins involving has-one/belongs-to/has-many relations
Resolves a table in a SELECT statement checking if the model exists
Gets the write connection from the model if there is no transaction
Analyzes a DELETE intermediate code and produces an array to be executed
Analyzes an INSERT intermediate code and produces an array to be executed
Analyzes a SELECT intermediate code and produces an array to be executed later
Analyzes an UPDATE intermediate code and produces an array to be executed
Refreshes the schema/source of every model referenced in a cached
### Constants
### Properties
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
### Methods
__construct()
```php
public function __construct(
string|null $phql = null,
DiInterface|null $container = null,
array $options = []
);
```
Phalcon\Mvc\Model\Query constructor
cache()
```php
public function cache( array $cacheOptions ): QueryInterface;
```
Sets the cache parameters of the query
clean()
```php
public static function clean(): void;
```
Destroys the internal PHQL cache
execute()
```php
public function execute(
array $bindParams = [],
array $bindTypes = []
);
```
Executes a parsed PHQL statement
getBindParams()
```php
public function getBindParams(): array;
```
Returns default bind params
getBindTypes()
```php
public function getBindTypes(): array;
```
Returns default bind types
getCache()
```php
public function getCache(): AdapterInterface;
```
Returns the current cache backend instance
getCacheOptions()
```php
public function getCacheOptions(): array;
```
Returns the current cache options
getDI()
```php
public function getDI(): DiInterface;
```
Returns the dependency injection container
```php
public function getIntermediate(): array;
```
Returns the intermediate representation of the PHQL statement
getResultsetRowClass()
```php
public function getResultsetRowClass(): string;
```
Returns the class that will be used to hydrate rows that are not mapped
to a model (custom columns/joins). An empty string means the default
Phalcon\Mvc\Model\Row is used.
getSingleResult()
```php
public function getSingleResult(
array $bindParams = [],
array $bindTypes = []
): ModelInterface;
```
Executes the query returning the first result
getSql()
```php
public function getSql(): array;
```
Returns an associative array with the SQL to be generated by the internal PHQL,
and arrays with bound parameters and their types (only works in SELECT statements).
```php
[
'sql' => 'SELECT * FROM co_invoices WHERE inv_cst_id = :cst_id',
'bind' => ['cst_id' => 123],
'bindTypes => ['cst_id' => 1] // 1 corresponds to int
]
```
getTransaction()
```php
public function getTransaction(): TransactionInterface|null;
```
getType()
```php
public function getType(): int;
```
Gets the type of PHQL statement executed
getUniqueRow()
```php
public function getUniqueRow(): bool;
```
Check if the query is programmed to get only the first row in the
resultset
parse()
```php
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
setBindParams()
```php
public function setBindParams(
array $bindParams,
bool $merge = false
): QueryInterface;
```
Set default bind parameters
setBindTypes()
```php
public function setBindTypes(
array $bindTypes,
bool $merge = false
): QueryInterface;
```
Set default bind parameters
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the dependency injection container
```php
public function setIntermediate( array $intermediate ): QueryInterface;
```
Allows to set the IR to be executed
setResultsetRowClass()
```php
public function setResultsetRowClass( string $resultsetRowClass ): QueryInterface;
```
Sets the class used to hydrate rows that are not mapped to a model
(custom columns/joins). The class must be a subclass of
Phalcon\Mvc\Model\Row.
setSharedLock()
```php
public function setSharedLock( bool $sharedLock = false ): QueryInterface;
```
Set SHARED LOCK clause
setTransaction()
```php
public function setTransaction( TransactionInterface $transaction ): QueryInterface;
```
allows to wrap a transaction around all queries
setType()
```php
public function setType( int $type ): QueryInterface;
```
Sets the type of PHQL statement to be executed
setUniqueRow()
```php
public function setUniqueRow( bool $uniqueRow ): QueryInterface;
```
Tells to the query if only the first row in the resultset must be
returned
executeDelete()
```php
final protected function executeDelete(
array $intermediate,
array $bindParams,
array $bindTypes
): StatusInterface;
```
Executes the DELETE intermediate representation producing a
Phalcon\Mvc\Model\Query\Status
executeInsert()
```php
final protected function executeInsert(
array $intermediate,
array $bindParams,
array $bindTypes
): StatusInterface;
```
Executes the INSERT intermediate representation producing a
Phalcon\Mvc\Model\Query\Status
executeSelect()
```php
final protected function executeSelect(
array $intermediate,
array $bindParams,
array $bindTypes,
bool $simulate = false
): ResultsetInterface|array;
```
Executes the SELECT intermediate representation producing a
Phalcon\Mvc\Model\Resultset
executeUpdate()
```php
final protected function executeUpdate(
array $intermediate,
array $bindParams,
array $bindTypes
): StatusInterface;
```
Executes the UPDATE intermediate representation producing a
Phalcon\Mvc\Model\Query\Status
getCallArgument()
```php
final protected function getCallArgument( array $argument ): array;
```
Resolves an expression in a single call argument
getCaseExpression()
```php
final protected function getCaseExpression( array $expr ): array;
```
Resolves an expression in a single call argument
getExpression()
```php
final protected function getExpression(
array $expr,
bool $quoting = true
): array;
```
Resolves an expression from its intermediate code into an array
getFunctionCall()
```php
final protected function getFunctionCall( array $expr ): array;
```
Resolves an expression in a single call argument
getGroupClause()
```php
final protected function getGroupClause( array $group ): array;
```
Returns a processed group clause for a SELECT statement
getJoin()
```php
final protected function getJoin(
ManagerInterface $manager,
array $join
): array;
```
Resolves a JOIN clause checking if the associated models exist
getJoinType()
```php
final protected function getJoinType( array $join ): string;
```
Resolves a JOIN type
getJoins()
```php
final protected function getJoins( array $select ): array;
```
Processes the JOINs in the query returning an internal representation for
the database dialect
getLimitClause()
```php
final protected function getLimitClause( array $limitClause ): array;
```
Returns a processed limit clause for a SELECT statement
getMultiJoin()
```php
final protected function getMultiJoin(
string $joinType,
mixed $joinSource,
string $modelAlias,
string $joinAlias,
RelationInterface $relation
): array;
```
Resolves joins involving many-to-many relations
getOrderClause()
```php
final protected function getOrderClause( mixed $order ): array;
```
Returns a processed order clause for a SELECT statement
getQualified()
```php
final protected function getQualified( array $expr ): array;
```
Replaces the model's name to its source name in a qualified-name
expression
getReadConnection()
```php
protected function getReadConnection(
ModelInterface $model,
array|null $intermediate = null,
array $bindParams = [],
array $bindTypes = []
): AdapterInterface;
```
Gets the read connection from the model if there is no transaction set
inside the query object
```php
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
getSelectColumn()
```php
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
getSingleJoin()
```php
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
getTable()
```php
final protected function getTable(
ManagerInterface $manager,
array $qualifiedName
);
```
Resolves a table in a SELECT statement checking if the model exists
getWriteConnection()
```php
protected function getWriteConnection(
ModelInterface $model,
array|null $intermediate = null,
array $bindParams = [],
array $bindTypes = []
): AdapterInterface;
```
Gets the write connection from the model if there is no transaction
inside the query object
prepareDelete()
```php
final protected function prepareDelete(): array;
```
Analyzes a DELETE intermediate code and produces an array to be executed
later
prepareInsert()
```php
final protected function prepareInsert(): array;
```
Analyzes an INSERT intermediate code and produces an array to be executed
later
prepareSelect()
```php
final protected function prepareSelect(
mixed $ast = null,
bool $merge = false
): array;
```
Analyzes a SELECT intermediate code and produces an array to be executed later
prepareUpdate()
```php
final protected function prepareUpdate(): array;
```
Analyzes an UPDATE intermediate code and produces an array to be executed
later
```php
final protected function refreshSchemasInIntermediate( array $irPhql ): array;
```
Refreshes the schema/source of every model referenced in a cached
intermediate representation. The PHQL cache is keyed by the PHQL
string only, so a model that switches its schema or source at
runtime (for instance via setSchema()/setSource() in initialize())
would otherwise see the value frozen at first parse. See #17020.
## Mvc\Model\QueryInterface
Interface
Phalcon\Mvc\Model\QueryInterface
Interface for Phalcon\Mvc\Model\Query
- **`Phalcon\Mvc\Model\QueryInterface`**
`Phalcon\Mvc\ModelInterface`
### Method Summary
Sets the cache parameters of the query
Executes a parsed PHQL statement
Returns default bind params
Returns default bind types
Returns the current cache options
Executes the query returning the first result
Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
Check if the query is programmed to get only the first row in the resultset
Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another
Set default bind parameters
Set default bind parameters
Set SHARED LOCK clause
Tells to the query if only the first row in the resultset must be returned
### Methods
cache()
```php
public function cache( array $cacheOptions ): QueryInterface;
```
Sets the cache parameters of the query
execute()
```php
public function execute(
array $bindParams = [],
array $bindTypes = []
);
```
Executes a parsed PHQL statement
getBindParams()
```php
public function getBindParams(): array;
```
Returns default bind params
getBindTypes()
```php
public function getBindTypes(): array;
```
Returns default bind types
getCacheOptions()
```php
public function getCacheOptions(): array;
```
Returns the current cache options
getSingleResult()
```php
public function getSingleResult(
array $bindParams = [],
array $bindTypes = []
): ModelInterface;
```
Executes the query returning the first result
getSql()
```php
public function getSql(): array;
```
Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
getUniqueRow()
```php
public function getUniqueRow(): bool;
```
Check if the query is programmed to get only the first row in the resultset
parse()
```php
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
setBindParams()
```php
public function setBindParams(
array $bindParams,
bool $merge = false
): QueryInterface;
```
Set default bind parameters
setBindTypes()
```php
public function setBindTypes(
array $bindTypes,
bool $merge = false
): QueryInterface;
```
Set default bind parameters
setSharedLock()
```php
public function setSharedLock( bool $sharedLock = false ): QueryInterface;
```
Set SHARED LOCK clause
setUniqueRow()
```php
public function setUniqueRow( bool $uniqueRow ): QueryInterface;
```
Tells to the query if only the first row in the resultset must be returned
## Mvc\Model\Query\Builder
Class
Helps to create PHQL queries using an OO interface
```php
$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);
```
- **`Phalcon\Mvc\Model\Query\Builder`** - implements [`Phalcon\Mvc\Model\Query\BuilderInterface`](#mvcmodelquerybuilderinterface), [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface)
`Phalcon\Db\Column` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\Model\Exception` · `Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable` · `Phalcon\Mvc\Model\Query` · `Phalcon\Mvc\Model\QueryInterface` · `Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderColumnNotInMap` · `Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderConditionInvalid` · `Phalcon\Mvc\Model\Query\Exceptions\Builder\ModelRequired` · `Phalcon\Mvc\Model\Query\Exceptions\Builder\NoPrimaryKey` · `Phalcon\Mvc\Model\Query\Exceptions\Builder\OperatorNotAvailable` · `Phalcon\Support\Settings`
### Method Summary
Phalcon\Mvc\Model\Query\Builder constructor
Add a model to take part of the query
Appends a condition to the current HAVING conditions clause using a AND operator
Appends a condition to the current WHERE conditions using a AND operator
Automatically escapes identifiers but only if they need to be escaped.
Appends a BETWEEN condition to the current HAVING conditions clause
Appends a BETWEEN condition to the current WHERE conditions
Sets the columns to be queried. The columns can be either a `string` or
Sets SELECT DISTINCT / SELECT ALL flag
Sets a FOR UPDATE clause
Sets the models who makes part of the query
Returns default bind params
Returns default bind types
Return the columns to be queried
Returns the DependencyInjector container
Returns SELECT DISTINCT / SELECT ALL flag
Return the models who makes part of the query
Returns the GROUP BY clause
Return the current having clause
Return join parts of the query
Returns the current LIMIT clause
Returns the models involved in the query
Returns the current OFFSET clause
Returns the set ORDER BY clause
Returns a PHQL statement built based on the builder parameters
Returns the query built
Returns the class that will be used to hydrate rows that are not mapped
Return the conditions for the query
Sets a GROUP BY clause
Sets the HAVING condition clause
Appends an IN condition to the current HAVING conditions clause
Appends an IN condition to the current WHERE conditions
Adds an INNER join to the query
Adds an :type: join (by default type - INNER) to the query
Adds a LEFT join to the query
Sets a LIMIT clause, optionally an offset clause
Appends a NOT BETWEEN condition to the current HAVING conditions clause
Appends a NOT BETWEEN condition to the current WHERE conditions
Appends a NOT IN condition to the current HAVING conditions clause
Appends a NOT IN condition to the current WHERE conditions
Sets an OFFSET clause
Appends a condition to the current HAVING conditions clause using an OR operator
Appends a condition to the current conditions using an OR operator
Sets an ORDER BY condition clause
Adds a RIGHT join to the query
Set default bind parameters
Set default bind types
Sets the DependencyInjector container
Sets the class used to hydrate rows that are not mapped to a model
Sets the query WHERE conditions
Appends a BETWEEN condition
Appends an IN condition
Appends a NOT BETWEEN condition
Appends a NOT IN condition
### Properties
### Methods
__construct()
```php
public function __construct(
mixed $params = null,
DiInterface|null $container = null
);
```
Phalcon\Mvc\Model\Query\Builder constructor
addFrom()
```php
public function addFrom(
string $model,
string|null $alias = null
): BuilderInterface;
```
Add a model to take part of the query
```php
// Load data from models Invoices
$builder->addFrom(
Invoices::class
);
// Load data from model 'Invoices' using 'r' as alias in PHQL
$builder->addFrom(
Invoices::class,
"r"
);
```
andHaving()
```php
public function andHaving(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current HAVING conditions clause using a AND operator
```php
$builder->andHaving("SUM(Invoices.inv_total) > 0");
$builder->andHaving(
"SUM(Invoices.inv_total) > :sum:",
[
"sum" => 100,
]
);
```
andWhere()
```php
public function andWhere(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current WHERE conditions using a AND operator
```php
$builder->andWhere("name = 'Peter'");
$builder->andWhere(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
```
autoescape()
```php
final public function autoescape( string $identifier ): string;
```
Automatically escapes identifiers but only if they need to be escaped.
betweenHaving()
```php
public function betweenHaving(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a BETWEEN condition to the current HAVING conditions clause
```php
$builder->betweenHaving("SUM(Invoices.inv_total)", 100.25, 200.50);
```
betweenWhere()
```php
public function betweenWhere(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a BETWEEN condition to the current WHERE conditions
```php
$builder->betweenWhere("price", 100.25, 200.50);
```
columns()
```php
public function columns( mixed $columns ): BuilderInterface;
```
Sets the columns to be queried. The columns can be either a `string` or
an `array` of strings. If the argument is a (single, non-embedded) string,
its content can specify one or more columns, separated by commas, the same
way that one uses the SQL select statement. You can use aliases, aggregate
functions, etc. If you need to reference other models you will need to
reference them with their namespaces.
When using an array as a parameter, you will need to specify one field
per array element. If a non-numeric key is defined in the array, it will
be used as the alias in the query
```php
columns("id, category");
// Array, one column per element
$builder->columns(
[
"inv_id",
"inv_total",
]
);
// Array with named key. The name of the key acts as an
// alias (`AS` clause)
$builder->columns(
[
"inv_cst_id",
"total_invoices" => "COUNT(*)",
]
);
// Different models
$builder->columns(
[
"\Phalcon\Models\Invoices.*",
"\Phalcon\Models\Customers.cst_name_first",
"\Phalcon\Models\Customers.cst_name_last",
]
);
```
distinct()
```php
public function distinct( mixed $distinct ): BuilderInterface;
```
Sets SELECT DISTINCT / SELECT ALL flag
```php
$builder->distinct("status");
$builder->distinct(null);
```
forUpdate()
```php
public function forUpdate( bool $forUpdate ): BuilderInterface;
```
Sets a FOR UPDATE clause
```php
$builder->forUpdate(true);
```
from()
```php
public function from( mixed $models ): BuilderInterface;
```
Sets the models who makes part of the query
```php
$builder->from(
Invoices::class
);
$builder->from(
[
Invoices::class,
OrdersProducts::class,
]
);
$builder->from(
[
"r" => Invoices::class,
"rp" => OrdersProducts::class,
]
);
```
getBindParams()
```php
public function getBindParams(): array;
```
Returns default bind params
getBindTypes()
```php
public function getBindTypes(): array;
```
Returns default bind types
getColumns()
```php
public function getColumns();
```
Return the columns to be queried
getDI()
```php
public function getDI(): DiInterface;
```
Returns the DependencyInjector container
getDistinct()
```php
public function getDistinct(): bool;
```
Returns SELECT DISTINCT / SELECT ALL flag
getFrom()
```php
public function getFrom();
```
Return the models who makes part of the query
getGroupBy()
```php
public function getGroupBy(): array;
```
Returns the GROUP BY clause
getHaving()
```php
public function getHaving(): string|null;
```
Return the current having clause
getJoins()
```php
public function getJoins(): array;
```
Return join parts of the query
getLimit()
```php
public function getLimit();
```
Returns the current LIMIT clause
getModels()
```php
public function getModels(): string|array|null;
```
Returns the models involved in the query
getOffset()
```php
public function getOffset(): int;
```
Returns the current OFFSET clause
getOrderBy()
```php
public function getOrderBy();
```
Returns the set ORDER BY clause
getPhql()
```php
final public function getPhql(): string;
```
Returns a PHQL statement built based on the builder parameters
getQuery()
```php
public function getQuery(): QueryInterface;
```
Returns the query built
getResultsetRowClass()
```php
public function getResultsetRowClass(): string;
```
Returns the class that will be used to hydrate rows that are not mapped
to a model (custom columns/joins). An empty string means the default
Phalcon\Mvc\Model\Row is used.
getWhere()
```php
public function getWhere();
```
Return the conditions for the query
groupBy()
```php
public function groupBy( mixed $group ): BuilderInterface;
```
Sets a GROUP BY clause
```php
$builder->groupBy(
[
"Invoices.inv_title",
]
);
```
Passing null (or an empty array) clears the clause; the PHQL generator
treats both as "no GROUP BY".
having()
```php
public function having(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Sets the HAVING condition clause
```php
$builder->having("SUM(Invoices.inv_total) > 0");
$builder->having(
"SUM(Invoices.inv_total) > :sum:",
[
"sum" => 100,
]
);
```
inHaving()
```php
public function inHaving(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends an IN condition to the current HAVING conditions clause
```php
$builder->inHaving("SUM(Invoices.inv_total)", [100, 200]);
```
inWhere()
```php
public function inWhere(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends an IN condition to the current WHERE conditions
```php
$builder->inWhere(
"id",
[1, 2, 3]
);
```
innerJoin()
```php
public function innerJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds an INNER join to the query
```php
// Inner Join model 'Invoices' with automatic conditions and alias
$builder->innerJoin(
Invoices::class
);
// Inner Join model 'Invoices' specifying conditions
$builder->innerJoin(
Invoices::class,
"Invoices.inv_id = OrdersProducts.oxp_ord_id"
);
// Inner Join model 'Invoices' specifying conditions and alias
$builder->innerJoin(
Invoices::class,
"r.inv_id = OrdersProducts.oxp_ord_id",
"r"
);
```
join()
```php
public function join(
string $model,
string|null $conditions = null,
string|null $alias = null,
string|null $type = null
): BuilderInterface;
```
Adds an :type: join (by default type - INNER) to the query
```php
// Inner Join model 'Invoices' with automatic conditions and alias
$builder->join(
Invoices::class
);
// Inner Join model 'Invoices' specifying conditions
$builder->join(
Invoices::class,
"Invoices.inv_id = OrdersProducts.oxp_ord_id"
);
// Inner Join model 'Invoices' specifying conditions and alias
$builder->join(
Invoices::class,
"r.inv_id = OrdersProducts.oxp_ord_id",
"r"
);
// Left Join model 'Invoices' specifying conditions, alias and type of join
$builder->join(
Invoices::class,
"r.inv_id = OrdersProducts.oxp_ord_id",
"r",
"LEFT"
);
```
leftJoin()
```php
public function leftJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds a LEFT join to the query
```php
$builder->leftJoin(
Invoices::class,
"r.inv_id = OrdersProducts.oxp_ord_id",
"r"
);
```
limit()
```php
public function limit(
int $limit,
mixed $offset = null
): BuilderInterface;
```
Sets a LIMIT clause, optionally an offset clause
```php
$builder->limit(100);
$builder->limit(100, 20);
$builder->limit("100", "20");
```
notBetweenHaving()
```php
public function notBetweenHaving(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT BETWEEN condition to the current HAVING conditions clause
```php
$builder->notBetweenHaving("SUM(Invoices.inv_total)", 100.25, 200.50);
```
notBetweenWhere()
```php
public function notBetweenWhere(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT BETWEEN condition to the current WHERE conditions
```php
$builder->notBetweenWhere("price", 100.25, 200.50);
```
notInHaving()
```php
public function notInHaving(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT IN condition to the current HAVING conditions clause
```php
$builder->notInHaving("SUM(Invoices.inv_total)", [100, 200]);
```
notInWhere()
```php
public function notInWhere(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT IN condition to the current WHERE conditions
```php
$builder->notInWhere("id", [1, 2, 3]);
```
offset()
```php
public function offset( int $offset ): BuilderInterface;
```
Sets an OFFSET clause
```php
$builder->offset(30);
```
orHaving()
```php
public function orHaving(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current HAVING conditions clause using an OR operator
```php
$builder->orHaving("SUM(Invoices.inv_total) > 0");
$builder->orHaving(
"SUM(Invoices.inv_total) > :sum:",
[
"sum" => 100,
]
);
```
orWhere()
```php
public function orWhere(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current conditions using an OR operator
```php
$builder->orWhere("name = 'Peter'");
$builder->orWhere(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
```
orderBy()
```php
public function orderBy( mixed $orderBy ): BuilderInterface;
```
Sets an ORDER BY condition clause
```php
$builder->orderBy("Invoices.inv_title");
$builder->orderBy(["1", "Invoices.inv_title"]);
$builder->orderBy(["Invoices.inv_title DESC"]);
```
rightJoin()
```php
public function rightJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds a RIGHT join to the query
```php
$builder->rightJoin(
Invoices::class,
"r.inv_id = OrdersProducts.oxp_ord_id",
"r"
);
```
setBindParams()
```php
public function setBindParams(
array $bindParams,
bool $merge = false
): BuilderInterface;
```
Set default bind parameters
setBindTypes()
```php
public function setBindTypes(
array $bindTypes,
bool $merge = false
): BuilderInterface;
```
Set default bind types
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the DependencyInjector container
setResultsetRowClass()
```php
public function setResultsetRowClass( string $resultsetRowClass ): BuilderInterface;
```
Sets the class used to hydrate rows that are not mapped to a model
(custom columns/joins). The class must be a subclass of
Phalcon\Mvc\Model\Row. Validation is performed by the underlying
Phalcon\Mvc\Model\Query when the query is built.
where()
```php
public function where(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Sets the query WHERE conditions
```php
$builder->where(100);
$builder->where("name = 'Peter'");
$builder->where(
"name = :name: AND id > :id:",
[
"name" => "Peter",
"id" => 100,
]
);
```
conditionBetween()
```php
protected function conditionBetween(
string $clause,
string $operator,
string $expr,
mixed $minimum,
mixed $maximum
): BuilderInterface;
```
Appends a BETWEEN condition
conditionIn()
```php
protected function conditionIn(
string $clause,
string $operator,
string $expr,
array $values
): BuilderInterface;
```
Appends an IN condition
conditionNotBetween()
```php
protected function conditionNotBetween(
string $clause,
string $operator,
string $expr,
mixed $minimum,
mixed $maximum
): BuilderInterface;
```
Appends a NOT BETWEEN condition
conditionNotIn()
```php
protected function conditionNotIn(
string $clause,
string $operator,
string $expr,
array $values
): BuilderInterface;
```
Appends a NOT IN condition
## Mvc\Model\Query\BuilderInterface
Interface
Interface for Phalcon\Mvc\Model\Query\Builder
- **`Phalcon\Mvc\Model\Query\BuilderInterface`**
`Phalcon\Mvc\Model\QueryInterface`
### Method Summary
Add a model to take part of the query
Appends a condition to the current conditions using a AND operator
Appends a BETWEEN condition to the current conditions
Sets the columns to be queried. The columns can be either a `string` or
Sets SELECT DISTINCT / SELECT ALL flag
Sets a FOR UPDATE clause
Sets the models who makes part of the query
Returns default bind params
Returns default bind types
Return the columns to be queried
Returns SELECT DISTINCT / SELECT ALL flag
Return the models who makes part of the query
Returns the GROUP BY clause
Returns the HAVING condition clause
Return join parts of the query
Returns the current LIMIT clause
Returns the models involved in the query
Returns the current OFFSET clause
Return the set ORDER BY clause
Returns a PHQL statement built based on the builder parameters
Returns the query built
Return the conditions for the query
Sets a GROUP BY clause
Sets a HAVING condition clause
Appends an IN condition to the current conditions
Adds an INNER join to the query
Adds an :type: join (by default type - INNER) to the query
Adds a LEFT join to the query
Sets a LIMIT clause
Appends a NOT BETWEEN condition to the current conditions
Appends a NOT IN condition to the current conditions
Sets an OFFSET clause
Appends a condition to the current conditions using an OR operator
Sets an ORDER BY condition clause
Adds a RIGHT join to the query
Set default bind parameters
Set default bind types
Sets conditions for the query
### Constants
### Methods
addFrom()
```php
public function addFrom(
string $model,
string|null $alias = null
): BuilderInterface;
```
Add a model to take part of the query
andWhere()
```php
public function andWhere(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current conditions using a AND operator
betweenWhere()
```php
public function betweenWhere(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a BETWEEN condition to the current conditions
columns()
```php
public function columns( mixed $columns ): BuilderInterface;
```
Sets the columns to be queried. The columns can be either a `string` or
an `array` of strings. If the argument is a (single, non-embedded) string,
its content can specify one or more columns, separated by commas, the same
way that one uses the SQL select statement. You can use aliases, aggregate
functions, etc. If you need to reference other models you will need to
reference them with their namespaces.
When using an array as a parameter, you will need to specify one field
per array element. If a non-numeric key is defined in the array, it will
be used as the alias in the query
```php
columns("id, name");
// Array, one column per element
$builder->columns(
[
"id",
"name",
]
);
// Array, named keys. The name of the key acts as an alias (`AS` clause)
$builder->columns(
[
"name",
"number" => "COUNT(*)",
]
);
// Different models
$builder->columns(
[
"\Phalcon\Models\Invoices.*",
"\Phalcon\Models\Customers.cst_name_first",
"\Phalcon\Models\Customers.cst_name_last",
]
);
```
distinct()
```php
public function distinct( mixed $distinct ): BuilderInterface;
```
Sets SELECT DISTINCT / SELECT ALL flag
```php
$builder->distinct("status");
$builder->distinct(null);
```
forUpdate()
```php
public function forUpdate( bool $forUpdate ): BuilderInterface;
```
Sets a FOR UPDATE clause
```php
$builder->forUpdate(true);
```
from()
```php
public function from( mixed $models ): BuilderInterface;
```
Sets the models who makes part of the query
getBindParams()
```php
public function getBindParams(): array;
```
Returns default bind params
getBindTypes()
```php
public function getBindTypes(): array;
```
Returns default bind types
getColumns()
```php
public function getColumns();
```
Return the columns to be queried
getDistinct()
```php
public function getDistinct(): bool;
```
Returns SELECT DISTINCT / SELECT ALL flag
getFrom()
```php
public function getFrom();
```
Return the models who makes part of the query
getGroupBy()
```php
public function getGroupBy(): array;
```
Returns the GROUP BY clause
getHaving()
```php
public function getHaving(): string|null;
```
Returns the HAVING condition clause
getJoins()
```php
public function getJoins(): array;
```
Return join parts of the query
getLimit()
```php
public function getLimit();
```
Returns the current LIMIT clause
getModels()
```php
public function getModels(): string|array|null;
```
Returns the models involved in the query
getOffset()
```php
public function getOffset(): int;
```
Returns the current OFFSET clause
getOrderBy()
```php
public function getOrderBy();
```
Return the set ORDER BY clause
getPhql()
```php
public function getPhql(): string;
```
Returns a PHQL statement built based on the builder parameters
getQuery()
```php
public function getQuery(): QueryInterface;
```
Returns the query built
getWhere()
```php
public function getWhere();
```
Return the conditions for the query
groupBy()
```php
public function groupBy( mixed $group ): BuilderInterface;
```
Sets a GROUP BY clause
having()
```php
public function having(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Sets a HAVING condition clause
inWhere()
```php
public function inWhere(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends an IN condition to the current conditions
innerJoin()
```php
public function innerJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds an INNER join to the query
join()
```php
public function join(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds an :type: join (by default type - INNER) to the query
leftJoin()
```php
public function leftJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds a LEFT join to the query
limit()
```php
public function limit(
int $limit,
mixed $offset = null
): BuilderInterface;
```
Sets a LIMIT clause
notBetweenWhere()
```php
public function notBetweenWhere(
string $expr,
mixed $minimum,
mixed $maximum,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT BETWEEN condition to the current conditions
notInWhere()
```php
public function notInWhere(
string $expr,
array $values,
string $operator = BuilderInterface::OPERATOR_AND
): BuilderInterface;
```
Appends a NOT IN condition to the current conditions
offset()
```php
public function offset( int $offset ): BuilderInterface;
```
Sets an OFFSET clause
orWhere()
```php
public function orWhere(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Appends a condition to the current conditions using an OR operator
orderBy()
```php
public function orderBy( mixed $orderBy ): BuilderInterface;
```
Sets an ORDER BY condition clause
rightJoin()
```php
public function rightJoin(
string $model,
string|null $conditions = null,
string|null $alias = null
): BuilderInterface;
```
Adds a RIGHT join to the query
setBindParams()
```php
public function setBindParams(
array $bindParams,
bool $merge = false
): BuilderInterface;
```
Set default bind parameters
setBindTypes()
```php
public function setBindTypes(
array $bindTypes,
bool $merge = false
): BuilderInterface;
```
Set default bind types
where()
```php
public function where(
string $conditions,
array $bindParams = [],
array $bindTypes = []
): BuilderInterface;
```
Sets conditions for the query
## Mvc\Model\Query\Exceptions\AmbiguousColumn
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\AmbiguousColumn`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $phql
);
```
## Mvc\Model\Query\Exceptions\AmbiguousJoinRelation
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\AmbiguousJoinRelation`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $from,
string $join,
string $phql
);
```
## Mvc\Model\Query\Exceptions\BindParameterNotInPlaceholders
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\BindParameterNotInPlaceholders`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $wildcard );
```
## Mvc\Model\Query\Exceptions\BindTypeRequiresArray
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\BindTypeRequiresArray`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\Model\Query\Exceptions\BindValueRequired
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\BindValueRequired`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\Model\Query\Exceptions\Builder\BuilderColumnNotInMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderColumnNotInMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $column );
```
## Mvc\Model\Query\Exceptions\Builder\BuilderConditionInvalid
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\Builder\BuilderConditionInvalid`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\Builder\ModelRequired
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\Builder\ModelRequired`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\Builder\NoPrimaryKey
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\Builder\NoPrimaryKey`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\Builder\OperatorNotAvailable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\Builder\OperatorNotAvailable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $operator );
```
## Mvc\Model\Query\Exceptions\ColumnNotInDomain
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInDomain`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $model,
string $phql
);
```
## Mvc\Model\Query\Exceptions\ColumnNotInSelectedModels
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ColumnNotInSelectedModels`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $tag,
string $phql
);
```
## Mvc\Model\Query\Exceptions\CorruptedAst
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\CorruptedAst`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\CorruptedDeleteAst
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\CorruptedDeleteAst`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\CorruptedInsertAst
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\CorruptedInsertAst`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\CorruptedSelectAst
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\CorruptedSelectAst`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\CorruptedUpdateAst
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\CorruptedUpdateAst`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\DeleteMultipleNotSupported
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\DeleteMultipleNotSupported`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\DuplicateAlias
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\DuplicateAlias`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $phql
);
```
## Mvc\Model\Query\Exceptions\EmptyArrayPlaceholderValue
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\EmptyArrayPlaceholderValue`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\Model\Query\Exceptions\InsertColumnCountMismatch
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InsertColumnCountMismatch`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidCachedResultset
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidCachedResultset`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidCachingOptions
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidCachingOptions`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidColumnDefinition
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidColumnDefinition`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidInjectedManager
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedManager`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidInjectedMetadata
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidInjectedMetadata`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidQueryCacheService
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidQueryCacheService`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\InvalidResultsetClass
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetClass`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Query\Exceptions\InvalidResultsetRowClass
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\InvalidResultsetRowClass`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Query\Exceptions\JoinAliasAlreadyUsed
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\JoinAliasAlreadyUsed`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $alias,
string $phql
);
```
## Mvc\Model\Query\Exceptions\JoinFieldCountMismatch
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\JoinFieldCountMismatch`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $model,
string $join,
string $phql
);
```
## Mvc\Model\Query\Exceptions\MissingCacheKey
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MissingCacheKey`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\MissingMetaData
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MissingMetaData`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\MissingModelAttribute
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MissingModelAttribute`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $model,
string $attribute,
string $phql
);
```
## Mvc\Model\Query\Exceptions\MissingModelsManager
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MissingModelsManager`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\MixedDatabaseSystems
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MixedDatabaseSystems`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\ModelSourceNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ModelSourceNotFound`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $phql
);
```
## Mvc\Model\Query\Exceptions\ModelsListNotLoaded
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ModelsListNotLoaded`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\MultipleSqlStatementsNotSupported
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\MultipleSqlStatementsNotSupported`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\NoModelForAlias
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\NoModelForAlias`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $model,
string $phql
);
```
## Mvc\Model\Query\Exceptions\PhqlColumnNotInMap
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\PhqlColumnNotInMap`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $fieldName );
```
## Mvc\Model\Query\Exceptions\ReadConnectionMissing
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ReadConnectionMissing`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\RelationshipNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\RelationshipNotFound`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $model,
string $relationship,
string $phql
);
```
## Mvc\Model\Query\Exceptions\ResultsetClassNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ResultsetClassNotFound`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Query\Exceptions\ResultsetNonCacheable
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ResultsetNonCacheable`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\ResultsetRowClassNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\ResultsetRowClassNotFound`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Mvc\Model\Query\Exceptions\UnknownBindType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownBindType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $type );
```
## Mvc\Model\Query\Exceptions\UnknownColumnType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownColumnType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $type );
```
## Mvc\Model\Query\Exceptions\UnknownJoinType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownJoinType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $type,
string $phql
);
```
## Mvc\Model\Query\Exceptions\UnknownModelOrAlias
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownModelOrAlias`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $model,
string $tag,
string $phql
);
```
## Mvc\Model\Query\Exceptions\UnknownPhqlExpression
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpression`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\UnknownPhqlExpressionType
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlExpressionType`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $type );
```
## Mvc\Model\Query\Exceptions\UnknownPhqlStatement
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnknownPhqlStatement`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $type );
```
## Mvc\Model\Query\Exceptions\UnsafeIdentifier
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UnsafeIdentifier`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $identifier,
string $phql
);
```
## Mvc\Model\Query\Exceptions\UpdateMultipleNotSupported
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\UpdateMultipleNotSupported`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Exceptions\WriteConnectionMissing
Class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Query\Exceptions\WriteConnectionMissing`**
`Phalcon\Mvc\Model\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Model\Query\Lang
Abstract
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.
```php
use Phalcon\Mvc\Model\Query\Lang;
$intermediate = Lang::parsePHQL(
"SELECT r.* FROM Invoices r LIMIT 10"
);
```
- **`Phalcon\Mvc\Model\Query\Lang`**
### Method Summary
Parses a PHQL statement returning an intermediate representation (IR)
### Methods
parsePHQL()
```php
public static function parsePHQL( string $phql ): array;
```
Parses a PHQL statement returning an intermediate representation (IR)
## Mvc\Model\Query\Status
Class
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
```php
$phql = "UPDATE Invoices SET inv_title = :inv_title:, inv_status_flag = :inv_status_flag:, inv_total = :inv_total: WHERE inv_id = :inv_id:";
$status = $app->modelsManager->executeQuery(
$phql,
[
"inv_id" => 100,
"inv_title" => "Test Invoice",
"inv_status_flag" => 1,
"inv_total" => 1959,
]
);
// Check if the update was successful
if ($status->success()) {
echo "OK";
}
```
- **`Phalcon\Mvc\Model\Query\Status`** - implements [`Phalcon\Mvc\Model\Query\StatusInterface`](#mvcmodelquerystatusinterface)
`Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Phalcon\Mvc\Model\Query\Status
Returns the messages produced because of a failed operation
Returns the model that executed the action
Allows to check if the executed operation was successful
### Properties
### Methods
__construct()
```php
public function __construct(
bool $success,
ModelInterface|null $model = null
);
```
Phalcon\Mvc\Model\Query\Status
getMessages()
```php
public function getMessages(): MessageInterface[];
```
Returns the messages produced because of a failed operation
getModel()
```php
public function getModel(): ModelInterface|null;
```
Returns the model that executed the action
success()
```php
public function success(): bool;
```
Allows to check if the executed operation was successful
## Mvc\Model\Query\StatusInterface
Interface
Interface for Phalcon\Mvc\Model\Query\Status
- **`Phalcon\Mvc\Model\Query\StatusInterface`**
`Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Returns the messages produced by an operation failed
Returns the model which executed the action
Allows to check if the executed operation was successful
### Methods
getMessages()
```php
public function getMessages(): MessageInterface[];
```
Returns the messages produced by an operation failed
getModel()
```php
public function getModel(): ModelInterface|null;
```
Returns the model which executed the action
success()
```php
public function success(): bool;
```
Allows to check if the executed operation was successful
## Mvc\Model\Relation
Class
Phalcon\Mvc\Model\Relation
This class represents a relationship between two models
- **`Phalcon\Mvc\Model\Relation`** - implements [`Phalcon\Mvc\Model\RelationInterface`](#mvcmodelrelationinterface)
### Method Summary
Phalcon\Mvc\Model\Relation constructor
Returns the fields
Returns the foreign key configuration
Gets the intermediate fields for has-*-through relations
Gets the intermediate model for has-*-through relations
Gets the intermediate referenced fields for has-*-through relations
Returns an option by the specified name
Returns the options
Returns parameters that must be always used when the related records are obtained
Returns the referenced fields
Returns the referenced model
Returns the relation type
Check whether the relation act as a foreign key
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
Check whether the relation is a 'many-to-many' relation or not
Sets the intermediate model data for has-*-through relations
### Constants
### Properties
### Methods
__construct()
```php
public function __construct(
int $type,
string $referencedModel,
mixed $fields,
mixed $referencedFields,
array $options = []
);
```
Phalcon\Mvc\Model\Relation constructor
getFields()
```php
public function getFields();
```
Returns the fields
getForeignKey()
```php
public function getForeignKey();
```
Returns the foreign key configuration
```php
public function getIntermediateFields();
```
Gets the intermediate fields for has-*-through relations
```php
public function getIntermediateModel(): string;
```
Gets the intermediate model for has-*-through relations
```php
public function getIntermediateReferencedFields();
```
Gets the intermediate referenced fields for has-*-through relations
getOption()
```php
public function getOption( string $name );
```
Returns an option by the specified name
If the option does not exist null is returned
getOptions()
```php
public function getOptions(): array;
```
Returns the options
getParams()
```php
public function getParams();
```
Returns parameters that must be always used when the related records are obtained
getReferencedFields()
```php
public function getReferencedFields();
```
Returns the referenced fields
getReferencedModel()
```php
public function getReferencedModel(): string;
```
Returns the referenced model
getType()
```php
public function getType(): int;
```
Returns the relation type
isForeignKey()
```php
public function isForeignKey(): bool;
```
Check whether the relation act as a foreign key
isReusable()
```php
public function isReusable(): bool;
```
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
isThrough()
```php
public function isThrough(): bool;
```
Check whether the relation is a 'many-to-many' relation or not
```php
public function setIntermediateRelation(
mixed $intermediateFields,
string $intermediateModel,
mixed $intermediateReferencedFields
);
```
Sets the intermediate model data for has-*-through relations
## Mvc\Model\RelationInterface
Interface
Phalcon\Mvc\Model\RelationInterface
Interface for Phalcon\Mvc\Model\Relation
- **`Phalcon\Mvc\Model\RelationInterface`**
### Method Summary
Returns the fields
Returns the foreign key configuration
Gets the intermediate fields for has-*-through relations
Gets the intermediate model for has-*-through relations
Gets the intermediate referenced fields for has-*-through relations
Returns an option by the specified name
Returns the options
Returns parameters that must be always used when the related records are obtained
Returns the referenced fields
Returns the referenced model
Returns the relations type
Check whether the relation act as a foreign key
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
Check whether the relation is a 'many-to-many' relation or not
Sets the intermediate model data for has-*-through relations
### Methods
getFields()
```php
public function getFields();
```
Returns the fields
getForeignKey()
```php
public function getForeignKey();
```
Returns the foreign key configuration
```php
public function getIntermediateFields();
```
Gets the intermediate fields for has-*-through relations
```php
public function getIntermediateModel(): string;
```
Gets the intermediate model for has-*-through relations
```php
public function getIntermediateReferencedFields();
```
Gets the intermediate referenced fields for has-*-through relations
getOption()
```php
public function getOption( string $name );
```
Returns an option by the specified name
If the option does not exist null is returned
getOptions()
```php
public function getOptions(): array;
```
Returns the options
getParams()
```php
public function getParams();
```
Returns parameters that must be always used when the related records are obtained
getReferencedFields()
```php
public function getReferencedFields();
```
Returns the referenced fields
getReferencedModel()
```php
public function getReferencedModel(): string;
```
Returns the referenced model
getType()
```php
public function getType(): int;
```
Returns the relations type
isForeignKey()
```php
public function isForeignKey(): bool;
```
Check whether the relation act as a foreign key
isReusable()
```php
public function isReusable(): bool;
```
Check if records returned by getting belongs-to/has-many are implicitly cached during the current request
isThrough()
```php
public function isThrough(): bool;
```
Check whether the relation is a 'many-to-many' relation or not
```php
public function setIntermediateRelation(
mixed $intermediateFields,
string $intermediateModel,
mixed $intermediateReferencedFields
);
```
Sets the intermediate model data for has-*-through relations
## Mvc\Model\ResultInterface
Interface
Phalcon\Mvc\Model\ResultInterface
All single objects passed as base objects to Resultsets must implement this interface
- **`Phalcon\Mvc\Model\ResultInterface`**
`Phalcon\Mvc\ModelInterface`
### Method Summary
Sets the object's state
### Methods
setDirtyState()
```php
public function setDirtyState( int $dirtyState ): ModelInterface|bool;
```
Sets the object's state
## Mvc\Model\Resultset
Abstract
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.
```php
// Using a standard foreach
$invoices = Invoices::find(
[
"inv_status_flag = 1",
"order" => "inv_title",
]
);
foreach ($invoices as invoice) {
echo invoice->inv_title, "\n";
}
// Using a while
$invoices = Invoices::find(
[
"inv_status_flag = 1",
"order" => "inv_title",
]
);
$invoices->rewind();
while ($invoices->valid()) {
$invoice = $invoices->current();
echo $invoice->inv_title, "\n";
$invoices->next();
}
```
@template TKey
@template TValue
@implements Iterator<TKey, TValue>
@implements ArrayAccess<TKey, TValue>
- **`Phalcon\Mvc\Model\Resultset`** - implements [`Phalcon\Mvc\Model\ResultsetInterface`](#mvcmodelresultsetinterface), `\Iterator`, `\SeekableIterator`, `\Countable`, `\ArrayAccess`, `\JsonSerializable`
- [`Phalcon\Mvc\Model\Resultset\Complex`](#mvcmodelresultsetcomplex)
- [`Phalcon\Mvc\Model\Resultset\Simple`](#mvcmodelresultsetsimple)
`ArrayAccess` · `Closure` · `Countable` · `Iterator` · `JsonSerializable` · `Phalcon\Cache\CacheInterface` · `Phalcon\Db\Enum` · `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\Model` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exceptions\CursorIsImmutable` · `Phalcon\Mvc\Model\Exceptions\IndexNotInCursor` · `Phalcon\Mvc\Model\Exceptions\InvalidResultsetCacheService` · `Phalcon\Mvc\Model\Exceptions\InvalidReturnedRecord` · `Phalcon\Storage\Serializer\SerializerInterface` · `Phalcon\Support\Settings` · `SeekableIterator`
### Method Summary
Phalcon\Mvc\Model\Resultset constructor
Counts how many rows are in the resultset
Deletes every record in the resultset
Filters a resultset returning only those the developer requires
Returns the associated cache for the resultset
Get first row in the resultset
Returns the current hydration mode
Get last row in the resultset
Returns the error messages produced by a batch operation
Returns the internal type of data retrieval that the resultset is using
Tell if the resultset if fresh or an old one cached
Returns serialised model objects as array for json_encode.
Gets pointer number of active row in the resultset
Fetches every remaining row of the underlying cursor into memory,
Moves cursor to next row in the resultset
Checks whether offset exists in the resultset
Gets row in a specific position of the resultset
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
Rewinds resultset to its beginning
Changes the internal pointer to a specific position in the resultset.
Sets the hydration mode in the resultset
Set if the resultset is fresh or an old one cached
Updates every record in the resultset
Check whether internal resource has rows to fetch
### Constants
### Properties
Number of rows, or null while it has not been worked out yet. Resolved
lazily by count() - asking the driver up front costs SQLite an extra
statement on every single result-set.
Phalcon\Db\ResultInterface or false for empty resultset
### Methods
__construct()
```php
public function __construct(
mixed $result,
mixed $cache = null
);
```
Phalcon\Mvc\Model\Resultset constructor
count()
```php
final public function count(): int;
```
Counts how many rows are in the resultset
delete()
```php
public function delete( Closure|null $conditionCallback = null ): bool;
```
Deletes every record in the resultset
filter()
```php
public function filter( callable $filter ): ModelInterface[];
```
Filters a resultset returning only those the developer requires
```php
$filtered = $invoices->filter(
function ($invoice) {
if ($invoice->inv_id < 3) {
return $invoice;
}
}
);
```
getCache()
```php
public function getCache(): CacheInterface|null;
```
Returns the associated cache for the resultset
getFirst()
```php
public function getFirst(): mixed|null;
```
Get first row in the resultset
```php
$model = new Invoices();
$manager = $model->getModelsManager();
// \Invoices
$manager->createQuery('SELECT * FROM Invoices')
->execute()
->getFirst();
// \Phalcon\Mvc\Model\Row
$manager->createQuery('SELECT r.inv_id FROM Invoices AS r')
->execute()
->getFirst();
// NULL
$manager->createQuery('SELECT r.inv_id FROM Invoices AS r WHERE r.inv_title = "NON-EXISTENT"')
->execute()
->getFirst();
```
getHydrateMode()
```php
public function getHydrateMode(): int;
```
Returns the current hydration mode
getLast()
```php
public function getLast(): ModelInterface|null;
```
Get last row in the resultset
getMessages()
```php
public function getMessages(): MessageInterface[];
```
Returns the error messages produced by a batch operation
getResult()
```php
public function getResult(): mixed;
```
getType()
```php
public function getType(): int;
```
Returns the internal type of data retrieval that the resultset is using
isFresh()
```php
public function isFresh(): bool;
```
Tell if the resultset if fresh or an old one cached
jsonSerialize()
```php
public function jsonSerialize(): array;
```
Returns serialised model objects as array for json_encode.
Calls jsonSerialize on each object if present
```php
$invoices = Invoices::find();
echo json_encode($invoices);
```
key()
```php
public function key(): int|null;
```
Gets pointer number of active row in the resultset
materialize()
```php
public function materialize(): void;
```
Fetches every remaining row of the underlying cursor into memory,
turning the resultset into TYPE_RESULT_FULL.
Free when called before the cursor has been advanced: the statement has
already been executed by Model\Query::executeSelect() and only the row
the constructor consumed is missing from the cursor, so no re-execution
takes place. Idempotent.
next()
```php
public function next(): void;
```
Moves cursor to next row in the resultset
offsetExists()
```php
public function offsetExists( mixed $index ): bool;
```
Checks whether offset exists in the resultset
offsetGet()
```php
public function offsetGet( mixed $index ): mixed;
```
Gets row in a specific position of the resultset
offsetSet()
```php
public function offsetSet(
mixed $offset,
mixed $value
): void;
```
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
offsetUnset()
```php
public function offsetUnset( mixed $offset ): void;
```
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
refresh()
```php
public function refresh(): bool;
```
rewind()
```php
final public function rewind(): void;
```
Rewinds resultset to its beginning
seek()
```php
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
setHydrateMode()
```php
public function setHydrateMode( int $hydrateMode ): ResultsetInterface;
```
Sets the hydration mode in the resultset
setIsFresh()
```php
public function setIsFresh( bool $isFresh ): ResultsetInterface;
```
Set if the resultset is fresh or an old one cached
update()
```php
public function update(
mixed $data,
Closure|null $conditionCallback = null
): bool;
```
Updates every record in the resultset
valid()
```php
public function valid(): bool;
```
Check whether internal resource has rows to fetch
Driven by the row the cursor is parked on rather than by the count, so
that a plain traversal never has to ask the driver how many rows there
are - on SQLite that answer costs a second statement.
## Mvc\Model\ResultsetInterface
Interface
Phalcon\Mvc\Model\ResultsetInterface
Interface for Phalcon\Mvc\Model\Resultset
- **`Phalcon\Mvc\Model\ResultsetInterface`**
`Closure` · `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Deletes every record in the resultset
Filters a resultset returning only those the developer requires
Returns the associated cache for the resultset
Get first row in the resultset
Returns the current hydration mode
Get last row in the resultset
Returns the error messages produced by a batch operation
Returns the internal type of data retrieval that the resultset is using
Tell if the resultset if fresh or an old one cached
Sets the hydration mode in the resultset
Set if the resultset is fresh or an old one cached
Returns a complete resultset as an array, if the resultset has a big number of rows
Updates every record in the resultset
### Methods
delete()
```php
public function delete( Closure|null $conditionCallback = null ): bool;
```
Deletes every record in the resultset
filter()
```php
public function filter( callable $filter ): ModelInterface[];
```
Filters a resultset returning only those the developer requires
```php
$filtered = $invoices->filter(
function ($invoice) {
if ($invoice->inv_id < 3) {
return $invoice;
}
}
);
```
getCache()
```php
public function getCache(): mixed|null;
```
Returns the associated cache for the resultset
getFirst()
```php
public function getFirst(): mixed|null;
```
Get first row in the resultset
getHydrateMode()
```php
public function getHydrateMode(): int;
```
Returns the current hydration mode
getLast()
```php
public function getLast(): ModelInterface|null;
```
Get last row in the resultset
getMessages()
```php
public function getMessages(): MessageInterface[];
```
Returns the error messages produced by a batch operation
getType()
```php
public function getType(): int;
```
Returns the internal type of data retrieval that the resultset is using
isFresh()
```php
public function isFresh(): bool;
```
Tell if the resultset if fresh or an old one cached
setHydrateMode()
```php
public function setHydrateMode( int $hydrateMode ): ResultsetInterface;
```
Sets the hydration mode in the resultset
setIsFresh()
```php
public function setIsFresh( bool $isFresh ): ResultsetInterface;
```
Set if the resultset is fresh or an old one cached
toArray()
```php
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.
update()
```php
public function update(
mixed $data,
Closure|null $conditionCallback = null
): bool;
```
Updates every record in the resultset
## Mvc\Model\Resultset\Complex
Class
Phalcon\Mvc\Model\Resultset\Complex
Complex resultsets may include complete objects and scalar values.
This class builds every complex row as it is required
@template TKey of int
@template TValue of mixed
- [`Phalcon\Mvc\Model\Resultset`](#mvcmodelresultset)
- **`Phalcon\Mvc\Model\Resultset\Complex`**
`Phalcon\Db\ResultInterface` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\Model` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exception` · `Phalcon\Mvc\Model\Exceptions\CorruptColumnType` · `Phalcon\Mvc\Model\Exceptions\InvalidContainer` · `Phalcon\Mvc\Model\Exceptions\InvalidSerializationData` · `Phalcon\Mvc\Model\Resultset` · `Phalcon\Mvc\Model\ResultsetInterface` · `Phalcon\Mvc\Model\Row` · `Phalcon\Storage\Serializer\SerializerInterface` · `Phalcon\Support\Settings` · `stdClass`
### Method Summary
Phalcon\Mvc\Model\Resultset\Complex constructor
Returns current row in the resultset
Serializing a resultset will dump all related rows into a big array,
Returns a complete resultset as an array, if the resultset has a big
Unserializing a resultset will allow to only works on the rows present in the saved state
### Properties
Unserialised result-set hydrated all rows already. unserialise() sets
disableHydration to true
### Methods
__construct()
```php
public function __construct(
mixed $columnTypes,
ResultInterface|null $result = null,
mixed $cache = null,
string $resultsetRowClass = ""
);
```
Phalcon\Mvc\Model\Resultset\Complex constructor
__serialize()
```php
public function __serialize(): array;
```
__unserialize()
```php
public function __unserialize( array $data ): void;
```
current()
```php
final public function current(): mixed;
```
Returns current row in the resultset
serialize()
```php
public function serialize(): string;
```
Serializing a resultset will dump all related rows into a big array,
serialize it and return the resulting string
toArray()
```php
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.
unserialize()
```php
public function unserialize( mixed $data ): void;
```
Unserializing a resultset will allow to only works on the rows present in the saved state
## Mvc\Model\Resultset\Simple
Class
Phalcon\Mvc\Model\Resultset\Simple
Simple resultsets only contains a complete objects
This class builds every complete object as it is required
@template TKey of int
@template TValue of \Phalcon\Mvc\ModelInterface
- [`Phalcon\Mvc\Model\Resultset`](#mvcmodelresultset)
- **`Phalcon\Mvc\Model\Resultset\Simple`**
`Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\Model` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Eager\Loader` · `Phalcon\Mvc\Model\Exception` · `Phalcon\Mvc\Model\Exceptions\InvalidContainer` · `Phalcon\Mvc\Model\Exceptions\InvalidSerializationData` · `Phalcon\Mvc\Model\Exceptions\ResultsetColumnNotInMap` · `Phalcon\Mvc\Model\Resultset` · `Phalcon\Mvc\Model\Row` · `Phalcon\Storage\Serializer\SerializerInterface` · `Phalcon\Support\Settings`
### Method Summary
Phalcon\Mvc\Model\Resultset\Simple constructor
Returns current row in the resultset
Serializing a resultset will dump all related rows into a big array
Attaches a pre-loaded relation map, applied to every record as it is
Builds a new resultset of the same concrete class over the rows at the
Returns a complete resultset as an array, if the resultset has a big
Unserializing a resultset will allow to only works on the rows present in
### Properties
### Methods
__construct()
```php
public function __construct(
mixed $columnMap,
mixed $model,
mixed $result,
mixed $cache = null,
bool $keepSnapshots = false
);
```
Phalcon\Mvc\Model\Resultset\Simple constructor
__serialize()
```php
public function __serialize(): array;
```
__unserialize()
```php
public function __unserialize( array $data ): void;
```
current()
```php
final public function current(): ModelInterface|Row|null;
```
Returns current row in the resultset
serialize()
```php
public function serialize(): string;
```
Serializing a resultset will dump all related rows into a big array
setEagerMap()
```php
public function setEagerMap( array $eagerMap ): void;
```
Attaches a pre-loaded relation map, applied to every record as it is
hydrated.
Records in a resultset are transient - seek() clears activeRow on every
move and current() re-hydrates from the raw row - so hydration is the
only durable point at which relations can be stamped.
sliceRows()
```php
public function sliceRows( array $indexes ): Simple;
```
Builds a new resultset of the same concrete class over the rows at the
given positions, preserving the column map, record prototype and
snapshot behavior of this resultset.
toArray()
```php
public function toArray( bool $renameColumns = true ): 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
unserialize()
```php
public function unserialize( mixed $data ): void;
```
Unserializing a resultset will allow to only works on the rows present in
the saved state
## Mvc\Model\Row
Class
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].
- `\stdClass`
- **`Phalcon\Mvc\Model\Row`** - implements [`Phalcon\Mvc\EntityInterface`](#mvcentityinterface), [`Phalcon\Mvc\Model\ResultInterface`](#mvcmodelresultinterface), `\ArrayAccess`, `\JsonSerializable`
`ArrayAccess` · `JsonSerializable` · `Phalcon\Mvc\EntityInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exceptions\IndexNotInRow` · `Phalcon\Mvc\Model\Exceptions\RowIsImmutable`
### Method Summary
Serializes the object for json_encode
Checks whether offset exists in the row. Returns true when the property
Gets a record in a specific position of the row
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
Reads an attribute value by its name
Set the current object's state
Returns the instance as an array representation
Writes an attribute value by its name
### Methods
jsonSerialize()
```php
public function jsonSerialize(): array;
```
Serializes the object for json_encode
offsetExists()
```php
public function offsetExists( mixed $index ): bool;
```
Checks whether offset exists in the row. Returns true when the property
is present on the row, regardless of whether its value is null - column
presence is the contract, not value truthiness.
offsetGet()
```php
public function offsetGet( mixed $index ): mixed;
```
Gets a record in a specific position of the row
offsetSet()
```php
public function offsetSet(
mixed $offset,
mixed $value
): void;
```
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
offsetUnset()
```php
public function offsetUnset( mixed $offset ): void;
```
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
readAttribute()
```php
public function readAttribute( string $attribute );
```
Reads an attribute value by its name
```php
echo $invoice->readAttribute("inv_title");
```
setDirtyState()
```php
public function setDirtyState( int $dirtyState ): ModelInterface|bool;
```
Set the current object's state
toArray()
```php
public function toArray(): array;
```
Returns the instance as an array representation
writeAttribute()
```php
public function writeAttribute(
string $attribute,
mixed $value
): void;
```
Writes an attribute value by its name
```php
$invoice->writeAttribute("inv_title", "Test Invoice");
```
## Mvc\Model\Transaction
Class
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.
```php
use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;
try {
$manager = new Manager();
$transaction = $manager->get();
$invoice = new Invoices();
$invoice->setTransaction($transaction);
$invoice->inv_title = "Test Invoice";
$invoice->inv_created_at = date("Y-m-d");
if ($invoice->save() === false) {
$transaction->rollback("Can't save invoice");
}
$product = new Products();
$product->setTransaction($transaction);
$product->prd_name = "Widget";
if ($product->save() === false) {
$transaction->rollback("Can't save product");
}
$transaction->commit();
} catch(Failed $e) {
echo "Failed, reason: ", $e->getMessage();
}
```
- **`Phalcon\Mvc\Model\Transaction`** - implements [`Phalcon\Mvc\Model\TransactionInterface`](#mvcmodeltransactioninterface)
`Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\TransactionInterface` · `Phalcon\Mvc\Model\Transaction\Failed` · `Phalcon\Mvc\Model\Transaction\ManagerInterface`
### Method Summary
Phalcon\Mvc\Model\Transaction constructor
Starts the transaction
Commits the transaction
Returns the connection related to transaction
Returns validations messages from last save try
Checks whether transaction is managed by a transaction manager
Checks whether internal connection is under an active transaction
Rollbacks the transaction
Sets if is a reused transaction or new once
Sets flag to rollback on abort the HTTP connection
Sets object which generates rollback action
Sets transaction manager related to the transaction
Enables throwing exception
### Properties
### Methods
__construct()
```php
public function __construct(
DiInterface $container,
bool $autoBegin = false,
string $service = "db"
);
```
Phalcon\Mvc\Model\Transaction constructor
begin()
```php
public function begin(): bool;
```
Starts the transaction
commit()
```php
public function commit(): bool;
```
Commits the transaction
getConnection()
```php
public function getConnection(): AdapterInterface;
```
Returns the connection related to transaction
getMessages()
```php
public function getMessages(): array;
```
Returns validations messages from last save try
isManaged()
```php
public function isManaged(): bool;
```
Checks whether transaction is managed by a transaction manager
isValid()
```php
public function isValid(): bool;
```
Checks whether internal connection is under an active transaction
rollback()
```php
public function rollback(
string|null $rollbackMessage = null,
ModelInterface|null $rollbackRecord = null
): bool;
```
Rollbacks the transaction
setIsNewTransaction()
```php
public function setIsNewTransaction( bool $isNew ): void;
```
Sets if is a reused transaction or new once
setRollbackOnAbort()
```php
public function setRollbackOnAbort( bool $rollbackOnAbort ): void;
```
Sets flag to rollback on abort the HTTP connection
setRollbackedRecord()
```php
public function setRollbackedRecord( ModelInterface $record ): void;
```
Sets object which generates rollback action
setTransactionManager()
```php
public function setTransactionManager( ManagerInterface $manager ): void;
```
Sets transaction manager related to the transaction
throwRollbackException()
```php
public function throwRollbackException( bool $status ): TransactionInterface;
```
Enables throwing exception
## Mvc\Model\TransactionInterface
Interface
Interface for Phalcon\Mvc\Model\Transaction
- **`Phalcon\Mvc\Model\TransactionInterface`**
`Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Transaction\ManagerInterface`
### Method Summary
Starts the transaction
Commits the transaction
Returns connection related to transaction
Returns validations messages from last save try
Checks whether transaction is managed by a transaction manager
Checks whether internal connection is under an active transaction
Rollbacks the transaction
Sets if is a reused transaction or new once
Sets flag to rollback on abort the HTTP connection
Sets object which generates rollback action
Sets transaction manager related to the transaction
Enables throwing exception
### Methods
begin()
```php
public function begin(): bool;
```
Starts the transaction
commit()
```php
public function commit(): bool;
```
Commits the transaction
getConnection()
```php
public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;
```
Returns connection related to transaction
getMessages()
```php
public function getMessages(): array;
```
Returns validations messages from last save try
isManaged()
```php
public function isManaged(): bool;
```
Checks whether transaction is managed by a transaction manager
isValid()
```php
public function isValid(): bool;
```
Checks whether internal connection is under an active transaction
rollback()
```php
public function rollback(
string|null $rollbackMessage = null,
ModelInterface|null $rollbackRecord = null
): bool;
```
Rollbacks the transaction
setIsNewTransaction()
```php
public function setIsNewTransaction( bool $isNew ): void;
```
Sets if is a reused transaction or new once
setRollbackOnAbort()
```php
public function setRollbackOnAbort( bool $rollbackOnAbort ): void;
```
Sets flag to rollback on abort the HTTP connection
setRollbackedRecord()
```php
public function setRollbackedRecord( ModelInterface $record ): void;
```
Sets object which generates rollback action
setTransactionManager()
```php
public function setTransactionManager( ManagerInterface $manager ): void;
```
Sets transaction manager related to the transaction
throwRollbackException()
```php
public function throwRollbackException( bool $status ): TransactionInterface;
```
Enables throwing exception
## Mvc\Model\Transaction\Exception
Class
Phalcon\Mvc\Model\Transaction\Exception
Exceptions thrown in Phalcon\Mvc\Model\Transaction will use this class
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\Transaction\Exception`**
- [`Phalcon\Mvc\Model\Transaction\Failed`](#mvcmodeltransactionfailed)
## Mvc\Model\Transaction\Failed
Class
Phalcon\Mvc\Model\Transaction\Failed
This class will be thrown to exit a try/catch block for isolated transactions
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- [`Phalcon\Mvc\Model\Transaction\Exception`](#mvcmodeltransactionexception)
- **`Phalcon\Mvc\Model\Transaction\Failed`**
`Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Phalcon\Mvc\Model\Transaction\Failed constructor
Returns validation record messages which stop the transaction
Returns validation record messages which stop the transaction
### Properties
### Methods
__construct()
```php
public function __construct(
string $message,
ModelInterface|null $record = null
);
```
Phalcon\Mvc\Model\Transaction\Failed constructor
getRecord()
```php
public function getRecord(): ModelInterface|null;
```
Returns validation record messages which stop the transaction
getRecordMessages()
```php
public function getRecordMessages(): array|string;
```
Returns validation record messages which stop the transaction
## Mvc\Model\Transaction\Manager
Class
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.
```php
use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;
try {
$transactionManager = new Manager();
$transaction = $transactionManager->get();
$invoice = new Invoices();
$invoice->setTransaction($transaction);
$invoice->inv_title = "Test Invoice";
$invoice->inv_created_at = date("Y-m-d");
if ($invoice->save() === false) {
$transaction->rollback("Can't save invoice");
}
$product = new Products();
$product->setTransaction($transaction);
$product->prd_name = "Widget";
if ($product->save() === false) {
$transaction->rollback("Can't save product");
}
$transaction->commit();
} catch (Failed $e) {
echo "Failed, reason: ", $e->getMessage();
}
```
- **`Phalcon\Mvc\Model\Transaction\Manager`** - implements [`Phalcon\Mvc\Model\Transaction\ManagerInterface`](#mvcmodeltransactionmanagerinterface), [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface)
`Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable` · `Phalcon\Mvc\Model\Transaction` · `Phalcon\Mvc\Model\TransactionInterface`
### Method Summary
Phalcon\Mvc\Model\Transaction\Manager constructor
Remove all the transactions from the manager
Commits active transactions within the manager
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
Returns the dependency injection container
Returns the database service used to isolate the transaction
Create/Returns a new transaction or an existing one
Check if the transaction manager is registering a shutdown function to
Checks whether the manager has an active transaction
Notifies the manager about a committed transaction
Notifies the manager about a rollbacked transaction
Rollbacks active transactions within the manager
Rollbacks active transactions within the manager
Sets the dependency injection container
Sets the database service used to run the isolated transactions
Set if the transaction manager must register a shutdown function to clean
Removes transactions from the TransactionManager
### Properties
### Methods
__construct()
```php
public function __construct( DiInterface|null $container = null );
```
Phalcon\Mvc\Model\Transaction\Manager constructor
collectTransactions()
```php
public function collectTransactions(): void;
```
Remove all the transactions from the manager
commit()
```php
public function commit();
```
Commits active transactions within the manager
get()
```php
public function get( bool $autoBegin = true ): TransactionInterface;
```
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
This method registers a shutdown function to rollback active connections
getDI()
```php
public function getDI(): DiInterface;
```
Returns the dependency injection container
getDbService()
```php
public function getDbService(): string;
```
Returns the database service used to isolate the transaction
getOrCreateTransaction()
```php
public function getOrCreateTransaction( bool $autoBegin = true ): TransactionInterface;
```
Create/Returns a new transaction or an existing one
getRollbackPendent()
```php
public function getRollbackPendent(): bool;
```
Check if the transaction manager is registering a shutdown function to
clean up pendent transactions
has()
```php
public function has(): bool;
```
Checks whether the manager has an active transaction
notifyCommit()
```php
public function notifyCommit( TransactionInterface $transaction ): void;
```
Notifies the manager about a committed transaction
notifyRollback()
```php
public function notifyRollback( TransactionInterface $transaction ): void;
```
Notifies the manager about a rollbacked transaction
rollback()
```php
public function rollback( bool $collect = true ): void;
```
Rollbacks active transactions within the manager
Collect will remove the transaction from the manager
rollbackPendent()
```php
public function rollbackPendent(): void;
```
Rollbacks active transactions within the manager
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the dependency injection container
setDbService()
```php
public function setDbService( string $service ): ManagerInterface;
```
Sets the database service used to run the isolated transactions
setRollbackPendent()
```php
public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;
```
Set if the transaction manager must register a shutdown function to clean
up pendent transactions
collectTransaction()
```php
protected function collectTransaction( TransactionInterface $transaction ): void;
```
Removes transactions from the TransactionManager
## Mvc\Model\Transaction\ManagerInterface
Interface
Phalcon\Mvc\Model\Transaction\ManagerInterface
Interface for Phalcon\Mvc\Model\Transaction\Manager
- **`Phalcon\Mvc\Model\Transaction\ManagerInterface`**
`Phalcon\Mvc\Model\TransactionInterface`
### Method Summary
Remove all the transactions from the manager
Commits active transactions within the manager
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
Returns the database service used to isolate the transaction
Check if the transaction manager is registering a shutdown function to clean up pendent transactions
Checks whether manager has an active transaction
Notifies the manager about a committed transaction
Notifies the manager about a rollbacked transaction
Rollbacks active transactions within the manager
Rollbacks active transactions within the manager
Sets the database service used to run the isolated transactions
Set if the transaction manager must register a shutdown function to clean up pendent transactions
### Methods
collectTransactions()
```php
public function collectTransactions(): void;
```
Remove all the transactions from the manager
commit()
```php
public function commit();
```
Commits active transactions within the manager
get()
```php
public function get( bool $autoBegin = true ): TransactionInterface;
```
Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
getDbService()
```php
public function getDbService(): string;
```
Returns the database service used to isolate the transaction
getRollbackPendent()
```php
public function getRollbackPendent(): bool;
```
Check if the transaction manager is registering a shutdown function to clean up pendent transactions
has()
```php
public function has(): bool;
```
Checks whether manager has an active transaction
notifyCommit()
```php
public function notifyCommit( TransactionInterface $transaction ): void;
```
Notifies the manager about a committed transaction
notifyRollback()
```php
public function notifyRollback( TransactionInterface $transaction ): void;
```
Notifies the manager about a rollbacked transaction
rollback()
```php
public function rollback( bool $collect = false ): void;
```
Rollbacks active transactions within the manager
Collect will remove transaction from the manager
rollbackPendent()
```php
public function rollbackPendent(): void;
```
Rollbacks active transactions within the manager
setDbService()
```php
public function setDbService( string $service ): ManagerInterface;
```
Sets the database service used to run the isolated transactions
setRollbackPendent()
```php
public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;
```
Set if the transaction manager must register a shutdown function to clean up pendent transactions
## Mvc\Model\ValidationFailed
Class
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
- `\Exception`
- [`Phalcon\Mvc\Model\Exception`](#mvcmodelexception)
- **`Phalcon\Mvc\Model\ValidationFailed`**
`Phalcon\Messages\Message` · `Phalcon\Mvc\ModelInterface`
### Method Summary
Phalcon\Mvc\Model\ValidationFailed constructor
Returns the complete group of messages produced in the validation
Returns the model that generated the messages
### Properties
### Methods
__construct()
```php
public function __construct(
ModelInterface $model,
array $validationMessages
);
```
Phalcon\Mvc\Model\ValidationFailed constructor
getMessages()
```php
public function getMessages(): Message[];
```
Returns the complete group of messages produced in the validation
getModel()
```php
public function getModel(): ModelInterface;
```
Returns the model that generated the messages
## Mvc\ModuleDefinitionInterface
Interface
This interface must be implemented by class module definitions
- **`Phalcon\Mvc\ModuleDefinitionInterface`**
`Phalcon\Di\DiInterface`
### Method Summary
Registers an autoloader related to the module
Registers services related to the module
### Methods
registerAutoloaders()
```php
public function registerAutoloaders( DiInterface|null $container = null );
```
Registers an autoloader related to the module
registerServices()
```php
public function registerServices( DiInterface $container );
```
Registers services related to the module
## Mvc\Router
Class
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
```php
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();
```
- `\stdClass`
- [`Phalcon\Di\AbstractInjectionAware`](/5.20/api/phalcon_di/#diabstractinjectionaware)
- **`Phalcon\Mvc\Router`** - implements [`Phalcon\Mvc\RouterInterface`](#mvcrouterinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
- [`Phalcon\Mvc\Router\Annotations`](#mvcrouterannotations)
`Phalcon\Cache\Adapter\AdapterInterface` · `Phalcon\Config\ConfigInterface` · `Phalcon\Di\AbstractInjectionAware` · `Phalcon\Di\DiInterface` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Http\RequestInterface` · `Phalcon\Mvc\Router\Exception` · `Phalcon\Mvc\Router\Exceptions\BeforeMatchNotCallable` · `Phalcon\Mvc\Router\Exceptions\ConfigKeyMustBeArray` · `Phalcon\Mvc\Router\Exceptions\EmptyGroupOfRoutes` · `Phalcon\Mvc\Router\Exceptions\GroupRoutesMustBeArray` · `Phalcon\Mvc\Router\Exceptions\InvalidConfigSource` · `Phalcon\Mvc\Router\Exceptions\InvalidNotFoundPaths` · `Phalcon\Mvc\Router\Exceptions\InvalidRoutePosition` · `Phalcon\Mvc\Router\Exceptions\MissingGroupRouteKey` · `Phalcon\Mvc\Router\Exceptions\MissingRouteConfigKey` · `Phalcon\Mvc\Router\Exceptions\RequestServiceUnavailable` · `Phalcon\Mvc\Router\Exceptions\UnknownHttpMethod` · `Phalcon\Mvc\Router\Exceptions\WrongPathsKey` · `Phalcon\Mvc\Router\Group` · `Phalcon\Mvc\Router\GroupInterface` · `Phalcon\Mvc\Router\Route` · `Phalcon\Mvc\Router\RouteInterface` · `Phalcon\Traits\Php\FileTrait`
### Method Summary
Phalcon\Mvc\Router constructor
Adds a route to the router without any HTTP constraint
Adds a route to the router that only match if the HTTP method is CONNECT
Adds a route to the router that only match if the HTTP method is DELETE
Adds a route to the router that only match if the HTTP method is GET
Adds a route to the router that only match if the HTTP method is HEAD
Add a route to the router that only match if the HTTP method is OPTIONS
Adds a route to the router that only match if the HTTP method is PATCH
Adds a route to the router that only match if the HTTP method is POST
Adds a route to the router that only match if the HTTP method is PURGE
Adds a route to the router that only match if the HTTP method is PUT
Adds a route to the router that only match if the HTTP method is TRACE
Attach Route object to the routes stack.
Produces a pure-data array describing every piece of state needed
Removes all the pre-defined routes
File-shaped helper around buildDispatcherDump(). Writes the dump as
Returns the processed action name
Returns the processed controller name
Returns an array of default parameters
Returns the internal event manager
Returns the route that matches the handled URI
Returns the sub expressions in the regular expression matched
Returns the routes indexed by HTTP method.
Returns the processed module name
Returns the processed namespace name
Returns the processed parameters
Get rewrite info. This info is read from $_GET["_url"].
Returns a route object by its id
Returns a route object by its name
Returns all the routes defined in the router
Handles routing information received from the rewrite engine
Returns whether controller name should not be mangled
File-shaped helper around loadDispatcherFromArray(). Includes the
Inverse of buildDispatcherDump(). Reconstructs every Route from the
Loads routes from an array or Phalcon\Config\Config instance.
Mounts a group of routes in the router
Set a group of paths to be returned when none of the defined routes are
Set whether router must remove the extra slashes in the handled routes
Sets the default action name
Sets the default controller name
Sets the name of the default module
Sets the name of the default namespace
Sets an array of default paths. If a route is missing a path the router
Sets the events manager
Sets the URI source. One of the URI_SOURCE_* constants
Cache-instance convenience wrapper. On cache hit, restores the
Checks if the router matches any of the defined routes
Adds a single route from a config array entry. Used by loadFromConfig.
Builds a Group from a config entry and mounts it. Used by loadFromConfig.
Rebuilds the HTTP-method index from the current routes array.
### Constants
Number of alternatives per combined-regex chunk. Empirically derived
(FastRoute uses ~10) - keeps each chunk below PCRE's optimizer cliff.
### Properties
Pre-merged per-method candidate buckets in attach order. For each HTTP
method seen on any registered route, the bucket contains the
method-specific routes followed by the "*" (no-constraint) routes.
The "*" key itself holds only the no-constraint routes - used when the
request method has no specific bucket.
Built in rebuildMethodIndex(); consumed by handle() in reverse.
Combined PCRE pattern per method bucket (chunked list of strings).
Each chunk uses (?|...) branch reset and (*:N) mark labels. Built
only when the bucket meets gating: no hostname routes; standard
pattern shape.
Boolean per method bucket: true when the combined regex cannot be
built (hostname route present, exotic pattern shape, etc.).
Map from MARK label back to the route index in
candidatesByMethod[method]. One per chunk.
combinedRegexMarkMap[method][chunkIdx][markLabel] = routeIdx
Per-method buckets of routes with hostname constraints, grouped by
raw hostname string. Routes are referenced by their index into
candidatesByMethod[method]. Built in rebuildMethodIndex().
Shape: hostnameByMethod[method][hostname] = list of route indices.
Per-method indices of routes without a hostname constraint, in
attach order.
Shape: hostnameLessByMethod[method] = list of route indices into
candidatesByMethod[method].
Lazy-write cache target set by useCache(). When non-null, handle()
writes buildDispatcherDump() to this cache after a successful
rebuild on cache miss, then clears the property to skip subsequent
writes.
Single-source per-route metadata cache. One entry per route, keyed
by the route's intrinsic id. Replaces the previous per-method-bucket
replication of metadata arrays. Built once in rebuildMethodIndex().
Shape: routeMeta[routeId] = [
"pattern": string, // compiled pattern
"isRegex": bool,
"hostname": string|null,
"hostRegex": string|null,
"beforeMatch": callable|null
]
Static-route hash, populated by rebuildMethodIndex(). For each method
bucket (including "*"), maps URI => list of routes whose compiled
pattern is a literal string equal to that URI.
Shadow-detection map. If staticShadowedByMethod[method][uri] is set,
the static URI in that bucket is shadowed by a later-attached regex
route - the fast path MUST NOT be used; fall through to the dynamic
loop so the regex wins (reverse-iteration semantics).
### Methods
__construct()
```php
public function __construct( bool $defaultRoutes = true );
```
Phalcon\Mvc\Router constructor
add()
```php
public function add(
string $pattern,
mixed $paths = null,
mixed $httpMethods = null,
int $position = Router::POSITION_LAST
): RouteInterface;
```
Adds a route to the router without any HTTP constraint
```php
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
);
```
addConnect()
```php
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
addDelete()
```php
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
addGet()
```php
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
addHead()
```php
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
addOptions()
```php
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
addPatch()
```php
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
addPost()
```php
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
addPurge()
```php
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)
addPut()
```php
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
addTrace()
```php
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
attach()
```php
public function attach(
RouteInterface $route,
int $position = Router::POSITION_LAST
): static;
```
Attach Route object to the routes stack.
```php
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
);
```
buildDispatcherDump()
```php
public function buildDispatcherDump(): array;
```
Produces a pure-data array describing every piece of state needed
to reconstruct this router. The returned array is var_export-able
(no objects, no closures). Used by dumpDispatcher() and by
Phalcon\Cache integration via useCache().
Throws when a route has a Closure beforeMatch or converter - those
cannot be cached.
clear()
```php
public function clear(): void;
```
Removes all the pre-defined routes
dumpDispatcher()
```php
public function dumpDispatcher( string $path ): void;
```
File-shaped helper around buildDispatcherDump(). Writes the dump as
a `getActionName()
```php
public function getActionName(): string;
```
Returns the processed action name
getControllerName()
```php
public function getControllerName(): string;
```
Returns the processed controller name
getDefaults()
```php
public function getDefaults(): array;
```
Returns an array of default parameters
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getKeyRouteIds()
```php
public function getKeyRouteIds(): array;
```
getKeyRouteNames()
```php
public function getKeyRouteNames(): array;
```
getMatchedRoute()
```php
public function getMatchedRoute(): RouteInterface|null;
```
Returns the route that matches the handled URI
getMatches()
```php
public function getMatches(): array;
```
Returns the sub expressions in the regular expression matched
getMethodRoutes()
```php
public function getMethodRoutes(): array;
```
Returns the routes indexed by HTTP method.
Routes with no HTTP constraint are stored under the "*" key.
getModuleName()
```php
public function getModuleName(): string;
```
Returns the processed module name
getNamespaceName()
```php
public function getNamespaceName(): string;
```
Returns the processed namespace name
getParams()
```php
public function getParams(): array;
```
Returns the processed parameters
getRewriteUri()
```php
public function getRewriteUri(): string;
```
Get rewrite info. This info is read from $_GET["_url"].
This returns '/' if the rewrite information cannot be read
getRouteById()
```php
public function getRouteById( mixed $routeId ): RouteInterface|bool;
```
Returns a route object by its id
getRouteByName()
```php
public function getRouteByName( string $name ): RouteInterface|bool;
```
Returns a route object by its name
getRoutes()
```php
public function getRoutes(): RouteInterface[];
```
Returns all the routes defined in the router
handle()
```php
public function handle( string $uri ): void;
```
Handles routing information received from the rewrite engine
```php
// Passing a URL
$router->handle("/posts/edit/1");
```
isExactControllerName()
```php
public function isExactControllerName(): bool;
```
Returns whether controller name should not be mangled
loadDispatcher()
```php
public function loadDispatcher( string $path ): void;
```
File-shaped helper around loadDispatcherFromArray(). Includes the
file (opcache-friendly) and forwards the return value.
loadDispatcherFromArray()
```php
public function loadDispatcherFromArray( array $dump ): void;
```
Inverse of buildDispatcherDump(). Reconstructs every Route from the
scalar `routes` entries (preserving subclass and routeId), restores
every index, and marks the indexes clean so handle() skips rebuild.
loadFromConfig()
```php
public function loadFromConfig( mixed $config ): static;
```
Loads routes from an array or Phalcon\Config\Config instance.
```php
$router->loadFromConfig(
[
'routes' => [
[
'method' => 'get',
'pattern' => '/users',
'paths' => 'Users::index',
],
],
]
);
```
mount()
```php
public function mount( GroupInterface $group ): static;
```
Mounts a group of routes in the router
notFound()
```php
public function notFound( mixed $paths ): static;
```
Set a group of paths to be returned when none of the defined routes are
matched
```php
public function removeExtraSlashes( bool $remove ): static;
```
Set whether router must remove the extra slashes in the handled routes
setDefaultAction()
```php
public function setDefaultAction( string $actionName ): static;
```
Sets the default action name
setDefaultController()
```php
public function setDefaultController( string $controllerName ): static;
```
Sets the default controller name
setDefaultModule()
```php
public function setDefaultModule( string $moduleName ): static;
```
Sets the name of the default module
setDefaultNamespace()
```php
public function setDefaultNamespace( string $namespaceName ): static;
```
Sets the name of the default namespace
@parma string namespaceName
setDefaults()
```php
public function setDefaults( array $defaults ): static;
```
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
```php
$router->setDefaults(
[
"module" => "common",
"action" => "index",
]
);
```
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
setKeyRouteIds()
```php
public function setKeyRouteIds( array $routeIds ): static;
```
setKeyRouteNames()
```php
public function setKeyRouteNames( array $routeNames ): static;
```
setUriSource()
```php
public function setUriSource( int $uriSource ): static;
```
Sets the URI source. One of the URI_SOURCE_* constants
```php
$router->setUriSource(
Router::URI_SOURCE_SERVER_REQUEST_URI
);
```
useCache()
```php
public function useCache(
CacheAdapterInterface $cache,
string $key = "phalcon.router.dispatcher"
): void;
```
Cache-instance convenience wrapper. On cache hit, restores the
dispatcher immediately. On miss, defers cache population until the
next handle() completes - at which point buildDispatcherDump() is
written to the cache key.
wasMatched()
```php
public function wasMatched(): bool;
```
Checks if the router matches any of the defined routes
addRouteFromConfig()
```php
protected function addRouteFromConfig( array $routeData ): void;
```
Adds a single route from a config array entry. Used by loadFromConfig.
```php
protected function extractRealUri( string $uri ): string;
```
mountGroupFromConfig()
```php
protected function mountGroupFromConfig( array $groupData ): void;
```
Builds a Group from a config entry and mounts it. Used by loadFromConfig.
rebuildMethodIndex()
```php
protected function rebuildMethodIndex(): void;
```
Rebuilds the HTTP-method index from the current routes array.
Routes with no HTTP method constraint are filed under "*".
## Mvc\RouterInterface
Interface
Interface for Phalcon\Mvc\Router
- **`Phalcon\Mvc\RouterInterface`**
`Phalcon\Mvc\Router\GroupInterface` · `Phalcon\Mvc\Router\RouteInterface`
### Method Summary
Adds a route to the router on any HTTP method
Adds a route to the router that only match if the HTTP method is CONNECT
Adds a route to the router that only match if the HTTP method is DELETE
Adds a route to the router that only match if the HTTP method is GET
Adds a route to the router that only match if the HTTP method is HEAD
Add a route to the router that only match if the HTTP method is OPTIONS
Adds a route to the router that only match if the HTTP method is PATCH
Adds a route to the router that only match if the HTTP method is POST
Adds a route to the router that only match if the HTTP method is PURGE
Adds a route to the router that only match if the HTTP method is PUT
Adds a route to the router that only match if the HTTP method is TRACE
Attach Route object to the routes stack.
Removes all the defined routes
Returns processed action name
Returns processed controller name
Returns the route that matches the handled URI
Return the sub expressions in the regular expression matched
Returns processed module name
Returns processed namespace name
Returns processed extra params
Returns a route object by its id
Returns a route object by its name
Return all the routes defined in the router
Handles routing information received from the rewrite engine
Loads routes from an array or Phalcon\Config\Config instance.
Mounts a group of routes in the router
Sets the default action name
Sets the default controller name
Sets the name of the default module
Sets an array of default paths
Check if the router matches any of the defined routes
### Methods
add()
```php
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
addConnect()
```php
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
addDelete()
```php
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
addGet()
```php
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
addHead()
```php
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
addOptions()
```php
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
addPatch()
```php
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
addPost()
```php
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
addPurge()
```php
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)
addPut()
```php
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
addTrace()
```php
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
attach()
```php
public function attach(
RouteInterface $route,
int $position = Router::POSITION_LAST
): RouterInterface;
```
Attach Route object to the routes stack.
clear()
```php
public function clear(): void;
```
Removes all the defined routes
getActionName()
```php
public function getActionName(): string;
```
Returns processed action name
getControllerName()
```php
public function getControllerName(): string;
```
Returns processed controller name
getMatchedRoute()
```php
public function getMatchedRoute(): RouteInterface|null;
```
Returns the route that matches the handled URI
getMatches()
```php
public function getMatches(): array;
```
Return the sub expressions in the regular expression matched
getModuleName()
```php
public function getModuleName(): string;
```
Returns processed module name
getNamespaceName()
```php
public function getNamespaceName(): string;
```
Returns processed namespace name
getParams()
```php
public function getParams(): array;
```
Returns processed extra params
getRouteById()
```php
public function getRouteById( mixed $routeId ): RouteInterface|bool;
```
Returns a route object by its id
getRouteByName()
```php
public function getRouteByName( string $name ): RouteInterface|bool;
```
Returns a route object by its name
getRoutes()
```php
public function getRoutes(): RouteInterface[];
```
Return all the routes defined in the router
handle()
```php
public function handle( string $uri ): void;
```
Handles routing information received from the rewrite engine
loadFromConfig()
```php
public function loadFromConfig( mixed $config ): RouterInterface;
```
Loads routes from an array or Phalcon\Config\Config instance.
mount()
```php
public function mount( GroupInterface $group ): RouterInterface;
```
Mounts a group of routes in the router
setDefaultAction()
```php
public function setDefaultAction( string $actionName ): RouterInterface;
```
Sets the default action name
setDefaultController()
```php
public function setDefaultController( string $controllerName ): RouterInterface;
```
Sets the default controller name
setDefaultModule()
```php
public function setDefaultModule( string $moduleName ): RouterInterface;
```
Sets the name of the default module
setDefaults()
```php
public function setDefaults( array $defaults ): RouterInterface;
```
Sets an array of default paths
wasMatched()
```php
public function wasMatched(): bool;
```
Check if the router matches any of the defined routes
## Mvc\Router\Annotations
Class
Phalcon\Mvc\Router\Annotations
A router that reads routes annotations from classes/resources
```php
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 /invoices
$router->addResource("Invoices", "/invoices");
return $router;
}
);
```
- `\stdClass`
- [`Phalcon\Di\AbstractInjectionAware`](/5.20/api/phalcon_di/#diabstractinjectionaware)
- [`Phalcon\Mvc\Router`](#mvcrouter)
- **`Phalcon\Mvc\Router\Annotations`**
`Phalcon\Annotations\Annotation` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\Router` · `Phalcon\Mvc\Router\Exceptions\AnnotationsServiceUnavailable` · `Phalcon\Mvc\Router\Exceptions\InvalidCallbackParameter`
### Method Summary
Adds a resource to the annotations handler
Adds a resource to the annotations handler
Return the registered resources
Produce the routing parameters from the rewrite information
Checks for annotations in the public methods of the controller
Checks for annotations in the controller docblock
Sets the action preformat callback
Changes the action method suffix
Changes the controller class suffix
### Properties
### Methods
addModuleResource()
```php
public function addModuleResource(
string $module,
string $handler,
string|null $prefix = null
): static;
```
Adds a resource to the annotations handler
A resource is a class that contains routing annotations
The class is located in a module
addResource()
```php
public function addResource(
string $handler,
string|null $prefix = null
): static;
```
Adds a resource to the annotations handler
A resource is a class that contains routing annotations
```php
public function getActionPreformatCallback();
```
getResources()
```php
public function getResources(): array;
```
Return the registered resources
handle()
```php
public function handle( string $uri ): void;
```
Produce the routing parameters from the rewrite information
processActionAnnotation()
```php
public function processActionAnnotation(
string $module,
string $namespaceName,
string $controller,
string $action,
Annotation $annotation
): void;
```
Checks for annotations in the public methods of the controller
processControllerAnnotation()
```php
public function processControllerAnnotation(
string $handler,
Annotation $annotation
);
```
Checks for annotations in the controller docblock
```php
public function setActionPreformatCallback( mixed $callback = null ): self;
```
Sets the action preformat callback
$action here already without suffix 'Action'
```php
// 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();
```
setActionSuffix()
```php
public function setActionSuffix( string $actionSuffix ): self;
```
Changes the action method suffix
setControllerSuffix()
```php
public function setControllerSuffix( string $controllerSuffix ): self;
```
Changes the controller class suffix
## Mvc\Router\Exception
Class
Phalcon\Mvc\Router\Exception
Exceptions thrown in Phalcon\Mvc\Router will use this class
- `\Exception`
- **`Phalcon\Mvc\Router\Exception`**
- [`Phalcon\Mvc\Router\Exceptions\AnnotationsServiceUnavailable`](#mvcrouterexceptionsannotationsserviceunavailable)
- [`Phalcon\Mvc\Router\Exceptions\BeforeMatchNotCallable`](#mvcrouterexceptionsbeforematchnotcallable)
- [`Phalcon\Mvc\Router\Exceptions\ConfigKeyMustBeArray`](#mvcrouterexceptionsconfigkeymustbearray)
- [`Phalcon\Mvc\Router\Exceptions\EmptyGroupOfRoutes`](#mvcrouterexceptionsemptygroupofroutes)
- [`Phalcon\Mvc\Router\Exceptions\GroupRoutesMustBeArray`](#mvcrouterexceptionsgrouproutesmustbearray)
- [`Phalcon\Mvc\Router\Exceptions\InvalidCallbackParameter`](#mvcrouterexceptionsinvalidcallbackparameter)
- [`Phalcon\Mvc\Router\Exceptions\InvalidConfigSource`](#mvcrouterexceptionsinvalidconfigsource)
- [`Phalcon\Mvc\Router\Exceptions\InvalidNotFoundPaths`](#mvcrouterexceptionsinvalidnotfoundpaths)
- [`Phalcon\Mvc\Router\Exceptions\InvalidRoutePaths`](#mvcrouterexceptionsinvalidroutepaths)
- [`Phalcon\Mvc\Router\Exceptions\InvalidRoutePosition`](#mvcrouterexceptionsinvalidrouteposition)
- [`Phalcon\Mvc\Router\Exceptions\InvalidRouterFactoryConfig`](#mvcrouterexceptionsinvalidrouterfactoryconfig)
- [`Phalcon\Mvc\Router\Exceptions\MissingGroupRouteKey`](#mvcrouterexceptionsmissinggrouproutekey)
- [`Phalcon\Mvc\Router\Exceptions\MissingRouteConfigKey`](#mvcrouterexceptionsmissingrouteconfigkey)
- [`Phalcon\Mvc\Router\Exceptions\RequestServiceUnavailable`](#mvcrouterexceptionsrequestserviceunavailable)
- [`Phalcon\Mvc\Router\Exceptions\UnknownHttpMethod`](#mvcrouterexceptionsunknownhttpmethod)
- [`Phalcon\Mvc\Router\Exceptions\WrongPathsKey`](#mvcrouterexceptionswrongpathskey)
## Mvc\Router\Exceptions\AnnotationsServiceUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\AnnotationsServiceUnavailable`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\BeforeMatchNotCallable
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\BeforeMatchNotCallable`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\ConfigKeyMustBeArray
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\ConfigKeyMustBeArray`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $key );
```
## Mvc\Router\Exceptions\EmptyGroupOfRoutes
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\EmptyGroupOfRoutes`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\GroupRoutesMustBeArray
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\GroupRoutesMustBeArray`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidCallbackParameter
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidCallbackParameter`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidConfigSource
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidConfigSource`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidNotFoundPaths
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidNotFoundPaths`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidRoutePaths
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidRoutePaths`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidRoutePosition
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidRoutePosition`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\InvalidRouterFactoryConfig
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\InvalidRouterFactoryConfig`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\MissingGroupRouteKey
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\MissingGroupRouteKey`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $key );
```
## Mvc\Router\Exceptions\MissingRouteConfigKey
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\MissingRouteConfigKey`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $key );
```
## Mvc\Router\Exceptions\RequestServiceUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\RequestServiceUnavailable`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Router\Exceptions\UnknownHttpMethod
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\UnknownHttpMethod`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $method );
```
## Mvc\Router\Exceptions\WrongPathsKey
Class
- `\Exception`
- [`Phalcon\Mvc\Router\Exception`](#mvcrouterexception)
- **`Phalcon\Mvc\Router\Exceptions\WrongPathsKey`**
`Phalcon\Mvc\Router\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $part );
```
## Mvc\Router\Group
Class
Helper class to create a group of routes with common attributes
```php
$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);
```
- **`Phalcon\Mvc\Router\Group`** - implements [`Phalcon\Mvc\Router\GroupInterface`](#mvcroutergroupinterface)
### Method Summary
Phalcon\Mvc\Router\Group constructor
Adds a route to the router on any HTTP method
Adds a route to the router that only match if the HTTP method is CONNECT
Adds a route to the router that only match if the HTTP method is DELETE
Adds a route to the router that only match if the HTTP method is GET
Adds a route to the router that only match if the HTTP method is HEAD
Add a route to the router that only match if the HTTP method is OPTIONS
Adds a route to the router that only match if the HTTP method is PATCH
Adds a route to the router that only match if the HTTP method is POST
Adds a route to the router that only match if the HTTP method is PURGE
Adds a route to the router that only match if the HTTP method is PUT
Adds a route to the router that only match if the HTTP method is TRACE
Sets a callback that is called if the route is matched.
Removes all the pre-defined routes
Returns the 'before match' callback if any
Returns the hostname restriction
Returns the common paths defined for this group
Returns the common prefix for all the routes
Returns the routes added to the group
Set a hostname restriction for all the routes in the group
Set common paths for all the routes in the group
Set a common uri prefix for all the routes in this group
Adds a route applying the common attributes
### Properties
### Methods
__construct()
```php
public function __construct( mixed $paths = null );
```
Phalcon\Mvc\Router\Group constructor
add()
```php
public function add(
string $pattern,
mixed $paths = null,
mixed $httpMethods = null
): RouteInterface;
```
Adds a route to the router on any HTTP method
```php
$router->add("/about", "About::index");
```
addConnect()
```php
public function addConnect(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is CONNECT
addDelete()
```php
public function addDelete(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is DELETE
addGet()
```php
public function addGet(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is GET
addHead()
```php
public function addHead(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is HEAD
addOptions()
```php
public function addOptions(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Add a route to the router that only match if the HTTP method is OPTIONS
addPatch()
```php
public function addPatch(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PATCH
addPost()
```php
public function addPost(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is POST
addPurge()
```php
public function addPurge(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PURGE
addPut()
```php
public function addPut(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PUT
addTrace()
```php
public function addTrace(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is TRACE
beforeMatch()
```php
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
clear()
```php
public function clear(): void;
```
Removes all the pre-defined routes
getBeforeMatch()
```php
public function getBeforeMatch(): callable|null;
```
Returns the 'before match' callback if any
getHostname()
```php
public function getHostname(): string|null;
```
Returns the hostname restriction
getPaths()
```php
public function getPaths(): array|string|null;
```
Returns the common paths defined for this group
getPrefix()
```php
public function getPrefix(): string|null;
```
Returns the common prefix for all the routes
getRoutes()
```php
public function getRoutes(): RouteInterface[];
```
Returns the routes added to the group
setHostname()
```php
public function setHostname( string $hostname ): GroupInterface;
```
Set a hostname restriction for all the routes in the group
setPaths()
```php
public function setPaths( mixed $paths ): GroupInterface;
```
Set common paths for all the routes in the group
setPrefix()
```php
public function setPrefix( string $prefix ): GroupInterface;
```
Set a common uri prefix for all the routes in this group
addRoute()
```php
protected function addRoute(
string $pattern,
mixed $paths = null,
mixed $httpMethods = null
): RouteInterface;
```
Adds a route applying the common attributes
## Mvc\Router\GroupInterface
Interface
```php
$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);
```
- **`Phalcon\Mvc\Router\GroupInterface`**
### Method Summary
Adds a route to the router on any HTTP method
Adds a route to the router that only match if the HTTP method is CONNECT
Adds a route to the router that only match if the HTTP method is DELETE
Adds a route to the router that only match if the HTTP method is GET
Adds a route to the router that only match if the HTTP method is HEAD
Add a route to the router that only match if the HTTP method is OPTIONS
Adds a route to the router that only match if the HTTP method is PATCH
Adds a route to the router that only match if the HTTP method is POST
Adds a route to the router that only match if the HTTP method is PURGE
Adds a route to the router that only match if the HTTP method is PUT
Adds a route to the router that only match if the HTTP method is TRACE
Sets a callback that is called if the route is matched.
Removes all the pre-defined routes
Returns the 'before match' callback if any
Returns the hostname restriction
Returns the common paths defined for this group
Returns the common prefix for all the routes
Returns the routes added to the group
Set a hostname restriction for all the routes in the group
Set common paths for all the routes in the group
Set a common uri prefix for all the routes in this group
### Methods
add()
```php
public function add(
string $pattern,
mixed $paths = null,
mixed $httpMethods = null
): RouteInterface;
```
Adds a route to the router on any HTTP method
```php
router->add("/about", "About::index");
```
addConnect()
```php
public function addConnect(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is CONNECT
addDelete()
```php
public function addDelete(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is DELETE
addGet()
```php
public function addGet(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is GET
addHead()
```php
public function addHead(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is HEAD
addOptions()
```php
public function addOptions(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Add a route to the router that only match if the HTTP method is OPTIONS
addPatch()
```php
public function addPatch(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PATCH
addPost()
```php
public function addPost(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is POST
addPurge()
```php
public function addPurge(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PURGE
addPut()
```php
public function addPut(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is PUT
addTrace()
```php
public function addTrace(
string $pattern,
mixed $paths = null
): RouteInterface;
```
Adds a route to the router that only match if the HTTP method is TRACE
beforeMatch()
```php
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
clear()
```php
public function clear(): void;
```
Removes all the pre-defined routes
getBeforeMatch()
```php
public function getBeforeMatch(): callable|null;
```
Returns the 'before match' callback if any
getHostname()
```php
public function getHostname(): string|null;
```
Returns the hostname restriction
getPaths()
```php
public function getPaths(): array|string|null;
```
Returns the common paths defined for this group
getPrefix()
```php
public function getPrefix(): string|null;
```
Returns the common prefix for all the routes
getRoutes()
```php
public function getRoutes(): RouteInterface[];
```
Returns the routes added to the group
setHostname()
```php
public function setHostname( string $hostname ): GroupInterface;
```
Set a hostname restriction for all the routes in the group
setPaths()
```php
public function setPaths( mixed $paths ): GroupInterface;
```
Set common paths for all the routes in the group
setPrefix()
```php
public function setPrefix( string $prefix ): GroupInterface;
```
Set a common uri prefix for all the routes in this group
## Mvc\Router\Route
Class
This class represents every route added to the router
- **`Phalcon\Mvc\Router\Route`** - implements [`Phalcon\Mvc\Router\RouteInterface`](#mvcrouterrouteinterface)
`Phalcon\Mvc\Router\Exceptions\InvalidRoutePaths`
### Method Summary
Phalcon\Mvc\Router\Route constructor
Sets a callback that is called if the route is matched.
Replaces placeholders from pattern returning a valid PCRE regular expression
\{@inheritdoc\}
Extracts parameters from a string
Returns the 'before match' callback if any
Returns the compiled hostname regex, or null when the hostname is
Returns the route's compiled pattern
Returns the router converter
Returns the group associated with the route
Returns the hostname restriction if any
Returns the HTTP methods that constraint matching the route
Returns the 'match' callback if any
Returns the route's name
Returns the paths
Returns the route's pattern
Returns the paths using positions as keys and names as values
Returns the route's id
Returns routePaths
Allows to set a callback to handle the request directly in the route
Reconfigure the route adding a new pattern and a set of paths
Resets the internal route id generator
Sets the group associated with the route
Sets a hostname restriction to the route
Sets a set of HTTP methods that constraint the matching of the route (alias of via)
Sets the route's name
Sets the route's id. Intended for restoring cached routes - most
Set one or more HTTP methods that constraint the matching of the route
### Properties
Cached compiled hostname regex. `false` means "not yet computed";
`null` means "hostname is literal - use string equality"; any string
means "use this as the PCRE pattern."
### Methods
__construct()
```php
public function __construct(
string $pattern,
mixed $paths = null,
mixed $httpMethods = null
);
```
Phalcon\Mvc\Router\Route constructor
beforeMatch()
```php
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
```php
$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;
}
);
```
compilePattern()
```php
public function compilePattern( string $pattern ): string;
```
Replaces placeholders from pattern returning a valid PCRE regular expression
convert()
```php
public function convert(
string $name,
mixed $converter
): RouteInterface;
```
\{@inheritdoc\}
```php
public function extractNamedParams( string $pattern ): array|bool;
```
Extracts parameters from a string
getBeforeMatch()
```php
public function getBeforeMatch(): callable|null;
```
Returns the 'before match' callback if any
getCompiledHostName()
```php
public function getCompiledHostName(): string|null;
```
Returns the compiled hostname regex, or null when the hostname is
literal and a string-equality comparison should be used.
The result is cached after first computation; setHostname() clears
the cache.
getCompiledPattern()
```php
public function getCompiledPattern(): string;
```
Returns the route's compiled pattern
getConverters()
```php
public function getConverters(): array;
```
Returns the router converter
getGroup()
```php
public function getGroup(): GroupInterface|null;
```
Returns the group associated with the route
getHostname()
```php
public function getHostname(): string|null;
```
Returns the hostname restriction if any
getHttpMethods()
```php
public function getHttpMethods(): array|string|null;
```
Returns the HTTP methods that constraint matching the route
getMatch()
```php
public function getMatch(): callable|null;
```
Returns the 'match' callback if any
getName()
```php
public function getName(): string|null;
```
Returns the route's name
getPaths()
```php
public function getPaths(): array;
```
Returns the paths
getPattern()
```php
public function getPattern(): string;
```
Returns the route's pattern
getReversedPaths()
```php
public function getReversedPaths(): array;
```
Returns the paths using positions as keys and names as values
getRouteId()
```php
public function getRouteId(): string;
```
Returns the route's id
getRoutePaths()
```php
public static function getRoutePaths( mixed $paths = null ): array;
```
Returns routePaths
match()
```php
public function match( mixed $callback ): RouteInterface;
```
Allows to set a callback to handle the request directly in the route
```php
$router->add(
"/help",
[]
)->match(
function () {
return $this->getResponse()->redirect("https://support.google.com/", true);
}
);
```
```php
public function reConfigure(
string $pattern,
mixed $paths = null
): void;
```
Reconfigure the route adding a new pattern and a set of paths
reset()
```php
public static function reset(): void;
```
Resets the internal route id generator
setGroup()
```php
public function setGroup( GroupInterface $group ): RouteInterface;
```
Sets the group associated with the route
setHostname()
```php
public function setHostname( string $hostname ): RouteInterface;
```
Sets a hostname restriction to the route
```php
$route->setHostname("localhost");
```
setHttpMethods()
```php
public function setHttpMethods( mixed $httpMethods ): RouteInterface;
```
Sets a set of HTTP methods that constraint the matching of the route (alias of via)
```php
$route->setHttpMethods("GET");
$route->setHttpMethods(
[
"GET",
"POST",
]
);
```
setName()
```php
public function setName( string $name ): RouteInterface;
```
Sets the route's name
```php
$router->add(
"/about",
[
"controller" => "about",
]
)->setName("about");
```
setRouteId()
```php
public function setRouteId( string $routeId ): RouteInterface;
```
Sets the route's id. Intended for restoring cached routes - most
applications should rely on the auto-incrementing id assigned by
the constructor.
via()
```php
public function via( mixed $httpMethods ): RouteInterface;
```
Set one or more HTTP methods that constraint the matching of the route
```php
$route->via("GET");
$route->via(
[
"GET",
"POST",
]
);
```
## Mvc\Router\RouteInterface
Interface
Interface for Phalcon\Mvc\Router\Route
- **`Phalcon\Mvc\Router\RouteInterface`**
### Method Summary
Replaces placeholders from pattern returning a valid PCRE regular expression
Adds a converter to perform an additional transformation for certain parameter.
Returns the route's pattern
Returns the hostname restriction if any
Returns the HTTP methods that constraint matching the route
Returns the route's name
Returns the paths
Returns the route's pattern
Returns the paths using positions as keys and names as values
Returns the route's id
Reconfigure the route adding a new pattern and a set of paths
Resets the internal route id generator
Sets a hostname restriction to the route
Sets a set of HTTP methods that constraint the matching of the route
Sets the route's name
Sets the route's id (intended for restoring cached routes)
Set one or more HTTP methods that constraint the matching of the route
### Methods
compilePattern()
```php
public function compilePattern( string $pattern ): string;
```
Replaces placeholders from pattern returning a valid PCRE regular expression
convert()
```php
public function convert(
string $name,
mixed $converter
): RouteInterface;
```
Adds a converter to perform an additional transformation for certain parameter.
getCompiledPattern()
```php
public function getCompiledPattern(): string;
```
Returns the route's pattern
getHostname()
```php
public function getHostname(): string|null;
```
Returns the hostname restriction if any
getHttpMethods()
```php
public function getHttpMethods(): array|string|null;
```
Returns the HTTP methods that constraint matching the route
getName()
```php
public function getName(): string|null;
```
Returns the route's name
getPaths()
```php
public function getPaths(): array;
```
Returns the paths
getPattern()
```php
public function getPattern(): string;
```
Returns the route's pattern
getReversedPaths()
```php
public function getReversedPaths(): array;
```
Returns the paths using positions as keys and names as values
getRouteId()
```php
public function getRouteId(): string;
```
Returns the route's id
```php
public function reConfigure(
string $pattern,
mixed $paths = null
): void;
```
Reconfigure the route adding a new pattern and a set of paths
reset()
```php
public static function reset(): void;
```
Resets the internal route id generator
setHostname()
```php
public function setHostname( string $hostname ): RouteInterface;
```
Sets a hostname restriction to the route
setHttpMethods()
```php
public function setHttpMethods( mixed $httpMethods ): RouteInterface;
```
Sets a set of HTTP methods that constraint the matching of the route
setName()
```php
public function setName( string $name ): RouteInterface;
```
Sets the route's name
setRouteId()
```php
public function setRouteId( string $routeId ): RouteInterface;
```
Sets the route's id (intended for restoring cached routes)
via()
```php
public function via( mixed $httpMethods ): RouteInterface;
```
Set one or more HTTP methods that constraint the matching of the route
## Mvc\Router\RouterFactory
Class
Phalcon\Mvc\Router\RouterFactory
Builds a Router from an array or ConfigInterface and loads routes via
Router::loadFromConfig.
```php
use Phalcon\Mvc\Router\RouterFactory;
$router = (new RouterFactory())->load(
[
"defaultRoutes" : false,
"routes" : [
["method" : "get", "pattern" : "/users", "paths" : "Users::index"]
]
]
);
```
- **`Phalcon\Mvc\Router\RouterFactory`**
`Phalcon\Config\ConfigInterface` · `Phalcon\Mvc\Router` · `Phalcon\Mvc\RouterInterface` · `Phalcon\Mvc\Router\Exceptions\InvalidRouterFactoryConfig`
### Method Summary
Builds a Router from a config array or ConfigInterface and loads routes.
Returns a bare Router instance.
### Methods
load()
```php
public function load( mixed $config ): RouterInterface;
```
Builds a Router from a config array or ConfigInterface and loads routes.
newInstance()
```php
public function newInstance( bool $defaultRoutes = true ): RouterInterface;
```
Returns a bare Router instance.
## Mvc\Url
Class
This component helps in the generation of: URIs, URLs and Paths
```php
// 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",
]
);
```
- `\stdClass`
- [`Phalcon\Di\AbstractInjectionAware`](/5.20/api/phalcon_di/#diabstractinjectionaware)
- **`Phalcon\Mvc\Url`** - implements [`Phalcon\Mvc\Url\UrlInterface`](#mvcurlurlinterface)
`Phalcon\Di\AbstractInjectionAware` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\RouterInterface` · `Phalcon\Mvc\Router\RouteInterface` · `Phalcon\Mvc\Url\Exception` · `Phalcon\Mvc\Url\Exceptions\MissingRouteName` · `Phalcon\Mvc\Url\Exceptions\RouteNotFound` · `Phalcon\Mvc\Url\Exceptions\RouterServiceUnavailable` · `Phalcon\Mvc\Url\UrlInterface` · `Phalcon\Support\Helper\Str\ReduceSlashes`
### Method Summary
Generates a URL
Returns the base path
Returns the prefix for all the generated urls. By default /
Generates a URL for a static resource
Returns the prefix for all the generated static urls. By default /
Generates a local path
Sets a base path for all the generated paths
Sets a prefix for all the URIs to be generated
Sets a prefix for all static URLs generated
### Properties
### Methods
__construct()
```php
public function __construct( RouterInterface|null $router = null );
```
get()
```php
public function get(
mixed $uri = null,
mixed $arguments = null,
bool|null $local = null,
mixed $baseUri = null,
bool $replaceArgs = false
): string;
```
Generates a URL
```php
// 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",
]
);
// A URI that already carries a scheme is detected as remote and is
// returned untouched. The third parameter is only honored when it is
// explicitly true - a false reads the same as leaving it out.
echo $url->get(
"https://phalcon.io/",
null,
false
);
// Override existing query string keys instead of appending duplicates.
// Without the fifth argument: "http://example.com?page=1&page=5".
// With it set to true: "http://example.com?page=5".
echo $url->get(
"http://example.com?page=1",
["page" => 5],
null,
null,
true
);
```
getBasePath()
```php
public function getBasePath(): string|null;
```
Returns the base path
getBaseUri()
```php
public function getBaseUri(): string;
```
Returns the prefix for all the generated urls. By default /
getStatic()
```php
public function getStatic( mixed $uri = null ): string;
```
Generates a URL for a static resource
```php
// 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",
]
);
```
getStaticBaseUri()
```php
public function getStaticBaseUri(): string;
```
Returns the prefix for all the generated static urls. By default /
path()
```php
public function path( string|null $path = null ): string;
```
Generates a local path
setBasePath()
```php
public function setBasePath( string $basePath ): UrlInterface;
```
Sets a base path for all the generated paths
```php
$url->setBasePath("/var/www/htdocs/");
```
setBaseUri()
```php
public function setBaseUri( string $baseUri ): UrlInterface;
```
Sets a prefix for all the URIs to be generated
```php
$url->setBaseUri("/invo/");
$url->setBaseUri("/invo/index.php/");
```
setStaticBaseUri()
```php
public function setStaticBaseUri( string $staticBaseUri ): UrlInterface;
```
Sets a prefix for all static URLs generated
```php
$url->setStaticBaseUri("/invo/");
```
## Mvc\Url\Exception
Class
Phalcon\Mvc\Url\Exception
Exceptions thrown in Phalcon\Mvc\Url will use this class
- `\Exception`
- **`Phalcon\Mvc\Url\Exception`**
- [`Phalcon\Mvc\Url\Exceptions\MissingRouteName`](#mvcurlexceptionsmissingroutename)
- [`Phalcon\Mvc\Url\Exceptions\RouteNotFound`](#mvcurlexceptionsroutenotfound)
- [`Phalcon\Mvc\Url\Exceptions\RouterServiceUnavailable`](#mvcurlexceptionsrouterserviceunavailable)
## Mvc\Url\Exceptions\MissingRouteName
Class
- `\Exception`
- [`Phalcon\Mvc\Url\Exception`](#mvcurlexception)
- **`Phalcon\Mvc\Url\Exceptions\MissingRouteName`**
`Phalcon\Mvc\Url\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Url\Exceptions\RouteNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\Url\Exception`](#mvcurlexception)
- **`Phalcon\Mvc\Url\Exceptions\RouteNotFound`**
`Phalcon\Mvc\Url\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\Url\Exceptions\RouterServiceUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\Url\Exception`](#mvcurlexception)
- **`Phalcon\Mvc\Url\Exceptions\RouterServiceUnavailable`**
`Phalcon\Mvc\Url\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\Url\UrlInterface
Interface
Interface for Phalcon\Mvc\Url\UrlInterface
- **`Phalcon\Mvc\Url\UrlInterface`**
### Method Summary
Generates a URL
Returns a base path
Returns the prefix for all the generated urls. By default /
Generates a local path
Sets a base paths for all the generated paths
Sets a prefix to all the urls generated
### Methods
get()
```php
public function get(
mixed $uri = null,
mixed $arguments = null,
bool|null $local = null,
mixed $baseUri = null,
bool $replaceArgs = false
): string;
```
Generates a URL
getBasePath()
```php
public function getBasePath(): string|null;
```
Returns a base path
getBaseUri()
```php
public function getBaseUri(): string;
```
Returns the prefix for all the generated urls. By default /
path()
```php
public function path( string|null $path = null ): string;
```
Generates a local path
setBasePath()
```php
public function setBasePath( string $basePath ): UrlInterface;
```
Sets a base paths for all the generated paths
setBaseUri()
```php
public function setBaseUri( string $baseUri ): UrlInterface;
```
Sets a prefix to all the urls generated
## Mvc\View
Class
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.
```php
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();
```
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Mvc\View`** - implements [`Phalcon\Mvc\ViewInterface`](#mvcviewinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
`Closure` · `Phalcon\Di\DiInterface` · `Phalcon\Di\Injectable` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Mvc\View\Engine\Php` · `Phalcon\Mvc\View\Exception` · `Phalcon\Mvc\View\Exceptions\InvalidEngineRegistration` · `Phalcon\Mvc\View\Exceptions\InvalidViewsDirType` · `Phalcon\Mvc\View\Exceptions\ViewNotFound` · `Phalcon\Mvc\View\Exceptions\ViewServicesUnavailable` · `Phalcon\Mvc\View\Exceptions\ViewsDirItemMustBeString` · `Phalcon\Mvc\View\Traits\ViewParamsTrait` · `Phalcon\Traits\Php\FileTrait` · `Phalcon\Traits\Support\Helper\Str\DirSeparatorTrait`
### Method Summary
Phalcon\Mvc\View constructor
Magic method to retrieve a variable passed to the view
Magic method to retrieve if a variable is set in the view
Magic method to pass variables to the views
Resets any template before layouts
Resets any "template before" layouts
Disables the auto-rendering process
Disables a specific level of rendering
Enables the auto-rendering process
Checks whether view exists
Finishes the render process by stopping the output buffering
Gets the name of the action rendered
Returns the path (or paths) of the views that are currently rendered
Gets base path
Gets the name of the controller rendered
Returns the internal event manager
Returns the name of the main view
Gets the current layouts sub-directory
Returns the name of the main view
Renders a partial view
Gets the current partials sub-directory
Perform the automatic rendering returning the output as a string
Gets views directory
Checks whether view exists
Whether automatic rendering is enabled
Renders a partial view
Choose a different view to render instead of last-controller/last-action
Processes the view and templates; Fires events if needed
Register templating engines
Executes render process from dispatching data
Resets the view component to its factory default values
Sets base path. Depending of your platform, always add a trailing slash
Sets the events manager
Change the layout to be used instead of using the name of the latest
Sets the layouts sub-directory. Must be a directory under the views
Sets default view name. Must be a file without extension in the views
Adds parameters to views (alias of setVar)
Sets a partials sub-directory. Must be a directory under the views
Sets the render level for the view
Sets a "template after" controller layout
Sets a template before the controller layout
Set all the render params
Sets the views directory. Depending of your platform,
Starts rendering process enabling the output buffering
Renders the view and returns it as a string
Checks whether view exists on registered extensions and render it
Gets views directories
Checks if a path is absolute or not
Loads registered template engines, if none is registered it will use
### Constants
Render Level: To the action view
Render Level: Render to the templates "after"
Render Level: To the templates "before"
Render Level: To the controller layout
Render Level: To the main layout
Render Level: No render any view
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Phalcon\Mvc\View constructor
__get()
```php
public function __get( string $key ): mixed|null;
```
Magic method to retrieve a variable passed to the view
```php
echo $this->view->products;
```
__isset()
```php
public function __isset( string $key ): bool;
```
Magic method to retrieve if a variable is set in the view
```php
echo isset($this->view->products);
```
__set()
```php
public function __set(
string $key,
mixed $value
);
```
Magic method to pass variables to the views
```php
$this->view->products = $products;
```
cleanTemplateAfter()
```php
public function cleanTemplateAfter(): static;
```
Resets any template before layouts
cleanTemplateBefore()
```php
public function cleanTemplateBefore(): static;
```
Resets any "template before" layouts
disable()
```php
public function disable(): static;
```
Disables the auto-rendering process
disableLevel()
```php
public function disableLevel( mixed $level ): static;
```
Disables a specific level of rendering
```php
// Render all levels except ACTION level
$this->view->disableLevel(
View::LEVEL_ACTION_VIEW
);
```
enable()
```php
public function enable(): static;
```
Enables the auto-rendering process
exists()
```php
public function exists( string $view ): bool;
```
Checks whether view exists
finish()
```php
public function finish(): static;
```
Finishes the render process by stopping the output buffering
getActionName()
```php
public function getActionName(): string;
```
Gets the name of the action rendered
getActiveRenderPath()
```php
public function getActiveRenderPath(): string|array;
```
Returns the path (or paths) of the views that are currently rendered
getBasePath()
```php
public function getBasePath(): string;
```
Gets base path
getControllerName()
```php
public function getControllerName(): string;
```
Gets the name of the controller rendered
getCurrentRenderLevel()
```php
public function getCurrentRenderLevel(): int;
```
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getLayout()
```php
public function getLayout(): string|null;
```
Returns the name of the main view
getLayoutsDir()
```php
public function getLayoutsDir(): string;
```
Gets the current layouts sub-directory
getMainView()
```php
public function getMainView(): string;
```
Returns the name of the main view
getPartial()
```php
public function getPartial(
string $partialPath,
mixed $params = null
): string;
```
Renders a partial view
```php
// Retrieve the contents of a partial
echo $this->getPartial("shared/footer");
```
```php
// Retrieve the contents of a partial with arguments
echo $this->getPartial(
"shared/footer",
[
"content" => $html,
]
);
```
getPartialsDir()
```php
public function getPartialsDir(): string;
```
Gets the current partials sub-directory
getRender()
```php
public function getRender(
string $controllerName,
string $actionName,
array $params = [],
mixed $configCallback = null
): string;
```
Perform the automatic rendering returning the output as a string
```php
$template = $this->view->getRender(
"products",
"show",
[
"products" => $products,
]
);
```
getRenderLevel()
```php
public function getRenderLevel(): int;
```
getViewsDir()
```php
public function getViewsDir(): string|array;
```
Gets views directory
has()
```php
public function has( string $view ): bool;
```
Checks whether view exists
isDisabled()
```php
public function isDisabled(): bool;
```
Whether automatic rendering is enabled
partial()
```php
public function partial(
string $partialPath,
mixed $params = null
);
```
Renders a partial view
```php
// Show a partial inside another view
$this->partial("shared/footer");
```
```php
// Show a partial inside another view with parameters
$this->partial(
"shared/footer",
[
"content" => $html,
]
);
```
pick()
```php
public function pick( mixed $renderView ): static;
```
Choose a different view to render instead of last-controller/last-action
```php
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");
}
}
```
processRender()
```php
public function processRender(
string $controllerName,
string $actionName,
array $params = [],
bool $fireEvents = true
): bool;
```
Processes the view and templates; Fires events if needed
registerEngines()
```php
public function registerEngines( array $engines ): static;
```
Register templating engines
```php
$this->view->registerEngines(
[
".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
".volt" => \Phalcon\Mvc\View\Engine\Volt::class,
".mhtml" => \MyCustomEngine::class,
]
);
```
render()
```php
public function render(
string $controllerName,
string $actionName,
array $params = []
): static|false;
```
Executes render process from dispatching data
```php
// Shows recent posts view (app/views/posts/recent.phtml)
$view->start()->render("posts", "recent")->finish();
```
reset()
```php
public function reset(): static;
```
Resets the view component to its factory default values
setBasePath()
```php
public function setBasePath( string $basePath ): static;
```
Sets base path. Depending of your platform, always add a trailing slash
or backslash
```php
$view->setBasePath(__DIR__ . "/");
```
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
setLayout()
```php
public function setLayout( string $layout ): static;
```
Change the layout to be used instead of using the name of the latest
controller name
```php
$this->view->setLayout("main");
```
setLayoutsDir()
```php
public function setLayoutsDir( string $layoutsDir ): static;
```
Sets the layouts sub-directory. Must be a directory under the views
directory. Depending of your platform, always add a trailing slash or
backslash
```php
$view->setLayoutsDir("../common/layouts/");
```
setMainView()
```php
public function setMainView( string $viewPath ): static;
```
Sets default view name. Must be a file without extension in the views
directory
```php
// Renders as main view views-dir/base.phtml
$this->view->setMainView("base");
```
setParamToView()
```php
public function setParamToView(
string $key,
mixed $value
): static;
```
Adds parameters to views (alias of setVar)
```php
$this->view->setParamToView("products", $products);
```
setPartialsDir()
```php
public function setPartialsDir( string $partialsDir ): static;
```
Sets a partials sub-directory. Must be a directory under the views
directory. Depending of your platform, always add a trailing slash or
backslash
```php
$view->setPartialsDir("../common/partials/");
```
setRenderLevel()
```php
public function setRenderLevel( int $level ): static;
```
Sets the render level for the view
```php
// Render the view related to the controller only
$this->view->setRenderLevel(
View::LEVEL_LAYOUT
);
```
setTemplateAfter()
```php
public function setTemplateAfter( mixed $templateAfter ): static;
```
Sets a "template after" controller layout
setTemplateBefore()
```php
public function setTemplateBefore( mixed $templateBefore ): static;
```
Sets a template before the controller layout
setVars()
```php
public function setVars(
array $params,
bool $merge = true
): static;
```
Set all the render params
```php
$this->view->setVars(
[
"products" => $products,
]
);
```
setViewsDir()
```php
public function setViewsDir( mixed $viewsDir ): static;
```
Sets the views directory. Depending of your platform,
always add a trailing slash or backslash
start()
```php
public function start(): static;
```
Starts rendering process enabling the output buffering
toString()
```php
public function toString(
string $controllerName,
string $actionName,
array $params = []
): string;
```
Renders the view and returns it as a string
engineRender()
```php
protected function engineRender(
array $engines,
string $viewPath,
bool $silence,
bool $mustClean = true
);
```
Checks whether view exists on registered extensions and render it
getViewsDirs()
```php
protected function getViewsDirs(): array;
```
Gets views directories
isAbsolutePath()
```php
final protected function isAbsolutePath( string $path );
```
Checks if a path is absolute or not
loadTemplateEngines()
```php
protected function loadTemplateEngines(): array;
```
Loads registered template engines, if none is registered it will use
Phalcon\Mvc\View\Engine\Php
## Mvc\ViewBaseInterface
Interface
Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple
- **`Phalcon\Mvc\ViewBaseInterface`**
- [`Phalcon\Mvc\ViewInterface`](#mvcviewinterface)
`Phalcon\Cache\Adapter\AdapterInterface`
### Method Summary
Returns cached output from another view stage
Returns parameters to views
Gets views directory
Renders a partial view
Externally sets the view content
Adds parameters to views (alias of setVar)
Adds parameters to views
Sets views directory. Depending of your platform, always add a trailing
### Methods
getContent()
```php
public function getContent(): string;
```
Returns cached output from another view stage
getParamsToView()
```php
public function getParamsToView(): array;
```
Returns parameters to views
getViewsDir()
```php
public function getViewsDir(): string|array;
```
Gets views directory
partial()
```php
public function partial(
string $partialPath,
mixed $params = null
);
```
Renders a partial view
setContent()
```php
public function setContent( string $content );
```
Externally sets the view content
setParamToView()
```php
public function setParamToView(
string $key,
mixed $value
);
```
Adds parameters to views (alias of setVar)
setVar()
```php
public function setVar(
string $key,
mixed $value
);
```
Adds parameters to views
setViewsDir()
```php
public function setViewsDir( string $viewsDir );
```
Sets views directory. Depending of your platform, always add a trailing
slash or backslash
## Mvc\ViewInterface
Interface
Interface for Phalcon\Mvc\View
- [`Phalcon\Mvc\ViewBaseInterface`](#mvcviewbaseinterface)
- **`Phalcon\Mvc\ViewInterface`**
### Method Summary
Resets any template before layouts
Resets any template before layouts
Disables the auto-rendering process
Enables the auto-rendering process
Finishes the render process by stopping the output buffering
Gets the name of the action rendered
Returns the path of the view that is currently rendered
Gets base path
Gets the name of the controller rendered
Returns the name of the main view
Gets the current layouts sub-directory
Returns the name of the main view
Gets the current partials sub-directory
Whether the automatic rendering is disabled
Choose a view different to render than last-controller/last-action
Register templating engines
Executes render process from dispatching data
Resets the view component to its factory default values
Sets base path. Depending of your platform, always add a trailing slash
Change the layout to be used instead of using the name of the latest
Sets the layouts sub-directory. Must be a directory under the views
Sets default view name. Must be a file without extension in the views
Sets a partials sub-directory. Must be a directory under the views
Sets the render level for the view
Appends template after controller layout
Appends template before controller layout
Starts rendering process enabling the output buffering
### Methods
cleanTemplateAfter()
```php
public function cleanTemplateAfter();
```
Resets any template before layouts
cleanTemplateBefore()
```php
public function cleanTemplateBefore();
```
Resets any template before layouts
disable()
```php
public function disable();
```
Disables the auto-rendering process
enable()
```php
public function enable();
```
Enables the auto-rendering process
finish()
```php
public function finish();
```
Finishes the render process by stopping the output buffering
getActionName()
```php
public function getActionName(): string;
```
Gets the name of the action rendered
getActiveRenderPath()
```php
public function getActiveRenderPath(): string|array;
```
Returns the path of the view that is currently rendered
getBasePath()
```php
public function getBasePath(): string;
```
Gets base path
getControllerName()
```php
public function getControllerName(): string;
```
Gets the name of the controller rendered
getLayout()
```php
public function getLayout(): string|null;
```
Returns the name of the main view
getLayoutsDir()
```php
public function getLayoutsDir(): string;
```
Gets the current layouts sub-directory
getMainView()
```php
public function getMainView(): string;
```
Returns the name of the main view
getPartialsDir()
```php
public function getPartialsDir(): string;
```
Gets the current partials sub-directory
isDisabled()
```php
public function isDisabled(): bool;
```
Whether the automatic rendering is disabled
pick()
```php
public function pick( string $renderView );
```
Choose a view different to render than last-controller/last-action
registerEngines()
```php
public function registerEngines( array $engines );
```
Register templating engines
render()
```php
public function render(
string $controllerName,
string $actionName,
array $params = []
): ViewInterface|bool;
```
Executes render process from dispatching data
reset()
```php
public function reset();
```
Resets the view component to its factory default values
setBasePath()
```php
public function setBasePath( string $basePath );
```
Sets base path. Depending of your platform, always add a trailing slash
or backslash
setLayout()
```php
public function setLayout( string $layout );
```
Change the layout to be used instead of using the name of the latest
controller name
setLayoutsDir()
```php
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
setMainView()
```php
public function setMainView( string $viewPath );
```
Sets default view name. Must be a file without extension in the views
directory
setPartialsDir()
```php
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
setRenderLevel()
```php
public function setRenderLevel( int $level ): ViewInterface;
```
Sets the render level for the view
setTemplateAfter()
```php
public function setTemplateAfter( mixed $templateAfter );
```
Appends template after controller layout
setTemplateBefore()
```php
public function setTemplateBefore( mixed $templateBefore );
```
Appends template before controller layout
start()
```php
public function start();
```
Starts rendering process enabling the output buffering
## Mvc\View\Engine\AbstractEngine
Abstract
All the template engine adapters must inherit this class. This provides
basic interfacing between the engine and the Phalcon\Mvc\View component.
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Mvc\View\Engine\AbstractEngine`** - implements [`Phalcon\Mvc\View\Engine\EngineInterface`](#mvcviewengineengineinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
- [`Phalcon\Mvc\View\Engine\Php`](#mvcviewenginephp)
- [`Phalcon\Mvc\View\Engine\Volt`](#mvcviewenginevolt)
`Phalcon\Di\DiInterface` · `Phalcon\Di\Injectable` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Mvc\ViewBaseInterface`
### Method Summary
Phalcon\Mvc\View\Engine constructor
Returns cached output on another view stage
Returns the internal event manager
Returns the view component related to the adapter
Renders a partial inside another view
Sets the events manager
Helper method to fire an event
### Properties
### Methods
__construct()
```php
public function __construct(
ViewBaseInterface $view,
DiInterface|null $container = null
);
```
Phalcon\Mvc\View\Engine constructor
getContent()
```php
public function getContent(): string;
```
Returns cached output on another view stage
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getView()
```php
public function getView(): ViewBaseInterface;
```
Returns the view component related to the adapter
partial()
```php
public function partial(
string $partialPath,
mixed $params = null
): void;
```
Renders a partial inside another view
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
fireManagerEvent()
```php
protected function fireManagerEvent(
string $eventName,
mixed $data = null,
bool $cancellable = true
): mixed|bool;
```
Helper method to fire an event
## Mvc\View\Engine\EngineInterface
Interface
Interface for Phalcon\Mvc\View engine adapters
- **`Phalcon\Mvc\View\Engine\EngineInterface`**
### Method Summary
Returns cached output on another view stage
Renders a partial inside another view
Renders a view using the template engine
### Methods
getContent()
```php
public function getContent(): string;
```
Returns cached output on another view stage
partial()
```php
public function partial(
string $partialPath,
mixed $params = null
): void;
```
Renders a partial inside another view
render()
```php
public function render(
string $path,
mixed $params,
bool $mustClean = false
);
```
Renders a view using the template engine
TODO: Change params to array type
## Mvc\View\Engine\Php
Class
Adapter to use PHP itself as templating engine
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- [`Phalcon\Mvc\View\Engine\AbstractEngine`](#mvcviewengineabstractengine)
- **`Phalcon\Mvc\View\Engine\Php`**
### Method Summary
Renders a view using the template engine
### Methods
render()
```php
public function render(
string $path,
mixed $params,
bool $mustClean = false
);
```
Renders a view using the template engine
## Mvc\View\Engine\Volt
Class
Designer friendly and fast template engine for PHP written in Zephir/C
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- [`Phalcon\Mvc\View\Engine\AbstractEngine`](#mvcviewengineabstractengine)
- **`Phalcon\Mvc\View\Engine\Volt`** - implements [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface)
`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\Engine\Volt\Exceptions\InvalidHaystack` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroNotFound` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\MbstringRequired` · `Phalcon\Mvc\View\Exception` · `Phalcon\Traits\Php\InfoTrait`
### Method Summary
Checks if a macro is defined and calls it
Performs a string conversion
Returns the Volt's compiler
Returns the internal event manager
Return Volt's options
Checks if the needle is included in the haystack
Length filter. If an array/object is passed a count is performed otherwise a strlen/mb_strlen
Parses the preload element passed and sets the necessary link headers
Renders a view using the template engine
Sets the events manager
Set Volt's options
Extracts a slice from a string/array/traversable object value
Sorts an array
### Properties
### Methods
callMacro()
```php
public function callMacro(
string $name,
array $arguments = []
): mixed;
```
Checks if a macro is defined and calls it
@params string name
@params array arguments
convertEncoding()
```php
public function convertEncoding(
string $text,
string $from,
string $to
): string;
```
Performs a string conversion
getCompiler()
```php
public function getCompiler(): Compiler;
```
Returns the Volt's compiler
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getOptions()
```php
public function getOptions(): array;
```
Return Volt's options
isIncluded()
```php
public function isIncluded(
mixed $needle,
mixed $haystack
): bool;
```
Checks if the needle is included in the haystack
length()
```php
public function length( mixed $item ): int;
```
Length filter. If an array/object is passed a count is performed otherwise a strlen/mb_strlen
preload()
```php
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
render()
```php
public function render(
string $path,
mixed $params,
bool $mustClean = false
);
```
Renders a view using the template engine
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
setOptions()
```php
public function setOptions( array $options );
```
Set Volt's options
slice()
```php
public function slice(
mixed $value,
int $start = 0,
mixed $end = null
);
```
Extracts a slice from a string/array/traversable object value
sort()
```php
public function sort( array $value ): array;
```
Sorts an array
## Mvc\View\Engine\Volt\Compiler
Class
This class reads and compiles Volt templates into PHP plain code
```php
$compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
$compiler->compile("views/partials/header.volt");
require $compiler->getCompiledTemplatePath();
```
- **`Phalcon\Mvc\View\Engine\Volt\Compiler`** - implements [`Phalcon\Di\InjectionAwareInterface`](/5.20/api/phalcon_di/#diinjectionawareinterface)
`Closure` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\ViewBaseInterface` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\CannotOpenCompiledFile` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatement` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatementWithData` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidCompilationPrefix` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidExtension` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidIntermediateRepresentation` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidOptionType` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathClosureReturn` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathType` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidStatement` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFilterDefinition` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFunctionDefinition` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroAlreadyDefined` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotFound` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotOpenable` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplatePathCollision` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltExpression` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilter` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilterType` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltStatement` · `Phalcon\Mvc\View\Engine\Volt\Exceptions\VoltDirectoryNotWritable` · `Phalcon\Tag` · `Phalcon\Traits\Php\FileTrait`
### Method Summary
Phalcon\Mvc\View\Engine\Volt\Compiler
Registers a Volt's extension
Register a new filter in the compiler
Register a new function in the compiler
Resolves attribute reading
Compiles a template into a file applying the compiler options
Compiles a "autoescape" statement returning PHP code
Compiles calls to macros
Compiles a "case"/"default" clause returning PHP code
Compiles a "do" statement returning PHP code
Compiles a `{{` `}}` statement returning PHP code
Compiles a "elseif" statement returning PHP code
Compiles a template into a file forcing the destination path
Generates a 'forelse' PHP code
Compiles a "foreach" intermediate code representation into plain PHP code
Compiles a 'if' statement returning PHP code
Compiles a 'include' statement returning PHP code
Compiles macros
Compiles a "return" statement returning PHP code
Compiles a "set" statement returning PHP code. The method accepts an
Compiles a template into a string
Compiles a 'switch' statement returning PHP code
Resolves an expression node in an AST volt tree
Fires an event to registered extensions
Resolves function intermediate code into PHP function calls
Returns the path to the last compiled template
Returns the internal dependency injector
Returns the list of extensions registered in Volt
Register the user registered filters
Register the user registered functions
Returns a compiler's option
Returns the compiler options
Returns the path that is currently being compiled
Return a unique prefix to be used as prefix for compiled variables and
Parses a Volt template returning its intermediate representation
Resolves filter intermediate code into a valid PHP expression
Sets the dependency injector
Sets a single compiler option
Sets the compiler options
Set a unique prefix to be used as prefix for compiled variables
Compiles a Volt source code returning a PHP plain version
Gets the final path with VIEW
Resolves filter intermediate code into PHP function calls
Traverses a statement list compiling each of its nodes
Compiles a block of statements
### Properties
TODO: Make array only?
TODO: Make it always array
### Methods
__construct()
```php
public function __construct( ViewBaseInterface|null $view = null );
```
Phalcon\Mvc\View\Engine\Volt\Compiler
addExtension()
```php
public function addExtension( mixed $extension ): static;
```
Registers a Volt's extension
addFilter()
```php
public function addFilter(
string $name,
mixed $definition
): static;
```
Register a new filter in the compiler
addFunction()
```php
public function addFunction(
string $name,
mixed $definition
): static;
```
Register a new function in the compiler
attributeReader()
```php
public function attributeReader( array $expr ): string;
```
Resolves attribute reading
compile()
```php
public function compile(
string $templatePath,
bool $extendsMode = false
);
```
Compiles a template into a file applying the compiler options
This method does not return the compiled path if the template was not compiled
```php
$compiler->compile("views/layouts/main.volt");
require $compiler->getCompiledTemplatePath();
```
compileAutoEscape()
```php
public function compileAutoEscape(
array $statement,
bool $extendsMode
): string;
```
Compiles a "autoescape" statement returning PHP code
compileCall()
```php
public function compileCall(
array $statement,
bool $extendsMode
): string;
```
Compiles calls to macros
compileCase()
```php
public function compileCase(
array $statement,
bool $caseClause = true
): string;
```
Compiles a "case"/"default" clause returning PHP code
compileDo()
```php
public function compileDo( array $statement ): string;
```
Compiles a "do" statement returning PHP code
compileEcho()
```php
public function compileEcho( array $statement ): string;
```
Compiles a `{{` `}}` statement returning PHP code
compileElseIf()
```php
public function compileElseIf( array $statement ): string;
```
Compiles a "elseif" statement returning PHP code
compileFile()
```php
public function compileFile(
string $path,
string $compiledPath,
bool $extendsMode = false
);
```
Compiles a template into a file forcing the destination path
```php
$compiler->compileFile(
"views/layouts/main.volt",
"views/layouts/main.volt.php"
);
```
compileForElse()
```php
public function compileForElse(): string;
```
Generates a 'forelse' PHP code
compileForeach()
```php
public function compileForeach(
array $statement,
bool $extendsMode = false
): string;
```
Compiles a "foreach" intermediate code representation into plain PHP code
compileIf()
```php
public function compileIf(
array $statement,
bool $extendsMode = false
): string;
```
Compiles a 'if' statement returning PHP code
compileInclude()
```php
public function compileInclude( array $statement ): string;
```
Compiles a 'include' statement returning PHP code
compileMacro()
```php
public function compileMacro(
array $statement,
bool $extendsMode
): string;
```
Compiles macros
compileReturn()
```php
public function compileReturn( array $statement ): string;
```
Compiles a "return" statement returning PHP code
compileSet()
```php
public function compileSet( array $statement ): string;
```
Compiles a "set" statement returning PHP code. The method accepts an
array produced by the Volt parser and creates the `set` statement in PHP.
This method is not particularly useful in development, since it requires
advanced knowledge of the Volt parser.
```php
306,
"assignments" => [
[
"variable" => [
"type" => 265,
"value" => "a",
"file" => "eval code",
"line" => 1
],
"op" => 61,
"expr" => [
"type" => 360,
"left" => [
[
"expr" => [
"type" => 258,
"value" => "1",
"file" => "eval code",
"line" => 1
],
"name" => "first",
"file" => "eval code",
"line" => 1
]
],
"file" => "eval code",
"line" => 1
],
"file" => "eval code",
"line" => 1
]
]
];
echo $compiler->compileSet($source);
// 1]; ?>";
```
compileString()
```php
public function compileString(
string $viewCode,
bool $extendsMode = false
): string;
```
Compiles a template into a string
```php
echo $compiler->compileString('{{ "hello world" }}');
```
compileSwitch()
```php
public function compileSwitch(
array $statement,
bool $extendsMode = false
): string;
```
Compiles a 'switch' statement returning PHP code
expression()
```php
final public function expression(
array $expr,
bool $doubleQuotes = false
): string;
```
Resolves an expression node in an AST volt tree
fireExtensionEvent()
```php
final public function fireExtensionEvent(
string $name,
array $arguments = []
);
```
Fires an event to registered extensions
functionCall()
```php
public function functionCall(
array $expr,
bool $doubleQuotes = false
): string;
```
Resolves function intermediate code into PHP function calls
getCompiledTemplatePath()
```php
public function getCompiledTemplatePath(): string;
```
Returns the path to the last compiled template
getDI()
```php
public function getDI(): DiInterface;
```
Returns the internal dependency injector
getExtensions()
```php
public function getExtensions(): array;
```
Returns the list of extensions registered in Volt
getFilters()
```php
public function getFilters(): array;
```
Register the user registered filters
getFunctions()
```php
public function getFunctions(): array;
```
Register the user registered functions
getOption()
```php
public function getOption( string $option ): string|null;
```
Returns a compiler's option
getOptions()
```php
public function getOptions(): array;
```
Returns the compiler options
getTemplatePath()
```php
public function getTemplatePath(): string;
```
Returns the path that is currently being compiled
getUniquePrefix()
```php
public function getUniquePrefix(): string;
```
Return a unique prefix to be used as prefix for compiled variables and
contexts
parse()
```php
public function parse( string $viewCode ): array;
```
Parses a Volt template returning its intermediate representation
```php
print_r(
$compiler->parse("{{ 3 + 2 }}")
);
```
resolveTest()
```php
public function resolveTest(
array $test,
string $left
): string;
```
Resolves filter intermediate code into a valid PHP expression
setDI()
```php
public function setDI( DiInterface $container ): void;
```
Sets the dependency injector
setOption()
```php
public function setOption(
string $option,
mixed $value
): static;
```
Sets a single compiler option
setOptions()
```php
public function setOptions( array $options ): static;
```
Sets the compiler options
setUniquePrefix()
```php
public function setUniquePrefix( string $prefix ): static;
```
Set a unique prefix to be used as prefix for compiled variables
compileSource()
```php
protected function compileSource(
string $viewCode,
bool $extendsMode = false
): array|string;
```
Compiles a Volt source code returning a PHP plain version
getFinalPath()
```php
protected function getFinalPath( string $path );
```
Gets the final path with VIEW
resolveFilter()
```php
final protected function resolveFilter(
array $filter,
string $left
): string;
```
Resolves filter intermediate code into PHP function calls
statementList()
```php
final protected function statementList(
array $statements,
bool $extendsMode = false
): string;
```
Traverses a statement list compiling each of its nodes
statementListOrExtends()
```php
final protected function statementListOrExtends( mixed $statements );
```
Compiles a block of statements
## Mvc\View\Engine\Volt\Exception
Class
Class for exceptions thrown by Phalcon\Mvc\View
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exception`**
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\CannotOpenCompiledFile`](#mvcviewenginevoltexceptionscannotopencompiledfile)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatement`](#mvcviewenginevoltexceptionscorruptedstatement)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatementWithData`](#mvcviewenginevoltexceptionscorruptedstatementwithdata)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidCompilationPrefix`](#mvcviewenginevoltexceptionsinvalidcompilationprefix)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidExtension`](#mvcviewenginevoltexceptionsinvalidextension)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidHaystack`](#mvcviewenginevoltexceptionsinvalidhaystack)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidIntermediateRepresentation`](#mvcviewenginevoltexceptionsinvalidintermediaterepresentation)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidOptionType`](#mvcviewenginevoltexceptionsinvalidoptiontype)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathClosureReturn`](#mvcviewenginevoltexceptionsinvalidpathclosurereturn)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathType`](#mvcviewenginevoltexceptionsinvalidpathtype)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidStatement`](#mvcviewenginevoltexceptionsinvalidstatement)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFilterDefinition`](#mvcviewenginevoltexceptionsinvaliduserfilterdefinition)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFunctionDefinition`](#mvcviewenginevoltexceptionsinvaliduserfunctiondefinition)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroAlreadyDefined`](#mvcviewenginevoltexceptionsmacroalreadydefined)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroNotFound`](#mvcviewenginevoltexceptionsmacronotfound)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\MbstringRequired`](#mvcviewenginevoltexceptionsmbstringrequired)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotFound`](#mvcviewenginevoltexceptionstemplatefilenotfound)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotOpenable`](#mvcviewenginevoltexceptionstemplatefilenotopenable)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplatePathCollision`](#mvcviewenginevoltexceptionstemplatepathcollision)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltExpression`](#mvcviewenginevoltexceptionsunknownvoltexpression)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilter`](#mvcviewenginevoltexceptionsunknownvoltfilter)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilterType`](#mvcviewenginevoltexceptionsunknownvoltfiltertype)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltStatement`](#mvcviewenginevoltexceptionsunknownvoltstatement)
- [`Phalcon\Mvc\View\Engine\Volt\Exceptions\VoltDirectoryNotWritable`](#mvcviewenginevoltexceptionsvoltdirectorynotwritable)
`Phalcon\Mvc\View\Exception`
### Method Summary
Gets currently parsed statement (if any).
### Properties
### Methods
__construct()
```php
public function __construct(
string $message = "",
array $statement = [],
int $code = 0,
\Exception|null $previous = null
);
```
getStatement()
```php
public function getStatement(): array;
```
Gets currently parsed statement (if any).
## Mvc\View\Engine\Volt\Exceptions\CannotOpenCompiledFile
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\CannotOpenCompiledFile`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $path );
```
## Mvc\View\Engine\Volt\Exceptions\CorruptedStatement
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatement`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\CorruptedStatementWithData
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\CorruptedStatementWithData`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( array $statement );
```
## Mvc\View\Engine\Volt\Exceptions\InvalidCompilationPrefix
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidCompilationPrefix`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidExtension
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidExtension`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidHaystack
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidHaystack`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidIntermediateRepresentation
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidIntermediateRepresentation`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidOptionType
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidOptionType`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $option,
string $type
);
```
## Mvc\View\Engine\Volt\Exceptions\InvalidPathClosureReturn
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathClosureReturn`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidPathType
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidPathType`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\InvalidStatement
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidStatement`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $file,
int $line,
array $statement
);
```
## Mvc\View\Engine\Volt\Exceptions\InvalidUserFilterDefinition
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFilterDefinition`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\InvalidUserFunctionDefinition
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\InvalidUserFunctionDefinition`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\MacroAlreadyDefined
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroAlreadyDefined`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\View\Engine\Volt\Exceptions\MacroNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\MacroNotFound`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Mvc\View\Engine\Volt\Exceptions\MbstringRequired
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\MbstringRequired`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\TemplateFileNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotFound`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $path );
```
## Mvc\View\Engine\Volt\Exceptions\TemplateFileNotOpenable
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplateFileNotOpenable`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $path );
```
## Mvc\View\Engine\Volt\Exceptions\TemplatePathCollision
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\TemplatePathCollision`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Engine\Volt\Exceptions\UnknownVoltExpression
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltExpression`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
int $type,
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilter
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilter`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $name,
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilterType
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltFilterType`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\UnknownVoltStatement
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\UnknownVoltStatement`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct(
int $type,
string $file,
int $line
);
```
## Mvc\View\Engine\Volt\Exceptions\VoltDirectoryNotWritable
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- **`Phalcon\Mvc\View\Engine\Volt\Exceptions\VoltDirectoryNotWritable`**
`Phalcon\Mvc\View\Engine\Volt\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Exception
Class
Phalcon\Mvc\View\Exception
Class for exceptions thrown by Phalcon\Mvc\View
- `\Exception`
- **`Phalcon\Mvc\View\Exception`**
- [`Phalcon\Mvc\View\Engine\Volt\Exception`](#mvcviewenginevoltexception)
- [`Phalcon\Mvc\View\Exceptions\InvalidEngineRegistration`](#mvcviewexceptionsinvalidengineregistration)
- [`Phalcon\Mvc\View\Exceptions\InvalidViewsDirType`](#mvcviewexceptionsinvalidviewsdirtype)
- [`Phalcon\Mvc\View\Exceptions\SimpleViewNotFound`](#mvcviewexceptionssimpleviewnotfound)
- [`Phalcon\Mvc\View\Exceptions\SimpleViewServicesUnavailable`](#mvcviewexceptionssimpleviewservicesunavailable)
- [`Phalcon\Mvc\View\Exceptions\ViewNotFound`](#mvcviewexceptionsviewnotfound)
- [`Phalcon\Mvc\View\Exceptions\ViewServicesUnavailable`](#mvcviewexceptionsviewservicesunavailable)
- [`Phalcon\Mvc\View\Exceptions\ViewsDirItemMustBeString`](#mvcviewexceptionsviewsdiritemmustbestring)
## Mvc\View\Exceptions\InvalidEngineRegistration
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\InvalidEngineRegistration`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $extension );
```
## Mvc\View\Exceptions\InvalidViewsDirType
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\InvalidViewsDirType`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Exceptions\SimpleViewNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\SimpleViewNotFound`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $viewsDirPath );
```
## Mvc\View\Exceptions\SimpleViewServicesUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\SimpleViewServicesUnavailable`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Exceptions\ViewNotFound
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\ViewNotFound`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $viewPath );
```
## Mvc\View\Exceptions\ViewServicesUnavailable
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\ViewServicesUnavailable`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Exceptions\ViewsDirItemMustBeString
Class
- `\Exception`
- [`Phalcon\Mvc\View\Exception`](#mvcviewexception)
- **`Phalcon\Mvc\View\Exceptions\ViewsDirItemMustBeString`**
`Phalcon\Mvc\View\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Mvc\View\Simple
Class
This component allows to render views without hierarchical levels
```php
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,
]
);
```
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Mvc\View\Simple`** - implements [`Phalcon\Mvc\ViewBaseInterface`](#mvcviewbaseinterface), [`Phalcon\Events\EventsAwareInterface`](/5.20/api/phalcon_events/#eventseventsawareinterface), [`Phalcon\Contracts\View\Renderer`](/5.20/api/phalcon_contracts/#contractsviewrenderer)
`Closure` · `Phalcon\Contracts\View\Renderer` · `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` · `Phalcon\Mvc\View\Exceptions\InvalidEngineRegistration` · `Phalcon\Mvc\View\Exceptions\SimpleViewNotFound` · `Phalcon\Mvc\View\Exceptions\SimpleViewServicesUnavailable` · `Phalcon\Mvc\View\Traits\ViewParamsTrait` · `Phalcon\Traits\Php\FileTrait` · `Phalcon\Traits\Support\Helper\Str\DirSeparatorTrait`
### Method Summary
Phalcon\Mvc\View\Simple constructor
Magic method to retrieve a variable passed to the view
Magic method to pass variables to the views
Returns the path of the view that is currently rendered
Returns the internal event manager
Gets views directory
Renders a partial view
Register templating engines
Renders a view
Sets the events manager
Adds parameters to views (alias of setVar)
Set all the render params
Sets views directory
Tries to render the view with every engine registered in the component
Loads registered template engines, if none are registered it will use
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Phalcon\Mvc\View\Simple constructor
__get()
```php
public function __get( string $key ): mixed|null;
```
Magic method to retrieve a variable passed to the view
```php
echo $this->view->products;
```
__set()
```php
public function __set(
string $key,
mixed $value
): void;
```
Magic method to pass variables to the views
```php
$this->view->products = $products;
```
getActiveRenderPath()
```php
public function getActiveRenderPath(): string;
```
Returns the path of the view that is currently rendered
getEventsManager()
```php
public function getEventsManager(): ManagerInterface|null;
```
Returns the internal event manager
getViewsDir()
```php
public function getViewsDir(): string;
```
Gets views directory
partial()
```php
public function partial(
string $partialPath,
mixed $params = null
): void;
```
Renders a partial view
```php
// Show a partial inside another view
$this->partial("shared/footer");
```
```php
// Show a partial inside another view with parameters
$this->partial(
"shared/footer",
[
"content" => $html,
]
);
```
registerEngines()
```php
public function registerEngines( array $engines ): void;
```
Register templating engines
```php
$this->view->registerEngines(
[
".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
".volt" => \Phalcon\Mvc\View\Engine\Volt::class,
".mhtml" => \MyCustomEngine::class,
]
);
```
render()
```php
public function render(
string $path,
array $params = []
): string;
```
Renders a view
setEventsManager()
```php
public function setEventsManager( ManagerInterface $eventsManager ): void;
```
Sets the events manager
setParamToView()
```php
public function setParamToView(
string $key,
mixed $value
): static;
```
Adds parameters to views (alias of setVar)
```php
$this->view->setParamToView("products", $products);
```
setVars()
```php
public function setVars(
array $params,
bool $merge = true
): static;
```
Set all the render params
```php
$this->view->setVars(
[
"products" => $products,
]
);
```
setViewsDir()
```php
public function setViewsDir( string $viewsDir ): void;
```
Sets views directory
internalRender()
```php
final protected function internalRender(
string $path,
mixed $params
): void;
```
Tries to render the view with every engine registered in the component
loadTemplateEngines()
```php
protected function loadTemplateEngines(): array;
```
Loads registered template engines, if none are registered it will use
Phalcon\Mvc\View\Engine\Php
## Mvc\View\Traits\ViewParamsTrait
Trait
Shared view parameter and content accessors
@todo v7 - inspect the View/Simple interfaces (ViewInterface vs ViewBaseInterface) to see whether these accessors can be unified behind a shared contract
- **`Phalcon\Mvc\View\Traits\ViewParamsTrait`**
[`Phalcon\Mvc\View`](#mvcview) · [`Phalcon\Mvc\View\Simple`](#mvcviewsimple)
### Method Summary
Returns output from another view stage
Returns parameters to views
Returns a parameter previously set in the view
Externally sets the view content
Set a single view parameter
### Properties
@todo Use a default [] once Zephir supports array trait defaults
@todo Use a default [] once Zephir supports array trait defaults
### Methods
getContent()
```php
public function getContent(): string;
```
Returns output from another view stage
getParamsToView()
```php
public function getParamsToView(): array;
```
Returns parameters to views
getRegisteredEngines()
```php
public function getRegisteredEngines(): array;
```
getVar()
```php
public function getVar( string $key ): mixed|null;
```
Returns a parameter previously set in the view
setContent()
```php
public function setContent( string $content ): static;
```
Externally sets the view content
```php
$this->view->setContent("hello
");
```
setVar()
```php
public function setVar(
string $key,
mixed $value
): static;
```
Set a single view parameter
```php
$this->view->setVar("products", $products);
```
Source: https://docs.phalcon.io/5.20/api/phalcon_mvc/index.mdx