--- title: "Phalcon Mvc" version: "5.19" --- > 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 Source on GitHub 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.19/api/phalcon_di/#diinjectable) - [`Phalcon\Application\AbstractApplication`](/5.19/api/phalcon_application/#applicationabstractapplication) - **`Phalcon\Mvc\Application`**

__Uses__ `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

public ResponseInterface|bool handle( string $uri ) Handles a MVC request public static sendCookiesOnHandleRequest( bool $sendCookies ) Enables or disables sending cookies by each request handling public static sendHeadersOnHandleRequest( bool $sendHeaders ) Enables or disables sending headers by each request handling public static useImplicitView( bool $implicitView ) By default. The view is implicitly buffering all the output

### Properties

protected bool $implicitView = true

protected bool $sendCookies = true

protected bool $sendHeaders = true

### Methods

Public · 4

`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 Source on GitHub Phalcon\Mvc\Application\Exception Exceptions thrown in Phalcon\Mvc\Application class will use this class

- `\Exception` - [`Phalcon\Application\Exception`](/5.19/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 Source on GitHub

- `\Exception` - [`Phalcon\Application\Exception`](/5.19/api/phalcon_application/#applicationexception) - [`Phalcon\Mvc\Application\Exception`](#mvcapplicationexception) - **`Phalcon\Mvc\Application\Exceptions\ContainerRequired`**

__Uses__ `Phalcon\Mvc\Application\Exception` ### Method Summary

public __construct()

### Methods

Public · 1

`__construct()`

```php public function __construct(); ``` ## Mvc\Application\Exceptions\InvalidModuleDefinition Class Source on GitHub

__Uses__ `Phalcon\Mvc\Application\Exception` ### Method Summary

public __construct(string|null $name = null,string|null $reason = null)

### Methods

Public · 1

`__construct()`

```php public function __construct( string|null $name = null, string|null $reason = null ); ``` ## Mvc\Application\Exceptions\ModuleDefinitionPathNotFound Class Source on GitHub

__Uses__ `Phalcon\Mvc\Application\Exception` ### Method Summary

public __construct( string $path )

### Methods

Public · 1

`__construct()`

```php public function __construct( string $path ); ``` ## Mvc\Controller Abstract Source on GitHub 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.19/api/phalcon_di/#diinjectable) - **`Phalcon\Mvc\Controller`** - implements [`Phalcon\Mvc\ControllerInterface`](#mvccontrollerinterface), [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface)

__Uses__ `Phalcon\Di\Injectable` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` ### Method Summary

public __construct() Phalcon\Mvc\Controller constructor public ManagerInterface|null getEventsManager() Returns the internal event manager public void setEventsManager( ManagerInterface $eventsManager ) Sets the events manager protected mixed|bool fireManagerEvent(string $eventName,mixed $data = null,bool $cancellable = true) Helper method to fire an event

### Methods

Public · 3

`__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

Protected · 1

`fireManagerEvent()`

```php protected function fireManagerEvent( string $eventName, mixed $data = null, bool $cancellable = true ): mixed|bool; ``` Helper method to fire an event ## Mvc\ControllerInterface Interface Source on GitHub Phalcon\Mvc\ControllerInterface Interface for controller handlers

- **`Phalcon\Mvc\ControllerInterface`**

## Mvc\Controller\BindModelInterface Interface Source on GitHub Phalcon\Mvc\Controller\BindModelInterface Interface for Phalcon\Mvc\Controller

- **`Phalcon\Mvc\Controller\BindModelInterface`**

### Method Summary

public string getModelName() Return the model name associated with this controller

### Methods

Public · 1

`getModelName()`

```php public static function getModelName(): string; ``` Return the model name associated with this controller ## Mvc\Dispatcher Class Source on GitHub 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.19/api/phalcon_di/#diabstractinjectionaware) - [`Phalcon\Dispatcher\AbstractDispatcher`](/5.19/api/phalcon_dispatcher/#dispatcherabstractdispatcher) - **`Phalcon\Mvc\Dispatcher`** - implements [`Phalcon\Mvc\DispatcherInterface`](#mvcdispatcherinterface)

__Uses__ `Phalcon\Contracts\Dispatcher\DispatcherTypes` · `Phalcon\Dispatcher\AbstractDispatcher` · `Phalcon\Events\ManagerInterface` · `Phalcon\Http\ResponseInterface` · `Phalcon\Mvc\Dispatcher\Exception` · `Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable` ### Method Summary

public void forward( array $forward ) Forwards the execution flow to another controller/action. public ControllerInterface getActiveController() Returns the active controller in the dispatcher public string getControllerClass() Possible controller class name that will be located to dispatch the public string getControllerName() Gets last dispatched controller name public ControllerInterface getLastController() Returns the latest dispatched controller public string getPreviousControllerName() Gets previous dispatched controller name public DispatcherInterface setControllerName( string $controllerName ) Sets the controller name to be dispatched public DispatcherInterface setControllerSuffix( string $controllerSuffix ) Sets the default controller suffix public DispatcherInterface setDefaultController( string $controllerName ) Sets the default controller name protected handleException( \Exception $exception ) Handles a user exception protected throwDispatchException(string $message,int $exceptionCode = 0) Throws an internal exception

### Properties

protected string $defaultAction = "index"

protected string $defaultHandler = "index"

protected string $handlerSuffix = "Controller"

### Methods

Public · 9

`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

Protected · 2

`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 Source on GitHub Phalcon\Mvc\DispatcherInterface Interface for Phalcon\Mvc\Dispatcher

- [`Phalcon\Contracts\Dispatcher\Dispatcher`](/5.19/api/phalcon_contracts/#contractsdispatcherdispatcher) - [`Phalcon\Contracts\Mvc\Dispatcher`](/5.19/api/phalcon_contracts/#contractsmvcdispatcher) - **`Phalcon\Mvc\DispatcherInterface`**

__Uses__ `Phalcon\Contracts\Mvc\Dispatcher` ## Mvc\Dispatcher\Exception Class Source on GitHub Phalcon\Mvc\Dispatcher\Exception Exceptions thrown in Phalcon\Mvc\Dispatcher will use this class

- `\Exception` - [`Phalcon\Dispatcher\Exception`](/5.19/api/phalcon_dispatcher/#dispatcherexception) - **`Phalcon\Mvc\Dispatcher\Exception`** - [`Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable`](#mvcdispatcherexceptionsresponseserviceunavailable)

## Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable Class Source on GitHub

- `\Exception` - [`Phalcon\Dispatcher\Exception`](/5.19/api/phalcon_dispatcher/#dispatcherexception) - [`Phalcon\Mvc\Dispatcher\Exception`](#mvcdispatcherexception) - **`Phalcon\Mvc\Dispatcher\Exceptions\ResponseServiceUnavailable`**

__Uses__ `Phalcon\Mvc\Dispatcher\Exception` ### Method Summary

public __construct()

### Methods

Public · 1

`__construct()`

```php public function __construct(); ``` ## Mvc\EntityInterface Interface Source on GitHub Phalcon\Mvc\EntityInterface Interface for Phalcon\Mvc\Collection and Phalcon\Mvc\Model

- **`Phalcon\Mvc\EntityInterface`**

### Method Summary

public mixed|null readAttribute( string $attribute ) Reads an attribute value by its name public writeAttribute(string $attribute,mixed $value) Writes an attribute value by its name

### Methods

Public · 2

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectable) - **`Phalcon\Mvc\Micro`** - implements `\ArrayAccess`, [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface)

__Uses__ `ArrayAccess` · `Closure` · `Phalcon\Cache\Adapter\AdapterInterface` · `Phalcon\Di\DiInterface` · `Phalcon\Di\FactoryDefault` · `Phalcon\Di\Injectable` · `Phalcon\Di\ServiceInterface` · `Phalcon\Events\EventsAwareInterface` · `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

### Properties

protected callable|null $activeHandler = null

protected array $afterBindingHandlers = []

protected array $afterHandlers = []

protected array $beforeHandlers = []

protected DiInterface|null $container = null

protected callable|null $errorHandler = null

protected ManagerInterface|null $eventsManager = null

protected array $finishHandlers = []

protected array $handlers = []

protected BinderInterface|null $modelBinder = null

protected callable|null $notFoundHandler = null

protected callable|null $responseHandler = null

protected mixed|null $returnedValue = null

protected RouterInterface|null $router = null

protected bool $stopped = false

### Methods

Public · 38

`__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 Source on GitHub 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

### Properties

protected callable $handler

protected array $handlers = []

protected bool $isLazy = false

protected string $prefix = ""

### Methods

Public · 16

`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

Protected · 1

`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 Source on GitHub Phalcon\Mvc\Micro\CollectionInterface Interface for Phalcon\Mvc\Micro\Collection

- **`Phalcon\Mvc\Micro\CollectionInterface`**

### Method Summary

### Methods

Public · 15

`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 Source on GitHub 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)

```php public function __construct(); ``` ## Mvc\Micro\LazyLoader Class Source on GitHub Phalcon\Mvc\Micro\LazyLoader Lazy-Load of handlers for Mvc\Micro using auto-loading

- **`Phalcon\Mvc\Micro\LazyLoader`**

__Uses__ `Phalcon\Mvc\Micro\Exceptions\LazyHandlerNotFound` · `Phalcon\Mvc\Model\BinderInterface` ### Method Summary

public __construct( string $definition ) Phalcon\Mvc\Micro\LazyLoader constructor public callMethod(string $method,mixed $arguments,BinderInterface|null $modelBinder = null) Calling __call method public string getDefinition() public object|null getHandler()

### Properties

protected string $definition

protected object|null $handler = null

### Methods

Public · 4

`__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 Source on GitHub Allows to implement Phalcon\Mvc\Micro middleware in classes

- **`Phalcon\Mvc\Micro\MiddlewareInterface`**

__Uses__ `Phalcon\Mvc\Micro` ### Method Summary

public call( Micro $application ) Calls the middleware

### Methods

Public · 1

`call()`

```php public function call( Micro $application ); ``` Calls the middleware ## Mvc\Model Abstract Source on GitHub 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.19/api/phalcon_di/#diabstractinjectionaware) - **`Phalcon\Mvc\Model`** - implements [`Phalcon\Mvc\EntityInterface`](#mvcentityinterface), [`Phalcon\Mvc\ModelInterface`](#mvcmodelinterface), [`Phalcon\Mvc\Model\ResultInterface`](#mvcmodelresultinterface), `\JsonSerializable`

__Uses__ `JsonSerializable` · `Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Db\Column` · `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

hasManyToMany(mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referenceModel,mixed $referencedFields,array $options = [])

Setup an n-n relation between two models, through an intermediate protected Relation hasOne(mixed $fields,string $referenceModel,mixed $referencedFields,array $options = []) Setup a 1-1 relation between two models protected Relation

hasOneThrough(mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referenceModel,mixed $referencedFields,array $options = [])

Setup a 1-1 relation between two models, through an intermediate protected invokeFinder(string $method,array $arguments) Try to check if the query must invoke a finder protected void keepSnapshots( bool $keepSnapshot ) Sets if the model must keep the original record snapshot in memory protected bool possibleSetter(string $property,mixed $value) Check for, and attempt to use, possible setter. protected bool postSave(bool $success,bool $exists) Executes internal events after save a record protected bool postSaveRelatedRecords(AdapterInterface $connection,mixed $related,CollectionInterface $visited) Save the related records assigned in the has-one/has-many relations protected bool preSave(MetaDataInterface $metaData,bool $exists,mixed $identityField) Executes internal hooks before save a record protected bool preSaveRelatedRecords(AdapterInterface $connection,mixed $related,CollectionInterface $visited) Saves related records that must be stored prior to save the master record protected ModelInterface setSchema( string $schema ) Sets schema name where the mapped table is located protected ModelInterface setSource( string $source ) Sets the table name to which model should be mapped protected void skipAttributes( array $attributes ) Sets a list of attributes that must be skipped from the protected void skipAttributesOnCreate( array $attributes ) Sets a list of attributes that must be skipped from the protected void skipAttributesOnUpdate( array $attributes ) Sets a list of attributes that must be skipped from the protected void useDynamicUpdate( bool $dynamicUpdate ) Sets if a model must use dynamic update instead of the all-field update protected bool validate( ValidationInterface $validator ) Executes validators on every validation call

### Constants

int DIRTY_STATE_DETACHED = 2

int DIRTY_STATE_PERSISTENT = 0

int DIRTY_STATE_TRANSIENT = 1

int OP_CREATE = 1

int OP_DELETE = 3

int OP_NONE = 0

int OP_UPDATE = 2

string TRANSACTION_INDEX = "transaction"

### Properties

protected array $dirtyRelated = []

protected int $dirtyState = 1

protected array $errorMessages = []

protected ManagerInterface|null $modelsManager = null

protected MetaDataInterface|null $modelsMetaData = null

protected array $oldSnapshot = []

protected int $operationMade = 0

protected array $rawValues = []

protected array $related = []

protected bool $skipped = false

protected array $snapshot = []

protected array $syncRelated = [] Per-save many-to-many sync overrides, keyed by lowercased relation alias (or "*" wildcard) => bool. Cleared after each save().

protected TransactionInterface|null $transaction = null

protected string|null $uniqueKey = null

protected array $uniqueParams = []

protected array $uniqueTypes = []

### Methods

Public · 73

`__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

`getModelsMetaData()`

```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

`getRelated()`

```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

`setRelated()`

```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"); ```

Protected · 30

`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

`collectRelatedToSave()`

```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

`getRelatedRecords()`

```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

`preSaveRelatedRecords()`

```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 Source on GitHub Phalcon\Mvc\ModelInterface Interface for Phalcon\Mvc\Model @template T

- **`Phalcon\Mvc\ModelInterface`**

__Uses__ `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

public ModelInterface appendMessage( MessageInterface $message ) Appends a customized message on the validation process public ModelInterface assign(array $data,mixed $whiteList = null,mixed $dataColumnMap = null) Assigns values to a model from an array public float|ResultsetInterface average( array $parameters = [] ) Allows to calculate the average value on a column matching the specified public ModelInterface cloneResult(ModelInterface $base,array $data,int $dirtyState = 0) Assigns values to a model from an array returning a new model public ModelInterface cloneResultMap(mixed $base,array $data,mixed $columnMap,int $dirtyState = 0,bool $keepSnapshots = false) Assigns values to a model from an array returning a new model public cloneResultMapHydrate(array $data,mixed $columnMap,int $hydrationMode) Returns an hydrated result based on the data and the column map public int|ResultsetInterface count( mixed $parameters = null ) Allows to count how many records match the specified conditions public bool create() Inserts a model instance. If the instance already exists in the public bool delete() Deletes a model instance. Returning true on success or false otherwise. public find( mixed $parameters = null ) Allows to query a set of records that match the specified conditions. public mixed|null findFirst( mixed $parameters = null ) Allows to query the first record that match the specified conditions public bool fireEvent( string $eventName ) Fires an event, implicitly calls behaviors and listeners in the events public bool fireEventCancel( string $eventName ) Fires an event, implicitly calls behaviors and listeners in the events public int getDirtyState() Returns one of the DIRTY_STATE_* constants telling if the record exists public MessageInterface[] getMessages() Returns array of validation messages public MetaDataInterface getModelsMetaData() Returns the models meta-data service related to the entity instance. public int getOperationMade() Returns the type of the latest operation performed by the ORM public AdapterInterface getReadConnection() Gets internal database connection public string getReadConnectionService() Returns DependencyInjection connection service used to read data public getRelated(string $alias,mixed $arguments = null) Returns related records based on defined relations public string|null getSchema() Returns schema name where table mapped is located public string getSource() Returns table name mapped in the model public AdapterInterface getWriteConnection() Gets internal database connection public string getWriteConnectionService() Returns DependencyInjection connection service used to write data public mixed maximum( mixed $parameters = null ) Allows to get the maximum value of a column that match the specified public mixed minimum( mixed $parameters = null ) Allows to get the minimum value of a column that match the specified public CriteriaInterface query( DiInterface|null $container = null ) Create a criteria for a specific model public ModelInterface refresh() Refreshes the model attributes re-querying the record from the database public bool save() Inserts or updates a model instance. Returning true on success or false public void setConnectionService( string $connectionService ) Sets both read/write connection services public ModelInterface|bool setDirtyState( int $dirtyState ) Sets the dirty state of the object using one of the DIRTY_STATE_* public void setReadConnectionService( string $connectionService ) Sets the DependencyInjection connection service used to read data public void setSnapshotData(array $data,mixed $columnMap = null) Sets the record's snapshot data. This method is used internally to set public ModelInterface setSync(mixed $elements = null,bool $enabled = true) Marks one or more many-to-many relationships to be synchronized (or not) public ModelInterface setTransaction( TransactionInterface $transaction ) Sets a transaction related to the Model instance public void setWriteConnectionService( string $connectionService ) Sets the DependencyInjection connection service used to write data public void skipOperation( bool $skip ) Skips the current operation forcing a success state public float|ResultsetInterface sum( mixed $parameters = null ) Allows to calculate a sum on a column that match the specified conditions public bool update() Updates a model instance. If the instance does not exist in the public bool validationHasFailed() Check whether validation process has generated any messages

### Methods

Public · 40

`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

`getModelsMetaData()`

```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

`getRelated()`

```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()`

`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 Source on GitHub 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)

__Uses__ `Phalcon\Mvc\ModelInterface` ### Method Summary

public __construct( array $options = [] ) Phalcon\Mvc\Model\Behavior public missingMethod(ModelInterface $model,string $method,array $arguments = []) Acts as fallbacks when a missing method is called on the model public notify(string $type,ModelInterface $model) This method receives the notifications from the EventsManager protected getOptions( string|null $eventName = null ) Returns the behavior options related to an event protected bool mustTakeAction( string $eventName ) Checks whether the behavior must take action on certain event

### Properties

protected array $options

### Methods

Public · 3

`__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()`

`notify()`

```php public function notify( string $type, ModelInterface $model ); ``` Listens for notifications from the models manager ## Mvc\Model\Behavior\Timestampable Class Source on GitHub 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`**

__Uses__ `Closure` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Behavior` · `Phalcon\Mvc\Model\Behavior\Exceptions\MissingRequiredOption` · `Phalcon\Mvc\Model\Exception` ### Method Summary

public notify(string $type,ModelInterface $model) Listens for notifications from the models manager

### Methods

Public · 1

`notify()`

```php public function notify( string $type, ModelInterface $model ); ``` Listens for notifications from the models manager ## Mvc\Model\Binder Class Source on GitHub 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)

__Uses__ `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

public __construct( AdapterInterface|null $cache = null ) Phalcon\Mvc\Model\Binder constructor public array bindToHandler(object $handler,array $params,string $cacheKey,string|null $methodName = null) Bind models into params in proper handler public array getBoundModels() Return the active bound models public AdapterInterface getCache() Sets cache instance public array getOriginalValues() Return the array for original values public BinderInterface setCache( AdapterInterface $cache ) Gets cache instance protected mixed|bool findBoundModel(mixed $paramValue,string $className) Find the model by param value. protected array|null getParamsFromCache( string $cacheKey ) Get params classes from cache by key protected array getParamsFromReflection(object $handler,array $params,string $cacheKey,string $methodName) Get modified params for handler using reflection

### Properties

protected array $boundModels = [] Array for storing active bound models

protected AdapterInterface|null $cache Cache object used for caching parameters for model binding

protected array $internalCache = [] Internal cache for caching parameters for model binding during request

protected array $originalValues = [] Array for original values

### Methods

Public · 6

`__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

Protected · 3

`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 Source on GitHub Phalcon\Mvc\Model\BinderInterface Interface for Phalcon\Mvc\Model\Binder

- **`Phalcon\Mvc\Model\BinderInterface`**

__Uses__ `Phalcon\Cache\Adapter\AdapterInterface` ### Method Summary

public array bindToHandler(object $handler,array $params,string $cacheKey,string|null $methodName = null) Bind models into params in proper handler public array getBoundModels() Gets active bound models public AdapterInterface getCache() Gets cache instance public BinderInterface setCache( AdapterInterface $cache ) Sets cache instance

### Methods

Public · 4

`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 Source on GitHub Phalcon\Mvc\Model\Binder\BindableInterface Interface for bindable classes

- **`Phalcon\Mvc\Model\Binder\BindableInterface`**

### Method Summary

public string|array getModelName() Return the model name or models names and parameters keys associated with

### Methods

Public · 1

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface)

__Uses__ `Phalcon\Db\Column` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\Model\Exceptions\InvalidModelName` · `Phalcon\Mvc\Model\Query\BuilderInterface` ### Method Summary

### Properties

protected array $bindParams

protected array $bindTypes

protected int $hiddenParamNumber = 0

protected string|null $model = null

protected array $params = []

### Methods

Public · 39

`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

`fromInput()`

```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 Source on GitHub Phalcon\Mvc\Model\CriteriaInterface Interface for Phalcon\Mvc\Model\Criteria

- **`Phalcon\Mvc\Model\CriteriaInterface`**

__Uses__ `Phalcon\Di\DiInterface` ### Method Summary

### Methods

Public · 32

`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()`

`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()`

`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()`

`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 Source on GitHub 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`**

__Uses__ `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

public __construct( ManagerInterface $manager ) public void apply(mixed $record,array $eagerMap) Applies a pre-built eager map to a single record. public string buildKey( array $values ) Builds the lookup key for a set of key-field values. public void loadResultset(Simple $resultset,string $modelName,array $tree) Loads a relation tree for a root resultset. protected array buildMap(array $parents,string $modelName,array $tree) Builds one level of the map. protected array buildNode(RelationInterface $relation,string $alias,array $parents,array $node) Builds a single map node: one query, indexed by the referenced field. protected array buildThroughNode(RelationInterface $relation,string $alias,array $parents,array $node) Through-relations in two steps rather than a join. protected array collectKeys(array $parents,array $fields,string $alias) Distinct, non-null local key tuples across the parent set. protected Simple fetchReferenced(RelationInterface $relation,string $alias,array $keys,array $options) One query per relation node. An empty key set issues none at all - protected array normalizeFields( mixed $fields ) Relation fields are declared as a string for a single column and an protected string recordKey(mixed $record,array $fields) Lookup key for an already-hydrated record.

### Constants

int MAX_ROWS_PER_LEVEL = 100000 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

protected ManagerInterface $manager

### Methods

Public · 4

`__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.

Protected · 7

`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()`

Public · 1

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface), [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface)

__Uses__ `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

public __destruct() Destroys the current PHQL cache public void addBehavior(ModelInterface $model,BehaviorInterface $behavior) Binds a behavior to a model public RelationInterface addBelongsTo(ModelInterface $model,mixed $fields,string $referencedModel,mixed $referencedFields,array $options = []) Setup a relation reverse many to one between two models public RelationInterface addHasMany(ModelInterface $model,mixed $fields,string $referencedModel,mixed $referencedFields,array $options = []) Setup a relation 1-n between two models public RelationInterface

addHasManyToMany(ModelInterface $model,mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referencedModel,mixed $referencedFields,array $options = [])

Setups a relation n-m between two models public RelationInterface addHasOne(ModelInterface $model,mixed $fields,string $referencedModel,mixed $referencedFields,array $options = []) Setup a 1-1 relation between two models public RelationInterface

addHasOneThrough(ModelInterface $model,mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referencedModel,mixed $referencedFields,array $options = [])

Setups a relation 1-1 between two models using an intermediate model public void clearReusableObjects() Clears the internal reusable list public BuilderInterface createBuilder( mixed $params = null ) Creates a Phalcon\Mvc\Model\Query\Builder public QueryInterface createQuery( string $phql ) Creates a Phalcon\Mvc\Model\Query without execute it public mixed executeQuery(string $phql,mixed $placeholders = null,mixed $types = null) Creates a Phalcon\Mvc\Model\Query and execute it public bool existsBelongsTo(string $modelName,string $modelRelation) Checks whether a model has a belongsTo relation with another model public bool existsHasMany(string $modelName,string $modelRelation) Checks whether a model has a hasMany relation with another model public bool existsHasManyToMany(string $modelName,string $modelRelation) Checks whether a model has a hasManyToMany relation with another model public bool existsHasOne(string $modelName,string $modelRelation) Checks whether a model has a hasOne relation with another model public bool existsHasOneThrough(string $modelName,string $modelRelation) Checks whether a model has a hasOneThrough relation with another model public RelationInterface[]|array getBelongsTo( ModelInterface $model ) Gets all the belongsTo relations defined in a model public ResultsetInterface|bool

getBelongsToRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

Gets belongsTo related records from a model public BuilderInterface|null getBuilder() Returns the newly created Phalcon\Mvc\Model\Query\Builder or null public string getConnectionService(ModelInterface $model,array $connectionServices) Returns the connection service name used to read or write data related to public EventsManagerInterface|null getCustomEventsManager( ModelInterface $model ) Returns a custom events manager related to a model or null if there is public DiInterface getDI() Returns the DependencyInjector container public EventsManagerInterface|null getEventsManager() Returns the internal event manager public RelationInterface[]|array getHasMany( ModelInterface $model ) Gets hasMany relations defined on a model public ResultsetInterface|bool

getHasManyRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

getHasOneRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

Gets belongsTo related records from a model public RelationInterface[]|array getHasOneThrough( ModelInterface $model ) Gets hasOneThrough relations defined on a model public ModelInterface|null getLastInitialized() Get last initialized model public QueryInterface getLastQuery() Returns the last query created or executed in the models manager public string getModelPrefix() Returns the prefix for all model sources. public string|null getModelSchema( ModelInterface $model ) Returns the mapped schema for a model public string getModelSource( ModelInterface $model ) Returns the mapped source for a model public AdapterInterface getReadConnection( ModelInterface $model ) Returns the connection to read data related to a model public string getReadConnectionService( ModelInterface $model ) Returns the connection service name used to read data related to a model public RelationInterface|bool getRelationByAlias(string $modelName,string $alias) Returns a relation by its alias public

getRelationRecords(RelationInterface $relation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

### Properties

protected array $aliases = []

protected array $behaviors = [] Models' behaviors

protected array $belongsTo = [] Belongs to relations

protected array $belongsToSingle = [] All the relationships by model

protected BuilderInterface|null $builder = null

protected DiInterface|null $container = null

protected array $customEventsManager = []

protected array $dirtyWriteServices = [] 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.

protected array $dynamicUpdate = [] Does the model use dynamic update, instead of updating all rows?

protected EventsManagerInterface|null $eventsManager = null

protected array $hasMany = [] Has many relations

protected array $hasManySingle = [] Has many relations by model

protected array $hasManyToMany = [] Has many-Through relations

protected array $hasManyToManySingle = [] Has many-Through relations by model

protected array $hasOne = [] Has one relations

protected array $hasOneSingle = [] Has one relations by model

protected array $hasOneThrough = [] Has one through relations

protected array $hasOneThroughSingle = [] Has one through relations by model

protected array $initialized = [] Mark initialized models

protected array $keepSnapshots = []

protected ModelInterface|null $lastInitialized = null Last model initialized

protected QueryInterface|null $lastQuery = null Last query created/executed

protected array $modelVisibility = []

protected string $prefix = ""

protected array $readConnectionServices = []

protected array $reusable = [] Stores a list of reusable instances

protected array $schemas = []

protected array $sources = []

protected bool $sticky = false Whether reads should stick to the write connection after a write has occurred during the current request cycle.

protected array $writeConnectionServices = []

### Methods

Public · 74

`__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

Protected · 1

`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 Source on GitHub Phalcon\Mvc\Model\ManagerInterface Interface for Phalcon\Mvc\Model\Manager

- **`Phalcon\Mvc\Model\ManagerInterface`**

__Uses__ `Phalcon\Db\Adapter\AdapterInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Query\BuilderInterface` · `Phalcon\Mvc\Model\Query\StatusInterface` ### Method Summary

public void addBehavior(ModelInterface $model,BehaviorInterface $behavior) Binds a behavior to a model public RelationInterface addBelongsTo(ModelInterface $model,mixed $fields,string $referencedModel,mixed $referencedFields,array $options = []) Setup a relation reverse 1-1 between two models public RelationInterface addHasMany(ModelInterface $model,mixed $fields,string $referencedModel,mixed $referencedFields,array $options = []) Setup a relation 1-n between two models public RelationInterface

addHasManyToMany(ModelInterface $model,mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referencedModel,mixed $referencedFields,array $options = [])

addHasOneThrough(ModelInterface $model,mixed $fields,string $intermediateModel,mixed $intermediateFields,mixed $intermediateReferencedFields,string $referencedModel,mixed $referencedFields,array $options = [])

Setups a 1-1 relation between two models using an intermediate table public void clearReusableObjects() Clears the internal reusable list public BuilderInterface createBuilder( mixed $params = null ) Creates a Phalcon\Mvc\Model\Query\Builder public QueryInterface createQuery( string $phql ) Creates a Phalcon\Mvc\Model\Query without execute it public mixed executeQuery(string $phql,mixed $placeholders = null,mixed $types = null) Creates a Phalcon\Mvc\Model\Query and execute it public RelationInterface[]|array getBelongsTo( ModelInterface $model ) Gets belongsTo relations defined on a model public ResultsetInterface|bool

getBelongsToRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

Gets belongsTo related records from a model public BuilderInterface|null getBuilder() Returns the newly created Phalcon\Mvc\Model\Query\Builder or null public RelationInterface[]|array getHasMany( ModelInterface $model ) Gets hasMany relations defined on a model public ResultsetInterface|bool

getHasManyRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

getHasOneRecords(string $modelName,string $modelRelation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

getRelationRecords(RelationInterface $relation,ModelInterface $record,mixed $parameters = null,string|null $method = null)

### Methods

Public · 58

`addBehavior()`

```php public function addBehavior( ModelInterface $model, BehaviorInterface $behavior ): void; ``` Binds a behavior to a model

`addBelongsTo()`

`addHasMany()`

`addHasManyToMany()`

`addHasOne()`

`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()`

`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()`

`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()`

`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()`

`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()`

`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 Source on GitHub 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.19/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)

__Uses__ `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

### Constants

int MODELS_ATTRIBUTES = 0

int MODELS_AUTOMATIC_DEFAULT_INSERT = 10

int MODELS_AUTOMATIC_DEFAULT_UPDATE = 11

int MODELS_COLUMN_MAP = 0

int MODELS_DATA_TYPES = 4

int MODELS_DATA_TYPES_BIND = 9

int MODELS_DATA_TYPES_NUMERIC = 5

int MODELS_DATE_AT = 6

int MODELS_DATE_IN = 7

int MODELS_DEFAULT_VALUES = 12

int MODELS_EMPTY_STRING_VALUES = 13

int MODELS_IDENTITY_COLUMN = 8

int MODELS_NON_PRIMARY_KEY = 2

int MODELS_NOT_NULL = 3

int MODELS_PRIMARY_KEY = 1

int MODELS_REVERSE_COLUMN_MAP = 1

### Properties

protected CacheAdapterInterface|null $adapter = null

protected array $columnMap = []

protected DiInterface|null $container = null

protected array $metaData = []

protected array $pendingMetaDataWrites = [] 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.

protected StrategyInterface|null $strategy = null

### Methods

Public · 36

`getAdapter()`

```php public function getAdapter(): CacheAdapterInterface|null; ``` Return the internal cache adapter

`getAttributes()`

```php public function getAttributes( ModelInterface $model ): array; ``` Returns table attributes names (fields) ```php print_r( $metaData->getAttributes( new Invoices() ) ); ```

`getAutomaticCreateAttributes()`

```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() ) ); ```

`getAutomaticUpdateAttributes()`

```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() ) ); ```

`getBindTypes()`

```php public function getBindTypes( ModelInterface $model ): array; ``` Returns attributes and their bind data types ```php print_r( $metaData->getBindTypes( new Invoices() ) ); ```

`getColumnMap()`

```php public function getColumnMap( ModelInterface $model ): array|null; ``` Returns the column map if any ```php print_r( $metaData->getColumnMap( new Invoices() ) ); ```

`getColumnMapUniqueKey()`

```php public final function getColumnMapUniqueKey( ModelInterface $model ): string|null; ``` Returns a ColumnMap Unique key for meta-data is created using className

`getDI()`

```php public function getDI(): DiInterface; ``` Returns the DependencyInjector container

`getDataTypes()`

```php public function getDataTypes( ModelInterface $model ): array; ``` Returns attributes and their data types ```php print_r( $metaData->getDataTypes( new Invoices() ) ); ```

`getDataTypesNumeric()`

```php public function getDataTypesNumeric( ModelInterface $model ): array; ``` Returns attributes which types are numerical ```php print_r( $metaData->getDataTypesNumeric( new Invoices() ) ); ```

`getDefaultValues()`

```php public function getDefaultValues( ModelInterface $model ): array; ``` Returns attributes (which have default values) and their default values ```php print_r( $metaData->getDefaultValues( new Invoices() ) ); ```

`getEmptyStringAttributes()`

```php public function getEmptyStringAttributes( ModelInterface $model ): array; ``` Returns attributes allow empty strings ```php print_r( $metaData->getEmptyStringAttributes( new Invoices() ) ); ```

`getIdentityField()`

```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() ) ); ```

`getMetaDataUniqueKey()`

```php public final function getMetaDataUniqueKey( ModelInterface $model ): string|null; ``` Returns a MetaData Unique key for meta-data is created using className

`getModelUUID()`

```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)

`getNonPrimaryKeyAttributes()`

```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() ) ); ```

`getNotNullAttributes()`

```php public function getNotNullAttributes( ModelInterface $model ): array; ``` Returns an array of not null attributes ```php print_r( $metaData->getNotNullAttributes( new Invoices() ) ); ```

`getPrimaryKeyAttributes()`

```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() ) ); ```

`getReverseColumnMap()`

```php public function getReverseColumnMap( ModelInterface $model ): array|null; ``` Returns the reverse column map if any ```php print_r( $metaData->getReverseColumnMap( new Invoices() ) ); ```

`getStrategy()`

```php public function getStrategy(): StrategyInterface; ``` Return the strategy to obtain the meta-data

`hasAttribute()`

```php public function hasAttribute( ModelInterface $model, string $attribute ): bool; ``` Check if a model has certain attribute ```php var_dump( $metaData->hasAttribute( new Invoices(), "name" ) ); ```

`isEmpty()`

```php public function isEmpty(): bool; ``` Checks if the internal meta-data container is empty ```php var_dump( $metaData->isEmpty() ); ```

`modelEquals()`

```php public function modelEquals( ModelInterface $first, ModelInterface $other ): bool; ``` Compares if two models are the same in memory

`read()`

```php public function read( mixed $key ): array|null; ``` Reads metadata from the adapter

`readColumnMap()`

```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() ) ); ```

`readColumnMapIndex()`

```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 ) ); ```

`readMetaData()`

```php final public function readMetaData( ModelInterface $model ): array|null; ``` Reads the complete meta-data for certain model ```php print_r( $metaData->readMetaData( new Invoices() ) ); ```

`readMetaDataIndex()`

```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 ) ); ```

`reset()`

```php public function reset(): void; ``` Resets internal meta-data in order to regenerate it ```php $metaData->reset(); ```

`setAutomaticCreateAttributes()`

```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, ] ); ```

`setAutomaticUpdateAttributes()`

```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, ] ); ```

`setDI()`

```php public function setDI( DiInterface $container ): void; ``` Sets the DependencyInjector container

`setEmptyStringAttributes()`

```php public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void; ``` Set the attributes that allow empty string values ```php $metaData->setEmptyStringAttributes( new Invoices(), [ "name" => true, ] ); ```

`setStrategy()`

```php public function setStrategy( StrategyInterface $strategy ): void; ``` Set the meta-data extraction strategy

`write()`

```php public function write( string $key, array $data ): void; ``` Writes the metadata to adapter

`writeMetaDataIndex()`

```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", ] ) ); ```

Protected · 3

`initialize()`

```php final protected function initialize( ModelInterface $model, mixed $key, mixed $table, mixed $schema ); ``` Initialize old behavior for compatability

`initializeColumnMap()`

```php final protected function initializeColumnMap( ModelInterface $model, mixed $key ): bool; ``` Initialize ColumnMap for a certain table

`initializeMetaData()`

```php final protected function initializeMetaData( ModelInterface $model, mixed $key ): bool; ``` Initialize the metadata for certain table ## Mvc\Model\MetaDataInterface Interface Source on GitHub Phalcon\Mvc\Model\MetaDataInterface Interface for Phalcon\Mvc\Model\MetaData

- **`Phalcon\Mvc\Model\MetaDataInterface`**

__Uses__ `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface` ### Method Summary

### Methods

Public · 29

`getAttributes()`

```php public function getAttributes( ModelInterface $model ): array; ``` Returns table attributes names (fields)

`getAutomaticCreateAttributes()`

```php public function getAutomaticCreateAttributes( ModelInterface $model ): array; ``` Returns attributes that must be ignored from the INSERT SQL generation

`getAutomaticUpdateAttributes()`

```php public function getAutomaticUpdateAttributes( ModelInterface $model ): array; ``` Returns attributes that must be ignored from the UPDATE SQL generation

`getBindTypes()`

```php public function getBindTypes( ModelInterface $model ): array; ``` Returns attributes and their bind data types

`getColumnMap()`

```php public function getColumnMap( ModelInterface $model ): array|null; ``` Returns the column map if any

`getDataTypes()`

```php public function getDataTypes( ModelInterface $model ): array; ``` Returns attributes and their data types

`getDataTypesNumeric()`

```php public function getDataTypesNumeric( ModelInterface $model ): array; ``` Returns attributes which types are numerical

`getDefaultValues()`

```php public function getDefaultValues( ModelInterface $model ): array; ``` Returns attributes (which have default values) and their default values

`getEmptyStringAttributes()`

```php public function getEmptyStringAttributes( ModelInterface $model ): array; ``` Returns attributes allow empty strings

`getIdentityField()`

```php public function getIdentityField( ModelInterface $model ): bool|string|null; ``` Returns the name of identity field (if one is present)

`getNonPrimaryKeyAttributes()`

```php public function getNonPrimaryKeyAttributes( ModelInterface $model ): array; ``` Returns an array of fields which are not part of the primary key

`getNotNullAttributes()`

```php public function getNotNullAttributes( ModelInterface $model ): array; ``` Returns an array of not null attributes

`getPrimaryKeyAttributes()`

```php public function getPrimaryKeyAttributes( ModelInterface $model ): array; ``` Returns an array of fields which are part of the primary key

`getReverseColumnMap()`

```php public function getReverseColumnMap( ModelInterface $model ): array|null; ``` Returns the reverse column map if any

`getStrategy()`

```php public function getStrategy(): StrategyInterface; ``` Return the strategy to obtain the meta-data

`hasAttribute()`

```php public function hasAttribute( ModelInterface $model, string $attribute ): bool; ``` Check if a model has certain attribute

`isEmpty()`

```php public function isEmpty(): bool; ``` Checks if the internal meta-data container is empty

`read()`

```php public function read( string $key ): array|null; ``` Reads meta-data from the adapter

`readColumnMap()`

```php public function readColumnMap( ModelInterface $model ): array|null; ``` Reads the ordered/reversed column map for certain model

`readColumnMapIndex()`

```php public function readColumnMapIndex( ModelInterface $model, int $index ): array|null; ``` Reads column-map information for certain model using a MODEL_* constant

`readMetaData()`

```php public function readMetaData( ModelInterface $model ): array|null; ``` Reads meta-data for certain model

`readMetaDataIndex()`

```php public function readMetaDataIndex( ModelInterface $model, int $index ): array|string|null; ``` Reads meta-data for certain model using a MODEL_* constant

`reset()`

```php public function reset(); ``` Resets internal meta-data in order to regenerate it

`setAutomaticCreateAttributes()`

```php public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes ); ``` Set the attributes that must be ignored from the INSERT SQL generation

`setAutomaticUpdateAttributes()`

```php public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes ); ``` Set the attributes that must be ignored from the UPDATE SQL generation

`setEmptyStringAttributes()`

```php public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void; ``` Set the attributes that allow empty string values

`setStrategy()`

public __construct(string $completeTable,string $className)

### Methods

```php final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array; ``` Read the model's column map, this can't be inferred

`getMetaData()`

```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 Source on GitHub 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)

__Uses__ `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

### Methods

Public · 2

`getColumnMaps()`

```php final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array; ``` Read the model's column map, this can't be inferred

`getMetaData()`

- **`Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface`**

__Uses__ `Phalcon\Di\DiInterface` · `Phalcon\Mvc\ModelInterface` ### Method Summary

### Methods

Public · 2

`getColumnMaps()`

```php public function getColumnMaps( ModelInterface $model, DiInterface $container ): array; ``` Read the model's column map, this can't be inferred @todo Not implemented

`getMetaData()`

```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 Source on GitHub 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`**

__Uses__ `Phalcon\Mvc\Model\MetaData` · `Phalcon\Mvc\Model\MetaData\Exceptions\MetaDataDirectoryNotWritable` · `Phalcon\Support\Settings` · `Phalcon\Traits\Php\FileTrait` ### Method Summary

public __construct( array $options = [] ) Phalcon\Mvc\Model\MetaData\Files constructor public array|null read( mixed $key ) Reads meta-data from files public void write(mixed $key,array $data) Writes the meta-data to files

### Properties

protected string $metaDataDir = "./"

### Methods

Public · 3

`__construct()`

```php public function __construct( array $options = [] ); ``` Phalcon\Mvc\Model\MetaData\Files constructor

`read()`

```php public function read( mixed $key ): array|null; ``` Reads meta-data from files

`write()`

```php public function write( mixed $key, array $data ): void; ``` Writes the meta-data to files ## Mvc\Model\Query Class Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface)

__Uses__ `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\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

### Constants

int TYPE_DELETE = 303

int TYPE_INSERT = 306

int TYPE_SELECT = 309

int TYPE_UPDATE = 300

### Properties

protected array $ast

protected array $bindParams = []

protected array $bindTypes = []

protected mixed|null $cache = null

protected array|null $cacheOptions

protected DiInterface|null $container = null

protected bool $enableImplicitJoins

protected array $intermediate

protected array|null $internalPhqlCache

protected \Phalcon\Mvc\Model\ManagerInterface|null $manager = null

protected \Phalcon\Mvc\Model\MetaDataInterface|null $metaData = null

protected array $models = []

protected array $modelsInstances = []

protected int $nestingLevel = -1

protected string|null $phql = null

protected string $resultsetRowClass = ""

protected bool $sharedLock = false

protected array $sqlAliases = []

protected array $sqlAliasesModels = []

protected array $sqlAliasesModelsInstances = []

protected array $sqlColumnAliases = []

protected array $sqlModelsAliases = []

protected TransactionInterface|null $transaction = null 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

protected int|null $type

protected bool $uniqueRow = false

### Methods

Public · 26

`__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

`getIntermediate()`

```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

`setIntermediate()`

```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

Protected · 27

`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

`getRelatedRecords()`

```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

`refreshSchemasInIntermediate()`

```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 Source on GitHub Phalcon\Mvc\Model\QueryInterface Interface for Phalcon\Mvc\Model\Query

- **`Phalcon\Mvc\Model\QueryInterface`**

__Uses__ `Phalcon\Mvc\ModelInterface` ### Method Summary

public QueryInterface cache( array $cacheOptions ) Sets the cache parameters of the query public execute(array $bindParams = [],array $bindTypes = []) Executes a parsed PHQL statement public array getBindParams() Returns default bind params public array getBindTypes() Returns default bind types public array getCacheOptions() Returns the current cache options public ModelInterface getSingleResult(array $bindParams = [],array $bindTypes = []) Executes the query returning the first result public array getSql() Returns the SQL to be generated by the internal PHQL (only works in SELECT statements) public bool getUniqueRow() Check if the query is programmed to get only the first row in the resultset public array parse() Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another public QueryInterface setBindParams(array $bindParams,bool $merge = false) Set default bind parameters public QueryInterface setBindTypes(array $bindTypes,bool $merge = false) Set default bind parameters public QueryInterface setSharedLock( bool $sharedLock = false ) Set SHARED LOCK clause public QueryInterface setUniqueRow( bool $uniqueRow ) Tells to the query if only the first row in the resultset must be returned

### Methods

Public · 13

`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()`

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface)

__Uses__ `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

### Properties

protected array $bindParams = []

protected array $bindTypes = []

protected array|string|null $columns = null

protected array|string|null $conditions = null

protected DiInterface|null $container

protected mixed $distinct = null

protected bool $forUpdate = false

protected array $group = []

protected string|null $having = null

protected int $hiddenParamNumber = 0

protected array $joins = []

protected array|string $limit

protected array|string $models

protected int $offset = 0

protected array|string $order

protected string $resultsetRowClass = ""

protected bool $sharedLock = false

### Methods

Public · 50

`__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()`

`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, ] ); ```

Protected · 4

`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 Source on GitHub Interface for Phalcon\Mvc\Model\Query\Builder

- **`Phalcon\Mvc\Model\Query\BuilderInterface`**

__Uses__ `Phalcon\Mvc\Model\QueryInterface` ### Method Summary

### Constants

string OPERATOR_AND = "and"

string OPERATOR_OR = "or"

### Methods

Public · 38

`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()`

`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()`

`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()`

public __construct(bool $success,ModelInterface|null $model = null) Phalcon\Mvc\Model\Query\Status public MessageInterface[] getMessages() Returns the messages produced because of a failed operation public ModelInterface|null getModel() Returns the model that executed the action public bool success() Allows to check if the executed operation was successful

### Properties

protected ModelInterface|null $model

protected bool $success

### Methods

Public · 4

`__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 Source on GitHub Interface for Phalcon\Mvc\Model\Query\Status

- **`Phalcon\Mvc\Model\Query\StatusInterface`**

__Uses__ `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface` ### Method Summary

public MessageInterface[] getMessages() Returns the messages produced by an operation failed public ModelInterface|null getModel() Returns the model which executed the action public bool success() Allows to check if the executed operation was successful

### Methods

Public · 3

`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 Source on GitHub Phalcon\Mvc\Model\Relation This class represents a relationship between two models

- **`Phalcon\Mvc\Model\Relation`** - implements [`Phalcon\Mvc\Model\RelationInterface`](#mvcmodelrelationinterface)

### Method Summary

public __construct(int $type,string $referencedModel,mixed $fields,mixed $referencedFields,array $options = []) Phalcon\Mvc\Model\Relation constructor public getFields() Returns the fields public getForeignKey() Returns the foreign key configuration public getIntermediateFields() Gets the intermediate fields for has-*-through relations public string getIntermediateModel() Gets the intermediate model for has-*-through relations public getIntermediateReferencedFields() Gets the intermediate referenced fields for has-*-through relations public getOption( string $name ) Returns an option by the specified name public array getOptions() Returns the options public getParams() Returns parameters that must be always used when the related records are obtained public getReferencedFields() Returns the referenced fields public string getReferencedModel() Returns the referenced model public int getType() Returns the relation type public bool isForeignKey() Check whether the relation act as a foreign key public bool isReusable() Check if records returned by getting belongs-to/has-many are implicitly cached during the current request public bool isThrough() Check whether the relation is a 'many-to-many' relation or not public setIntermediateRelation(mixed $intermediateFields,string $intermediateModel,mixed $intermediateReferencedFields) Sets the intermediate model data for has-*-through relations

### Constants

int ACTION_CASCADE = 2

int ACTION_RESTRICT = 1

int BELONGS_TO = 0

int HAS_MANY = 2

int HAS_MANY_THROUGH = 4

int HAS_ONE = 1

int HAS_ONE_THROUGH = 3

int NO_ACTION = 0

### Properties

protected array|string $fields

protected array|string $intermediateFields

protected string|null $intermediateModel = null

protected array|string $intermediateReferencedFields

protected array $options = []

protected array|string $referencedFields

protected string $referencedModel

protected int $type

### Methods

Public · 16

`__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

`getIntermediateFields()`

```php public function getIntermediateFields(); ``` Gets the intermediate fields for has-*-through relations

`getIntermediateModel()`

```php public function getIntermediateModel(): string; ``` Gets the intermediate model for has-*-through relations

`getIntermediateReferencedFields()`

```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

`setIntermediateRelation()`

```php public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields ); ``` Sets the intermediate model data for has-*-through relations ## Mvc\Model\RelationInterface Interface Source on GitHub Phalcon\Mvc\Model\RelationInterface Interface for Phalcon\Mvc\Model\Relation

- **`Phalcon\Mvc\Model\RelationInterface`**

### Method Summary

public getFields() Returns the fields public getForeignKey() Returns the foreign key configuration public getIntermediateFields() Gets the intermediate fields for has-*-through relations public string getIntermediateModel() Gets the intermediate model for has-*-through relations public getIntermediateReferencedFields() Gets the intermediate referenced fields for has-*-through relations public getOption( string $name ) Returns an option by the specified name public array getOptions() Returns the options public getParams() Returns parameters that must be always used when the related records are obtained public getReferencedFields() Returns the referenced fields public string getReferencedModel() Returns the referenced model public int getType() Returns the relations type public bool isForeignKey() Check whether the relation act as a foreign key public bool isReusable() Check if records returned by getting belongs-to/has-many are implicitly cached during the current request public bool isThrough() Check whether the relation is a 'many-to-many' relation or not public setIntermediateRelation(mixed $intermediateFields,string $intermediateModel,mixed $intermediateReferencedFields) Sets the intermediate model data for has-*-through relations

### Methods

Public · 15

`getFields()`

```php public function getFields(); ``` Returns the fields

`getForeignKey()`

```php public function getForeignKey(); ``` Returns the foreign key configuration

`getIntermediateFields()`

```php public function getIntermediateFields(); ``` Gets the intermediate fields for has-*-through relations

`getIntermediateModel()`

```php public function getIntermediateModel(): string; ``` Gets the intermediate model for has-*-through relations

`getIntermediateReferencedFields()`

```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

`setIntermediateRelation()`

```php public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields ); ``` Sets the intermediate model data for has-*-through relations ## Mvc\Model\ResultInterface Interface Source on GitHub Phalcon\Mvc\Model\ResultInterface All single objects passed as base objects to Resultsets must implement this interface

- **`Phalcon\Mvc\Model\ResultInterface`**

__Uses__ `Phalcon\Mvc\ModelInterface` ### Method Summary

public ModelInterface|bool setDirtyState( int $dirtyState ) Sets the object's state

### Methods

Public · 1

`setDirtyState()`

```php public function setDirtyState( int $dirtyState ): ModelInterface|bool; ``` Sets the object's state ## Mvc\Model\Resultset Abstract Source on GitHub 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)

__Uses__ `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

### Constants

int HYDRATE_ARRAYS = 1

int HYDRATE_OBJECTS = 2

int HYDRATE_RECORDS = 0

int TYPE_RESULT_FULL = 0

int TYPE_RESULT_PARTIAL = 1

### Properties

protected mixed|null $activeRow = null

protected CacheInterface|null $cache = null

protected int|null $count = null 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.

protected array $errorMessages = []

protected int $hydrateMode = 0

protected bool $isFresh = true

protected int $pointer = 0

protected ResultInterface|bool $result Phalcon\Db\ResultInterface or false for empty resultset

protected mixed|null $row = null

protected array|null $rows = null

### Methods

Public · 27

`__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 Source on GitHub Phalcon\Mvc\Model\ResultsetInterface Interface for Phalcon\Mvc\Model\Resultset

- **`Phalcon\Mvc\Model\ResultsetInterface`**

__Uses__ `Closure` · `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface` ### Method Summary

public bool delete( Closure|null $conditionCallback = null ) Deletes every record in the resultset public ModelInterface[] filter( callable $filter ) Filters a resultset returning only those the developer requires public mixed|null getCache() Returns the associated cache for the resultset public mixed|null getFirst() Get first row in the resultset public int getHydrateMode() Returns the current hydration mode public ModelInterface|null getLast() Get last row in the resultset public MessageInterface[] getMessages() Returns the error messages produced by a batch operation public int getType() Returns the internal type of data retrieval that the resultset is using public bool isFresh() Tell if the resultset if fresh or an old one cached public ResultsetInterface setHydrateMode( int $hydrateMode ) Sets the hydration mode in the resultset public ResultsetInterface setIsFresh( bool $isFresh ) Set if the resultset is fresh or an old one cached public array toArray() Returns a complete resultset as an array, if the resultset has a big number of rows public bool update(mixed $data,Closure|null $conditionCallback = null) Updates every record in the resultset

### Methods

Public · 13

`delete()`

```php public function delete( Closure|null $conditionCallback = null ): bool; ``` Deletes every record in the resultset

`filter()`

`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 Source on GitHub 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`**

__Uses__ `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

public __construct(mixed $columnTypes,ResultInterface|null $result = null,mixed $cache = null,string $resultsetRowClass = "") Phalcon\Mvc\Model\Resultset\Complex constructor public array __serialize() public void __unserialize( array $data ) public mixed current() Returns current row in the resultset public string serialize() Serializing a resultset will dump all related rows into a big array, public array toArray() Returns a complete resultset as an array, if the resultset has a big public void unserialize( mixed $data ) Unserializing a resultset will allow to only works on the rows present in the saved state

### Properties

protected array $columnTypes

protected bool $disableHydration = false Unserialised result-set hydrated all rows already. unserialise() sets disableHydration to true

protected string $resultsetRowClass = ""

### Methods

Public · 7

`__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 Source on GitHub 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`**

__Uses__ `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

public __construct(mixed $columnMap,mixed $model,mixed $result,mixed $cache = null,bool $keepSnapshots = false) Phalcon\Mvc\Model\Resultset\Simple constructor public array __serialize() public void __unserialize( array $data ) public ModelInterface|Row|null current() Returns current row in the resultset public string serialize() Serializing a resultset will dump all related rows into a big array public void setEagerMap( array $eagerMap ) Attaches a pre-loaded relation map, applied to every record as it is public Simple sliceRows( array $indexes ) Builds a new resultset of the same concrete class over the rows at the public array toArray( bool $renameColumns = true ) Returns a complete resultset as an array, if the resultset has a big public void unserialize( mixed $data ) Unserializing a resultset will allow to only works on the rows present in

### Properties

protected array|string $columnMap

protected array|null $eagerMap = null

protected bool $keepSnapshots = false

protected ModelInterface|Row $model

### Methods

Public · 9

`__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 Source on GitHub 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`

__Uses__ `ArrayAccess` · `JsonSerializable` · `Phalcon\Mvc\EntityInterface` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Exceptions\IndexNotInRow` · `Phalcon\Mvc\Model\Exceptions\RowIsImmutable` ### Method Summary

public array jsonSerialize() Serializes the object for json_encode public bool offsetExists( mixed $index ) Checks whether offset exists in the row. Returns true when the property public mixed offsetGet( mixed $index ) Gets a record in a specific position of the row public void offsetSet(mixed $offset,mixed $value) Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface public void offsetUnset( mixed $offset ) Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface public readAttribute( string $attribute ) Reads an attribute value by its name public ModelInterface|bool setDirtyState( int $dirtyState ) Set the current object's state public array toArray() Returns the instance as an array representation public void writeAttribute(string $attribute,mixed $value) Writes an attribute value by its name

### Methods

Public · 9

`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 Source on GitHub 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)

__Uses__ `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

public __construct(DiInterface $container,bool $autoBegin = false,string $service = "db") Phalcon\Mvc\Model\Transaction constructor public bool begin() Starts the transaction public bool commit() Commits the transaction public AdapterInterface getConnection() Returns the connection related to transaction public array getMessages() Returns validations messages from last save try public bool isManaged() Checks whether transaction is managed by a transaction manager public bool isValid() Checks whether internal connection is under an active transaction public bool rollback(string|null $rollbackMessage = null,ModelInterface|null $rollbackRecord = null) Rollbacks the transaction public void setIsNewTransaction( bool $isNew ) Sets if is a reused transaction or new once public void setRollbackOnAbort( bool $rollbackOnAbort ) Sets flag to rollback on abort the HTTP connection public void setRollbackedRecord( ModelInterface $record ) Sets object which generates rollback action public void setTransactionManager( ManagerInterface $manager ) Sets transaction manager related to the transaction public TransactionInterface throwRollbackException( bool $status ) Enables throwing exception

### Properties

protected bool $activeTransaction = false

protected AdapterInterface $connection

protected bool $isNewTransaction = true

protected ManagerInterface|null $manager = null

protected array $messages = []

protected bool $rollbackOnAbort = false

protected ModelInterface|null $rollbackRecord = null

protected bool $rollbackThrowException = false

### Methods

Public · 13

`__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 Source on GitHub Interface for Phalcon\Mvc\Model\Transaction

- **`Phalcon\Mvc\Model\TransactionInterface`**

__Uses__ `Phalcon\Mvc\ModelInterface` · `Phalcon\Mvc\Model\Transaction\ManagerInterface` ### Method Summary

public bool begin() Starts the transaction public bool commit() Commits the transaction public \Phalcon\Db\Adapter\AdapterInterface getConnection() Returns connection related to transaction public array getMessages() Returns validations messages from last save try public bool isManaged() Checks whether transaction is managed by a transaction manager public bool isValid() Checks whether internal connection is under an active transaction public bool rollback(string|null $rollbackMessage = null,ModelInterface|null $rollbackRecord = null) Rollbacks the transaction public void setIsNewTransaction( bool $isNew ) Sets if is a reused transaction or new once public void setRollbackOnAbort( bool $rollbackOnAbort ) Sets flag to rollback on abort the HTTP connection public void setRollbackedRecord( ModelInterface $record ) Sets object which generates rollback action public void setTransactionManager( ManagerInterface $manager ) Sets transaction manager related to the transaction public TransactionInterface throwRollbackException( bool $status ) Enables throwing exception

### Methods

Public · 12

`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 Source on GitHub 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 Source on GitHub 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`**

__Uses__ `Phalcon\Messages\MessageInterface` · `Phalcon\Mvc\ModelInterface` ### Method Summary

public __construct(string $message,ModelInterface|null $record = null) Phalcon\Mvc\Model\Transaction\Failed constructor public ModelInterface|null getRecord() Returns validation record messages which stop the transaction public array|string getRecordMessages() Returns validation record messages which stop the transaction

### Properties

protected ModelInterface|null $record = null

### Methods

Public · 3

`__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 Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface)

__Uses__ `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\InjectionAwareInterface` · `Phalcon\Mvc\Model\Exceptions\ManagerOrmServicesUnavailable` · `Phalcon\Mvc\Model\Transaction` · `Phalcon\Mvc\Model\TransactionInterface` ### Method Summary

public __construct( DiInterface|null $container = null ) Phalcon\Mvc\Model\Transaction\Manager constructor public void collectTransactions() Remove all the transactions from the manager public commit() Commits active transactions within the manager public TransactionInterface get( bool $autoBegin = true ) Returns a new \Phalcon\Mvc\Model\Transaction or an already created once public DiInterface getDI() Returns the dependency injection container public string getDbService() Returns the database service used to isolate the transaction public TransactionInterface getOrCreateTransaction( bool $autoBegin = true ) Create/Returns a new transaction or an existing one public bool getRollbackPendent() Check if the transaction manager is registering a shutdown function to public bool has() Checks whether the manager has an active transaction public void notifyCommit( TransactionInterface $transaction ) Notifies the manager about a committed transaction public void notifyRollback( TransactionInterface $transaction ) Notifies the manager about a rollbacked transaction public void rollback( bool $collect = true ) Rollbacks active transactions within the manager public void rollbackPendent() Rollbacks active transactions within the manager public void setDI( DiInterface $container ) Sets the dependency injection container public ManagerInterface setDbService( string $service ) Sets the database service used to run the isolated transactions public ManagerInterface setRollbackPendent( bool $rollbackPendent ) Set if the transaction manager must register a shutdown function to clean protected void collectTransaction( TransactionInterface $transaction ) Removes transactions from the TransactionManager

### Properties

protected DiInterface|null $container

protected bool $initialized = false

protected int $number = 0

protected bool $rollbackPendent = true

protected string $service = "db"

protected array $transactions = []

### Methods

Public · 16

`__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

Protected · 1

`collectTransaction()`

```php protected function collectTransaction( TransactionInterface $transaction ): void; ``` Removes transactions from the TransactionManager ## Mvc\Model\Transaction\ManagerInterface Interface Source on GitHub Phalcon\Mvc\Model\Transaction\ManagerInterface Interface for Phalcon\Mvc\Model\Transaction\Manager

- **`Phalcon\Mvc\Model\Transaction\ManagerInterface`**

__Uses__ `Phalcon\Mvc\Model\TransactionInterface` ### Method Summary

public void collectTransactions() Remove all the transactions from the manager public commit() Commits active transactions within the manager public TransactionInterface get( bool $autoBegin = true ) Returns a new \Phalcon\Mvc\Model\Transaction or an already created once public string getDbService() Returns the database service used to isolate the transaction public bool getRollbackPendent() Check if the transaction manager is registering a shutdown function to clean up pendent transactions public bool has() Checks whether manager has an active transaction public void notifyCommit( TransactionInterface $transaction ) Notifies the manager about a committed transaction public void notifyRollback( TransactionInterface $transaction ) Notifies the manager about a rollbacked transaction public void rollback( bool $collect = false ) Rollbacks active transactions within the manager public void rollbackPendent() Rollbacks active transactions within the manager public ManagerInterface setDbService( string $service ) Sets the database service used to run the isolated transactions public ManagerInterface setRollbackPendent( bool $rollbackPendent ) Set if the transaction manager must register a shutdown function to clean up pendent transactions

### Methods

Public · 12

`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 Source on GitHub 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`**

__Uses__ `Phalcon\Messages\Message` · `Phalcon\Mvc\ModelInterface` ### Method Summary

public __construct(ModelInterface $model,array $validationMessages) Phalcon\Mvc\Model\ValidationFailed constructor public Message[] getMessages() Returns the complete group of messages produced in the validation public ModelInterface getModel() Returns the model that generated the messages

### Properties

protected ModelInterface $model

protected array $validationMessages = []

### Methods

Public · 3

`__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 Source on GitHub This interface must be implemented by class module definitions

- **`Phalcon\Mvc\ModuleDefinitionInterface`**

__Uses__ `Phalcon\Di\DiInterface` ### Method Summary

public registerAutoloaders( DiInterface|null $container = null ) Registers an autoloader related to the module public registerServices( DiInterface $container ) Registers services related to the module

### Methods

Public · 2

`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 Source on GitHub 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.19/api/phalcon_di/#diabstractinjectionaware) - **`Phalcon\Mvc\Router`** - implements [`Phalcon\Mvc\RouterInterface`](#mvcrouterinterface), [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface) - [`Phalcon\Mvc\Router\Annotations`](#mvcrouterannotations)

__Uses__ `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

### Constants

int POSITION_FIRST = 0

int POSITION_LAST = 1

int REGEX_CHUNK_SIZE = 10 Number of alternatives per combined-regex chunk. Empirically derived (FastRoute uses ~10) - keeps each chunk below PCRE's optimizer cliff.

int URI_SOURCE_GET_URL = 0

int URI_SOURCE_SERVER_REQUEST_URI = 1

### Properties

protected string $action = ""

protected array $candidatesByMethod = [] 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.

protected array $combinedRegexByMethod = [] 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.

protected array $combinedRegexDisabled = [] Boolean per method bucket: true when the combined regex cannot be built (hostname route present, exotic pattern shape, etc.).

protected array $combinedRegexMarkMap = [] Map from MARK label back to the route index in candidatesByMethod[method]. One per chunk. combinedRegexMarkMap[method][chunkIdx][markLabel] = routeIdx

protected string $controller = ""

protected string $defaultAction = ""

protected string $defaultController = ""

protected string $defaultModule = ""

protected string $defaultNamespace = ""

protected array $defaultParams = []

protected ManagerInterface|null $eventsManager

protected array $hostnameByMethod = [] 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.

protected array $hostnameLessByMethod = [] Per-method indices of routes without a hostname constraint, in attach order. Shape: hostnameLessByMethod[method] = list of route indices into candidatesByMethod[method].

protected array $keyRouteIds = []

protected array $keyRouteNames = []

protected RouteInterface|null $matchedRoute = null

protected array $matches = []

protected array $methodRoutes = []

protected bool $methodRoutesDirty = true

protected string $module = ""

protected string $namespaceName = ""

protected array|string|null $notFoundPaths = null

protected array $params = []

protected CacheAdapterInterface|null $pendingCache = null 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.

protected string $pendingCacheKey = ""

protected bool $removeExtraSlashes = false

protected array $routeMeta = [] 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 ]

protected array $routes = []

protected array $staticByMethod = [] 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.

protected array $staticShadowedByMethod = [] 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).

protected int $uriSource = self::URI_SOURCE_GET_URL

protected bool $wasMatched = false

### Methods

Public · 51

`__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

`removeExtraSlashes()`

```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

Protected · 4

`addRouteFromConfig()`

```php protected function addRouteFromConfig( array $routeData ): void; ``` Adds a single route from a config array entry. Used by loadFromConfig.

`extractRealUri()`

```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 Source on GitHub Interface for Phalcon\Mvc\Router

- **`Phalcon\Mvc\RouterInterface`**

__Uses__ `Phalcon\Mvc\Router\GroupInterface` · `Phalcon\Mvc\Router\RouteInterface` ### Method Summary

### Methods

Public · 31

`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()`

`addDelete()`

`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()`

`addOptions()`

`addPatch()`

`addPost()`

`addPurge()`

`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()`

`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 Source on GitHub 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.19/api/phalcon_di/#diabstractinjectionaware) - [`Phalcon\Mvc\Router`](#mvcrouter) - **`Phalcon\Mvc\Router\Annotations`**

__Uses__ `Phalcon\Annotations\Annotation` · `Phalcon\Di\DiInterface` · `Phalcon\Mvc\Router` · `Phalcon\Mvc\Router\Exceptions\AnnotationsServiceUnavailable` · `Phalcon\Mvc\Router\Exceptions\InvalidCallbackParameter` ### Method Summary

public static addModuleResource(string $module,string $handler,string|null $prefix = null) Adds a resource to the annotations handler public static addResource(string $handler,string|null $prefix = null) Adds a resource to the annotations handler public getActionPreformatCallback() public array getResources() Return the registered resources public void handle( string $uri ) Produce the routing parameters from the rewrite information public void processActionAnnotation(string $module,string $namespaceName,string $controller,string $action,Annotation $annotation) Checks for annotations in the public methods of the controller public processControllerAnnotation(string $handler,Annotation $annotation) Checks for annotations in the controller docblock public self setActionPreformatCallback( mixed $callback = null ) Sets the action preformat callback public self setActionSuffix( string $actionSuffix ) Changes the action method suffix public self setControllerSuffix( string $controllerSuffix ) Changes the controller class suffix

### Properties

protected callable|string|null $actionPreformatCallback = null

protected string $actionSuffix = "Action"

protected string $controllerSuffix = "Controller"

protected array $handlers = []

protected string $routePrefix = ""

### Methods

Public · 10

`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

`getActionPreformatCallback()`

```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

`setActionPreformatCallback()`

```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 Source on GitHub 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)

```php public function __construct( string $part ); ``` ## Mvc\Router\Group Class Source on GitHub 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

### Properties

protected callable|null $beforeMatch = null

protected string|null $hostname = null

protected array|string|null $paths = null

protected string|null $prefix = null

protected array $routes = []

### Methods

Public · 22

`__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

Protected · 1

`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 Source on GitHub ```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

### Methods

Public · 21

`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()`

`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 Source on GitHub This class represents every route added to the router

- **`Phalcon\Mvc\Router\Route`** - implements [`Phalcon\Mvc\Router\RouteInterface`](#mvcrouterrouteinterface)

__Uses__ `Phalcon\Mvc\Router\Exceptions\InvalidRoutePaths` ### Method Summary

### Properties

protected callable|null $beforeMatch = null

protected string|null|false $compiledHostName = false 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."

protected string|null $compiledPattern = null

protected array $converters = []

protected GroupInterface|null $group = null

protected string|null $hostname = null

protected callable|null $match = null

protected array|string|null $methods = []

protected string|null $name = null

protected array $paths = []

protected string $pattern

protected string $routeId = ""

protected int $uniqueId = 0

### Methods

Public · 28

`__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\}

`extractNamedParams()`

```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); } ); ```

`reConfigure()`

```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 Source on GitHub Interface for Phalcon\Mvc\Router\Route

- **`Phalcon\Mvc\Router\RouteInterface`**

### Method Summary

public string compilePattern( string $pattern ) Replaces placeholders from pattern returning a valid PCRE regular expression public RouteInterface convert(string $name,mixed $converter) Adds a converter to perform an additional transformation for certain parameter. public string getCompiledPattern() Returns the route's pattern public string|null getHostname() Returns the hostname restriction if any public array|string|null getHttpMethods() Returns the HTTP methods that constraint matching the route public string|null getName() Returns the route's name public array getPaths() Returns the paths public string getPattern() Returns the route's pattern public array getReversedPaths() Returns the paths using positions as keys and names as values public string getRouteId() Returns the route's id public void reConfigure(string $pattern,mixed $paths = null) Reconfigure the route adding a new pattern and a set of paths public void reset() Resets the internal route id generator public RouteInterface setHostname( string $hostname ) Sets a hostname restriction to the route public RouteInterface setHttpMethods( mixed $httpMethods ) Sets a set of HTTP methods that constraint the matching of the route public RouteInterface setName( string $name ) Sets the route's name public RouteInterface setRouteId( string $routeId ) Sets the route's id (intended for restoring cached routes) public RouteInterface via( mixed $httpMethods ) Set one or more HTTP methods that constraint the matching of the route

### Methods

Public · 17

`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

`reConfigure()`

```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 Source on GitHub 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`**

__Uses__ `Phalcon\Config\ConfigInterface` · `Phalcon\Mvc\Router` · `Phalcon\Mvc\RouterInterface` · `Phalcon\Mvc\Router\Exceptions\InvalidRouterFactoryConfig` ### Method Summary

public RouterInterface load( mixed $config ) Builds a Router from a config array or ConfigInterface and loads routes. public RouterInterface newInstance( bool $defaultRoutes = true ) Returns a bare Router instance.

### Methods

Public · 2

`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 Source on GitHub 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.19/api/phalcon_di/#diabstractinjectionaware) - **`Phalcon\Mvc\Url`** - implements [`Phalcon\Mvc\Url\UrlInterface`](#mvcurlurlinterface)

__Uses__ `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

public __construct( RouterInterface|null $router = null ) public string get(mixed $uri = null,mixed $arguments = null,bool|null $local = null,mixed $baseUri = null,bool $replaceArgs = false) Generates a URL public string|null getBasePath() Returns the base path public string getBaseUri() Returns the prefix for all the generated urls. By default / public string getStatic( mixed $uri = null ) Generates a URL for a static resource public string getStaticBaseUri() Returns the prefix for all the generated static urls. By default / public string path( string|null $path = null ) Generates a local path public UrlInterface setBasePath( string $basePath ) Sets a base path for all the generated paths public UrlInterface setBaseUri( string $baseUri ) Sets a prefix for all the URIs to be generated public UrlInterface setStaticBaseUri( string $staticBaseUri ) Sets a prefix for all static URLs generated

### Properties

protected null|string $basePath = null

protected null|string $baseUri = null

protected RouterInterface|null $router = null

protected null|string $staticBaseUri = null

### Methods

Public · 10

`__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 Source on GitHub 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 Source on GitHub

- `\Exception` - [`Phalcon\Mvc\Url\Exception`](#mvcurlexception) - **`Phalcon\Mvc\Url\Exceptions\MissingRouteName`**

__Uses__ `Phalcon\Mvc\Url\Exception` ### Method Summary

public __construct()

### Methods

Public · 1

`__construct()`

```php public function __construct(); ``` ## Mvc\Url\Exceptions\RouteNotFound Class Source on GitHub

- `\Exception` - [`Phalcon\Mvc\Url\Exception`](#mvcurlexception) - **`Phalcon\Mvc\Url\Exceptions\RouteNotFound`**

__Uses__ `Phalcon\Mvc\Url\Exception` ### Method Summary

public __construct( string $name )

### Methods

Public · 1

`__construct()`

```php public function __construct( string $name ); ``` ## Mvc\Url\Exceptions\RouterServiceUnavailable Class Source on GitHub

- `\Exception` - [`Phalcon\Mvc\Url\Exception`](#mvcurlexception) - **`Phalcon\Mvc\Url\Exceptions\RouterServiceUnavailable`**

__Uses__ `Phalcon\Mvc\Url\Exception` ### Method Summary

public __construct()

### Methods

Public · 1

`__construct()`

```php public function __construct(); ``` ## Mvc\Url\UrlInterface Interface Source on GitHub Interface for Phalcon\Mvc\Url\UrlInterface

- **`Phalcon\Mvc\Url\UrlInterface`**

### Method Summary

public string get(mixed $uri = null,mixed $arguments = null,bool|null $local = null,mixed $baseUri = null,bool $replaceArgs = false) Generates a URL public string|null getBasePath() Returns a base path public string getBaseUri() Returns the prefix for all the generated urls. By default / public string path( string|null $path = null ) Generates a local path public UrlInterface setBasePath( string $basePath ) Sets a base paths for all the generated paths public UrlInterface setBaseUri( string $baseUri ) Sets a prefix to all the urls generated

### Methods

Public · 6

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectable) - **`Phalcon\Mvc\View`** - implements [`Phalcon\Mvc\ViewInterface`](#mvcviewinterface), [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface)

__Uses__ `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

### Constants

int LEVEL_ACTION_VIEW = 1 Render Level: To the action view

int LEVEL_AFTER_TEMPLATE = 4 Render Level: Render to the templates "after"

int LEVEL_BEFORE_TEMPLATE = 2 Render Level: To the templates "before"

int LEVEL_LAYOUT = 3 Render Level: To the controller layout

int LEVEL_MAIN_LAYOUT = 5 Render Level: To the main layout

int LEVEL_NO_RENDER = 0 Render Level: No render any view

### Properties

protected string $actionName

protected array $activeRenderPaths

protected string $basePath = ""

protected string $controllerName

protected int $currentRenderLevel = 0

protected bool $disabled = false

protected array $disabledLevels = []

protected array|bool $engines = false

protected ManagerInterface|null $eventsManager

protected string|null $layout = null

protected string $layoutsDir = ""

protected string $mainView = "index"

protected array $options = []

protected array $params = []

protected string $partialsDir = ""

protected array|null $pickView

protected int $renderLevel = 5

protected array $templatesAfter = []

protected array $templatesBefore = []

protected array $viewsDirs = []

### Methods

Public · 47

`__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

Protected · 4

`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 Source on GitHub Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple

- **`Phalcon\Mvc\ViewBaseInterface`** - [`Phalcon\Mvc\ViewInterface`](#mvcviewinterface)

__Uses__ `Phalcon\Cache\Adapter\AdapterInterface` ### Method Summary

public string getContent() Returns cached output from another view stage public array getParamsToView() Returns parameters to views public string|array getViewsDir() Gets views directory public partial(string $partialPath,mixed $params = null) Renders a partial view public setContent( string $content ) Externally sets the view content public setParamToView(string $key,mixed $value) Adds parameters to views (alias of setVar) public setVar(string $key,mixed $value) Adds parameters to views public setViewsDir( string $viewsDir ) Sets views directory. Depending of your platform, always add a trailing

### Methods

Public · 8

`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 Source on GitHub Interface for Phalcon\Mvc\View

- [`Phalcon\Mvc\ViewBaseInterface`](#mvcviewbaseinterface) - **`Phalcon\Mvc\ViewInterface`**

### Method Summary

public cleanTemplateAfter() Resets any template before layouts public cleanTemplateBefore() Resets any template before layouts public disable() Disables the auto-rendering process public enable() Enables the auto-rendering process public finish() Finishes the render process by stopping the output buffering public string getActionName() Gets the name of the action rendered public string|array getActiveRenderPath() Returns the path of the view that is currently rendered public string getBasePath() Gets base path public string getControllerName() Gets the name of the controller rendered public string|null getLayout() Returns the name of the main view public string getLayoutsDir() Gets the current layouts sub-directory public string getMainView() Returns the name of the main view public string getPartialsDir() Gets the current partials sub-directory public bool isDisabled() Whether the automatic rendering is disabled public pick( string $renderView ) Choose a view different to render than last-controller/last-action public registerEngines( array $engines ) Register templating engines public ViewInterface|bool render(string $controllerName,string $actionName,array $params = []) Executes render process from dispatching data public reset() Resets the view component to its factory default values public setBasePath( string $basePath ) Sets base path. Depending of your platform, always add a trailing slash public setLayout( string $layout ) Change the layout to be used instead of using the name of the latest public setLayoutsDir( string $layoutsDir ) Sets the layouts sub-directory. Must be a directory under the views public setMainView( string $viewPath ) Sets default view name. Must be a file without extension in the views public setPartialsDir( string $partialsDir ) Sets a partials sub-directory. Must be a directory under the views public ViewInterface setRenderLevel( int $level ) Sets the render level for the view public setTemplateAfter( mixed $templateAfter ) Appends template after controller layout public setTemplateBefore( mixed $templateBefore ) Appends template before controller layout public start() Starts rendering process enabling the output buffering

### Methods

Public · 27

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectable) - **`Phalcon\Mvc\View\Engine\AbstractEngine`** - implements [`Phalcon\Mvc\View\Engine\EngineInterface`](#mvcviewengineengineinterface), [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface) - [`Phalcon\Mvc\View\Engine\Php`](#mvcviewenginephp) - [`Phalcon\Mvc\View\Engine\Volt`](#mvcviewenginevolt)

__Uses__ `Phalcon\Di\DiInterface` · `Phalcon\Di\Injectable` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Mvc\ViewBaseInterface` ### Method Summary

public __construct(ViewBaseInterface $view,DiInterface|null $container = null) Phalcon\Mvc\View\Engine constructor public string getContent() Returns cached output on another view stage public ManagerInterface|null getEventsManager() Returns the internal event manager public ViewBaseInterface getView() Returns the view component related to the adapter public void partial(string $partialPath,mixed $params = null) Renders a partial inside another view public void setEventsManager( ManagerInterface $eventsManager ) Sets the events manager protected mixed|bool fireManagerEvent(string $eventName,mixed $data = null,bool $cancellable = true) Helper method to fire an event

### Properties

protected ManagerInterface|null $eventsManager = null

protected ViewBaseInterface $view

### Methods

Public · 6

`__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

Protected · 1

`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 Source on GitHub Interface for Phalcon\Mvc\View engine adapters

- **`Phalcon\Mvc\View\Engine\EngineInterface`**

### Method Summary

public string getContent() Returns cached output on another view stage public void partial(string $partialPath,mixed $params = null) Renders a partial inside another view public render(string $path,mixed $params,bool $mustClean = false) Renders a view using the template engine

### Methods

Public · 3

`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 Source on GitHub Adapter to use PHP itself as templating engine

- `\stdClass` - [`Phalcon\Di\Injectable`](/5.19/api/phalcon_di/#diinjectable) - [`Phalcon\Mvc\View\Engine\AbstractEngine`](#mvcviewengineabstractengine) - **`Phalcon\Mvc\View\Engine\Php`**

### Method Summary

public render(string $path,mixed $params,bool $mustClean = false) Renders a view using the template engine

### Methods

Public · 1

`render()`

```php public function render( string $path, mixed $params, bool $mustClean = false ); ``` Renders a view using the template engine ## Mvc\View\Engine\Volt Class Source on GitHub Designer friendly and fast template engine for PHP written in Zephir/C

- `\stdClass` - [`Phalcon\Di\Injectable`](/5.19/api/phalcon_di/#diinjectable) - [`Phalcon\Mvc\View\Engine\AbstractEngine`](#mvcviewengineabstractengine) - **`Phalcon\Mvc\View\Engine\Volt`** - implements [`Phalcon\Events\EventsAwareInterface`](/5.19/api/phalcon_events/#eventseventsawareinterface)

__Uses__ `Phalcon\Di\DiInterface` · `Phalcon\Events\EventsAwareInterface` · `Phalcon\Events\ManagerInterface` · `Phalcon\Html\Link\Link` · `Phalcon\Html\Link\Serializer\Header` · `Phalcon\Mvc\View\Engine\Volt\Compiler` · `Phalcon\Mvc\View\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

public mixed callMacro(string $name,array $arguments = []) Checks if a macro is defined and calls it public string convertEncoding(string $text,string $from,string $to) Performs a string conversion public Compiler getCompiler() Returns the Volt's compiler public ManagerInterface|null getEventsManager() Returns the internal event manager public array getOptions() Return Volt's options public bool isIncluded(mixed $needle,mixed $haystack) Checks if the needle is included in the haystack public int length( mixed $item ) Length filter. If an array/object is passed a count is performed otherwise a strlen/mb_strlen public string preload( mixed $parameters ) Parses the preload element passed and sets the necessary link headers public render(string $path,mixed $params,bool $mustClean = false) Renders a view using the template engine public void setEventsManager( ManagerInterface $eventsManager ) Sets the events manager public setOptions( array $options ) Set Volt's options public slice(mixed $value,int $start = 0,mixed $end = null) Extracts a slice from a string/array/traversable object value public array sort( array $value ) Sorts an array

### Properties

protected Compiler $compiler

protected ManagerInterface|null $eventsManager

protected array $macros = []

protected array $options = []

### Methods

Public · 13

`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 Source on GitHub 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.19/api/phalcon_di/#diinjectionawareinterface)

__Uses__ `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

### Properties

protected bool $autoescape = false

protected int $blockLevel = 0

protected array|null $blocks TODO: Make array only?

protected string|null $compiledTemplatePath

protected DiInterface|null $container = null

protected string|null $currentBlock = null

protected string|null $currentPath = null

protected int $exprLevel = 0

protected bool $extended = false

protected array|bool $extendedBlocks TODO: Make it always array

protected array $extensions = []

protected array $filters = []

protected array $forElsePointers = []

protected int $foreachLevel = 0

protected array $functions = []

protected int $level = 0

protected array $loopPointers = []

protected array $macros = []

protected array $options = []

protected string $prefix = ""

protected ViewBaseInterface|null $view

### Methods

Public · 40

`__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

Protected · 5

`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 Source on GitHub 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)

__Uses__ `Phalcon\Mvc\View\Exception` ### Method Summary

public __construct(string $message = "",array $statement = [],int $code = 0,\Exception|null $previous = null) public array getStatement() Gets currently parsed statement (if any).

### Properties

protected array $statement = []

### Methods

Public · 2

`__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 Source on GitHub

```php public function __construct(); ``` ## Mvc\View\Exception Class Source on GitHub 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)

protected ManagerInterface|null $eventsManager

protected array $options = []

protected string $viewsDir

### Methods

Public · 13

`__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

Protected · 2

`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 Source on GitHub 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`**

__Used by__ [`Phalcon\Mvc\View`](#mvcview) · [`Phalcon\Mvc\View\Simple`](#mvcviewsimple) ### Method Summary

public string getContent() Returns output from another view stage public array getParamsToView() Returns parameters to views public array getRegisteredEngines() public mixed|null getVar( string $key ) Returns a parameter previously set in the view public static setContent( string $content ) Externally sets the view content public static setVar(string $key,mixed $value) Set a single view parameter

### Properties

protected string $content = ""

protected array $registeredEngines = null @todo Use a default [] once Zephir supports array trait defaults

protected array $viewParams = null @todo Use a default [] once Zephir supports array trait defaults

### Methods

Public · 6

`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.19/api/phalcon_mvc/index.mdx