Phalcon mvc

NOTE

All classes are prefixed with Phalcon

Mvc\Application¶

Namespace
- Phalcon\Mvc
Uses
- Closure
- Phalcon\Application\AbstractApplication
- Phalcon\Di\DiInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Http\ResponseInterface
- Phalcon\Mvc\Application\Exception
- Phalcon\Mvc\ModuleDefinitionInterface
- Phalcon\Mvc\Router\RouteInterface
Extends

AbstractApplication
Implements

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.

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

Properties¶

/**
 * @var bool
 */
protected $implicitView = true;

/**
 * @var bool
 */
protected $sendCookies = true;

/**
 * @var bool
 */
protected $sendHeaders = true;

Methods¶

public function handle( string $uri ): ResponseInterface | bool;

Handles a MVC request

public function sendCookiesOnHandleRequest( bool $sendCookies ): Application;

Enables or disables sending cookies by each request handling

public function sendHeadersOnHandleRequest( bool $sendHeaders ): Application;

Enables or disables sending headers by each request handling

public function useImplicitView( bool $implicitView ): Application;

By default. The view is implicitly buffering all the output You can full disable the view component using this method

Mvc\Application\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Application
Uses
Extends

\Phalcon\Application\Exception
Implements

Phalcon\Mvc\Application\Exception

Exceptions thrown in Phalcon\Mvc\Application class will use this class

Mvc\Controller ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Di\Injectable
Extends

Injectable
Implements
- ControllerInterface

Phalcon\Mvc\Controller

Every application controller should extend this class that encapsulates all the controller functionality

The controllers provide the “flow” between models and views. Controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation.

<?php

class PeopleController extends \Phalcon\Mvc\Controller
{
    // This action will be executed by default
    public function indexAction()
    {

    }

    public function findAction()
    {

    }

    public function saveAction()
    {
        // Forwards flow to the index action
        return $this->dispatcher->forward(
            [
                "controller" => "people",
                "action"     => "index",
            ]
        );
    }
}

Methods¶

final public function __construct();

Phalcon\Mvc\Controller constructor

Mvc\Controller\BindModelInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Controller
Uses
Extends
Implements

Phalcon\Mvc\Controller\BindModelInterface

Interface for Phalcon\Mvc\Controller

Methods¶

public static function getModelName(): string;

Return the model name associated with this controller

Mvc\ControllerInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
Extends
Implements

Phalcon\Mvc\ControllerInterface

Interface for controller handlers

Mvc\Dispatcher¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Dispatcher\AbstractDispatcher
- Phalcon\Events\ManagerInterface
- Phalcon\Http\ResponseInterface
- Phalcon\Mvc\Dispatcher\Exception
Extends

BaseDispatcher
Implements
- DispatcherInterface

Dispatching is the process of taking the request object, extracting the module name, controller name, action name, and optional parameters contained in it, and then instantiating a controller and calling an action of that controller.

$di = new \Phalcon\Di\Di();

$dispatcher = new \Phalcon\Mvc\Dispatcher();

$dispatcher->setDI($di);

$dispatcher->setControllerName("posts");
$dispatcher->setActionName("index");
$dispatcher->setParams([]);

$controller = $dispatcher->dispatch();

Properties¶

//
protected $defaultAction = index;

//
protected $defaultHandler = index;

//
protected $handlerSuffix = Controller;

Methods¶

public function forward( array $forward ): void;

Forwards the execution flow to another controller/action.

use Phalcon\Events\Event;
use Phalcon\Mvc\Dispatcher;
use App\Backend\Bootstrap as Backend;
use App\Frontend\Bootstrap as Frontend;

// Registering modules
$modules = [
    "frontend" => [
        "className" => Frontend::class,
        "path"      => __DIR__ . "/app/Modules/Frontend/Bootstrap.php",
        "metadata"  => [
            "controllersNamespace" => "App\Frontend\Controllers",
        ],
    ],
    "backend" => [
        "className" => Backend::class,
        "path"      => __DIR__ . "/app/Modules/Backend/Bootstrap.php",
        "metadata"  => [
            "controllersNamespace" => "App\Backend\Controllers",
        ],
    ],
];

$application->registerModules($modules);

// Setting beforeForward listener
$eventsManager  = $di->getShared("eventsManager");

$eventsManager->attach(
    "dispatch:beforeForward",
    function(Event $event, Dispatcher $dispatcher, array $forward) use ($modules) {
        $metadata = $modules[$forward["module"]]["metadata"];

        $dispatcher->setModuleName(
            $forward["module"]
        );

        $dispatcher->setNamespaceName(
            $metadata["controllersNamespace"]
        );
    }
);

// Forward
$this->dispatcher->forward(
    [
        "module"     => "backend",
        "controller" => "posts",
        "action"     => "index",
    ]
);

public function getActiveController(): ControllerInterface;

Returns the active controller in the dispatcher

public function getControllerClass(): string;

Possible controller class name that will be located to dispatch the request

public function getControllerName(): string;

Gets last dispatched controller name

public function getLastController(): ControllerInterface;

Returns the latest dispatched controller

public function getPreviousActionName(): string;

Gets previous dispatched action name

public function getPreviousControllerName(): string;

Gets previous dispatched controller name

public function getPreviousNamespaceName(): string;

Gets previous dispatched namespace name

public function setControllerName( string $controllerName );

Sets the controller name to be dispatched

public function setControllerSuffix( string $controllerSuffix );

Sets the default controller suffix

public function setDefaultController( string $controllerName );

Sets the default controller name

protected function handleException( \Exception $exception );

Handles a user exception

protected function throwDispatchException( string $message, int $exceptionCode = int );

Throws an internal exception

Mvc\Dispatcher\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Dispatcher
Uses
Extends

\Phalcon\Dispatcher\Exception
Implements

Phalcon\Mvc\Dispatcher\Exception

Exceptions thrown in Phalcon\Mvc\Dispatcher will use this class

Mvc\DispatcherInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Dispatcher\DispatcherInterface
Extends

DispatcherInterfaceBase
Implements

Phalcon\Mvc\DispatcherInterface

Interface for Phalcon\Mvc\Dispatcher

Methods¶

public function getActiveController(): ControllerInterface;

Returns the active controller in the dispatcher

public function getControllerName(): string;

Gets last dispatched controller name

public function getLastController(): ControllerInterface;

Returns the latest dispatched controller

public function setControllerName( string $controllerName );

Sets the controller name to be dispatched

public function setControllerSuffix( string $controllerSuffix );

Sets the default controller suffix

public function setDefaultController( string $controllerName );

Sets the default controller name

Mvc\EntityInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
Extends
Implements

Phalcon\Mvc\EntityInterface

Interface for Phalcon\Mvc\Collection and Phalcon\Mvc\Model

Methods¶

public function readAttribute( string $attribute ): mixed | null;

Reads an attribute value by its name

public function writeAttribute( string $attribute, mixed $value );

Writes an attribute value by its name

Mvc\Micro¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- ArrayAccess
- Closure
- 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\LazyLoader
- Phalcon\Mvc\Micro\MiddlewareInterface
- Phalcon\Mvc\Model\BinderInterface
- Phalcon\Mvc\Router\RouteInterface
- Throwable
Extends

Injectable
Implements
- ArrayAccess
- EventsAwareInterface

Phalcon\Mvc\Micro

With Phalcon you can create "Micro-Framework like" applications. By doing this, you only need to write a minimal amount of code to create a PHP application. Micro applications are suitable to small applications, APIs and prototypes in a practical way.

$app = new \Phalcon\Mvc\Micro();

$app->get(
    "/say/welcome/{name}",
    function ($name) {
        echo "<h1>Welcome $name!</h1>";
    }
);

$app->handle("/say/welcome/Phalcon");

Properties¶

/**
 * @var callable|null
 */
protected $activeHandler;

/**
 * @var array
 */
protected $afterBindingHandlers;

/**
 * @var array
 */
protected $afterHandlers;

/**
 * @var array
 */
protected $beforeHandlers;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var callable|null
 */
protected $errorHandler;

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

/**
 * @var array
 */
protected $finishHandlers;

/**
 * @var array
 */
protected $handlers;

/**
 * @var BinderInterface|null
 */
protected $modelBinder;

/**
 * @var callable|null
 */
protected $notFoundHandler;

/**
 * @var callable|null
 */
protected $responseHandler;

/**
 * @var mixed|null
 */
protected $returnedValue;

/**
 * @var RouterInterface|null
 */
protected $router;

/**
 * @var bool
 */
protected $stopped = false;

Methods¶

public function __construct( DiInterface $container = null );

Phalcon\Mvc\Micro constructor

public function after( mixed $handler ): Micro;

Appends an 'after' middleware to be called after execute the route

public function afterBinding( mixed $handler ): Micro;

Appends a afterBinding middleware to be called after model binding

public function before( mixed $handler ): Micro;

Appends a before middleware to be called before execute the route

public function delete( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is DELETE

public function error( mixed $handler ): Micro;

Sets a handler that will be called when an exception is thrown handling the route

public function finish( mixed $handler ): Micro;

Appends a 'finish' middleware to be called when the request is finished

public function get( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is GET

public function getActiveHandler();

Return the handler that will be called for the matched route

public function getBoundModels(): array;

Returns bound models from binder instance

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getHandlers(): array;

Returns the internal handlers attached to the application

public function getModelBinder(): BinderInterface | null;

Gets model binder

public function getReturnedValue();

Returns the value returned by the executed handler

public function getRouter(): RouterInterface;

Returns the internal router used by the application

public function getService( string $serviceName );

Obtains a service from the DI

public function getSharedService( string $serviceName );

Obtains a shared service from the DI

public function handle( string $uri );

Handle the whole request

public function hasService( string $serviceName ): bool;

Checks if a service is registered in the DI

public function head( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is HEAD

public function map( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler without any HTTP method constraint

public function mount( CollectionInterface $collection ): Micro;

Mounts a collection of handlers

public function notFound( mixed $handler ): Micro;

Sets a handler that will be called when the router doesn't match any of the defined routes

public function offsetExists( mixed $offset ): bool;

Check if a service is registered in the internal services container using the array syntax

public function offsetGet( mixed $offset ): mixed;

Allows to obtain a shared service in the internal services container using the array syntax

var_dump(
    $app["request"]
);

public function offsetSet( mixed $offset, mixed $value ): void;

Allows to register a shared service in the internal services container using the array syntax

   $app["request"] = new \Phalcon\Http\Request();

public function offsetUnset( mixed $offset ): void;

Removes a service from the internal services container using the array syntax

public function options( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is OPTIONS

public function patch( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is PATCH

public function post( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is POST

public function put( string $routePattern, mixed $handler ): RouteInterface;

Maps a route to a handler that only matches if the HTTP method is PUT

public function setActiveHandler( mixed $activeHandler );

Sets externally the handler that must be called by the matched route

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setModelBinder( BinderInterface $modelBinder, mixed $cache = null ): Micro;

Sets model binder

$micro = new Micro($di);

$micro->setModelBinder(
    new Binder(),
    'cache'
);

public function setResponseHandler( mixed $handler ): Micro;

Appends a custom 'response' handler to be called instead of the default response handler

public function setService( string $serviceName, mixed $definition, bool $shared = bool ): ServiceInterface;

Sets a service from the DI

public function stop(): void;

Stops the middleware execution avoiding than other middlewares be executed

Mvc\Micro\Collection¶

Source on GitHub

Namespace
- Phalcon\Mvc\Micro
Uses
Extends
Implements
- CollectionInterface

Phalcon\Mvc\Micro\Collection

Groups Micro-Mvc handlers as controllers

$app = new \Phalcon\Mvc\Micro();

$collection = new Collection();

$collection->setHandler(
    new PostsController()
);

$collection->get("/posts/edit/{id}", "edit");

$app->mount($collection);

Properties¶

/**
 * @var callable
 */
protected $handler;

/**
 * @var array
 */
protected $handlers;

/**
 * @var bool
 */
protected $lazy = false;

/**
 * @var string
 */
protected $prefix = ;

Methods¶

public function delete( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is DELETE.

public function get( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is GET.

public function getHandler(): mixed;

Returns the main handler

public function getHandlers(): array;

Returns the registered handlers

public function getPrefix(): string;

Returns the collection prefix if any

public function head( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is HEAD.

public function isLazy(): bool;

Returns if the main handler must be lazy loaded

public function map( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler.

public function mapVia( string $routePattern, callable $handler, mixed $method, string $name = null ): CollectionInterface;

Maps a route to a handler via methods.

$collection->mapVia(
    "/test",
    "indexAction",
    ["POST", "GET"],
    "test"
);

public function options( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is OPTIONS.

public function patch( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is PATCH.

public function post( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is POST.

public function put( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is PUT.

public function setHandler( mixed $handler, bool $lazy = bool ): CollectionInterface;

Sets the main handler.

public function setLazy( bool $lazy ): CollectionInterface;

Sets if the main handler must be lazy loaded

public function setPrefix( string $prefix ): CollectionInterface;

Sets a prefix for all routes added to the collection

protected function addMap( mixed $method, string $routePattern, callable $handler, string $name = null ): void;

Internal function to add a handler to the group.

Mvc\Micro\CollectionInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Micro
Uses
Extends
Implements

Phalcon\Mvc\Micro\CollectionInterface

Interface for Phalcon\Mvc\Micro\Collection

Methods¶

public function delete( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is DELETE

public function get( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is GET

public function getHandler(): mixed;

Returns the main handler

public function getHandlers(): array;

Returns the registered handlers

public function getPrefix(): string;

Returns the collection prefix if any

public function head( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is HEAD

public function isLazy(): bool;

Returns if the main handler must be lazy loaded

public function map( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler

public function options( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is OPTIONS

public function patch( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is PATCH

public function post( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is POST

public function put( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

Maps a route to a handler that only matches if the HTTP method is PUT

public function setHandler( mixed $handler, bool $lazy = bool ): CollectionInterface;

Sets the main handler

public function setLazy( bool $lazy ): CollectionInterface;

Sets if the main handler must be lazy loaded

public function setPrefix( string $prefix ): CollectionInterface;

Sets a prefix for all routes added to the collection

Mvc\Micro\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Micro
Uses
Extends

\Exception
Implements

Exceptions thrown in Phalcon\Mvc\Micro will use this class

Mvc\Micro\LazyLoader¶

Source on GitHub

Namespace
- Phalcon\Mvc\Micro
Uses
- Phalcon\Mvc\Model\BinderInterface
Extends
Implements

Phalcon\Mvc\Micro\LazyLoader

Lazy-Load of handlers for Mvc\Micro using auto-loading

Properties¶

/**
 * @var string
 */
protected $definition;

/**
 * @var object|null
 */
protected $handler;

Methods¶

public function __construct( string $definition );

Phalcon\Mvc\Micro\LazyLoader constructor

public function callMethod( string $method, mixed $arguments, BinderInterface $modelBinder = null );

Calling __call method

public function getDefinition(): string;

public function getHandler(): object | null;

Mvc\Micro\MiddlewareInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Micro
Uses
- Phalcon\Mvc\Micro
Extends
Implements

Allows to implement Phalcon\Mvc\Micro middleware in classes

Methods¶

public function call( Micro $application );

Calls the middleware

Mvc\Model ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- JsonSerializable
- Phalcon\Db\Adapter\AdapterInterface
- Phalcon\Db\Column
- Phalcon\Db\DialectInterface
- Phalcon\Db\Enum
- Phalcon\Db\RawValue
- Phalcon\Di\AbstractInjectionAware
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Events\ManagerInterface
- Phalcon\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\Exception
- 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\TransactionInterface
- Phalcon\Mvc\Model\ValidationFailed
- Phalcon\Support\Collection
- Phalcon\Support\Collection\CollectionInterface
- Serializable
Extends

AbstractInjectionAware
Implements
- EntityInterface
- JsonSerializable
- ModelInterface
- ResultInterface
- Serializable

Phalcon\Mvc\Model

Phalcon\Mvc\Model connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. It‘s an implementation of the object-relational mapping (ORM).

A model represents the information (data) of the application and the rules to manipulate that data. Models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, each table in your database will correspond to one model in your application. The bulk of your application's business logic will be concentrated in the models.

Phalcon\Mvc\Model is the first ORM written in Zephir/C languages for PHP, giving to developers high performance when interacting with databases while is also easy to use.

$robot = new Robots();

$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

if ($robot->save() === false) {
    echo "Umh, We can store robots: ";

    $messages = $robot->getMessages();

    foreach ($messages as $message) {
        echo $message;
    }
} else {
    echo "Great, a new robot was saved successfully!";
}

Constants¶

const DIRTY_STATE_DETACHED = 2;
const DIRTY_STATE_PERSISTENT = 0;
const DIRTY_STATE_TRANSIENT = 1;
const OP_CREATE = 1;
const OP_DELETE = 3;
const OP_NONE = 0;
const OP_UPDATE = 2;
const TRANSACTION_INDEX = transaction;

Properties¶

/**
 * @var int
 */
protected $dirtyState = 1;

/**
 * @var array
 */
protected $dirtyRelated;

/**
 * @var array
 */
protected $errorMessages;

/**
 * @var ManagerInterface|null
 */
protected $modelsManager;

/**
 * @var MetaDataInterface|null
 */
protected $modelsMetaData;

/**
 * @var array
 */
protected $related;

/**
 * @var int
 */
protected $operationMade = ;

/**
 * @var array
 */
protected $oldSnapshot;

/**
 * @var bool
 */
protected $skipped = false;

/**
 * @var array
 */
protected $snapshot;

/**
 * @var TransactionInterface|null
 */
protected $transaction;

/**
 * @var string|null
 */
protected $uniqueKey;

/**
 * @var array
 */
protected $uniqueParams;

/**
 * @var array
 */
protected $uniqueTypes;

Methods¶

public function __call( string $method, array $arguments );

Handles method calls when a method is not implemented

public static function __callStatic( string $method, array $arguments );

Handles method calls when a static method is not implemented

final public function __construct( mixed $data = null, DiInterface $container = null, ManagerInterface $modelsManager = null );

Phalcon\Mvc\Model constructor

public function __get( string $property );

Magic method to get related records using the relation alias as a property

public function __isset( string $property ): bool;

Magic method to check if a property is a valid relation

public function __serialize(): array;

Serializes a model

public function __set( string $property, mixed $value );

Magic method to assign values to the the model

public function __unserialize( array $data ): void;

Unserializes an array to the model

public function addBehavior( BehaviorInterface $behavior ): void;

Setups a behavior in a model

use Phalcon\Mvc\Model;
use Phalcon\Mvc\Model\Behavior\Timestampable;

class Robots extends Model
{
    public function initialize()
    {
        $this->addBehavior(
            new Timestampable(
                [
                    "beforeCreate" => [
                        "field"  => "created_at",
                        "format" => "Y-m-d",
                    ],
                ]
            )
        );

        $this->addBehavior(
            new Timestampable(
                [
                    "beforeUpdate" => [
                        "field"  => "updated_at",
                        "format" => "Y-m-d",
                    ],
                ]
            )
        );
    }
}

public function appendMessage( MessageInterface $message ): ModelInterface;

Appends a customized message on the validation process

use Phalcon\Mvc\Model;
use Phalcon\Messages\Message as Message;

class Robots extends Model
{
    public function beforeSave()
    {
        if ($this->name === "Peter") {
            $message = new Message(
                "Sorry, but a robot cannot be named Peter"
            );

            $this->appendMessage($message);
        }
    }
}

public function assign( array $data, mixed $whiteList = null, mixed $dataColumnMap = null ): ModelInterface;

Assigns values to a model from an array

$robot->assign(
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

// Assign by db row, column map needed
$robot->assign(
    $dbRow,
    [
        "db_type" => "type",
        "db_name" => "name",
        "db_year" => "year",
    ]
);

// Allow assign only name and year
$robot->assign(
    $_POST,
    [
        "name",
        "year",
    ]
);

// By default assign method will use setters if exist, you can disable it by using ini_set to directly use properties

ini_set("phalcon.orm.disable_assign_setters", true);

$robot->assign(
    $_POST,
    [
        "name",
        "year",
    ]
);

public static function average( array $parameters = [] ): double | ResultsetInterface;

Returns the average value on a column for a result-set of rows matching the specified conditions.

Returned value will be a float for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the average of each group.

// What's the average price of robots?
$average = Robots::average(
    [
        "column" => "price",
    ]
);

echo "The average price is ", $average, "\n";

// What's the average price of mechanical robots?
$average = Robots::average(
    [
        "type = 'mechanical'",
        "column" => "price",
    ]
);

echo "The average price of mechanical robots is ", $average, "\n";

public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;

Assigns values to a model from an array returning a new model

$robot = Phalcon\Mvc\Model::cloneResult(
    new Robots(),
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = null ): ModelInterface;

Assigns values to a model from an array, returning a new model.

$robot = \Phalcon\Mvc\Model::cloneResultMap(
    new Robots(),
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );

Returns an hydrated result based on the data and the column map

public static function count( mixed $parameters = null ): int | ResultsetInterface;

Counts how many records match the specified conditions.

Returns an integer for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the count of each group.

// How many robots are there?
$number = Robots::count();

echo "There are ", $number, "\n";

// How many mechanical robots are there?
$number = Robots::count("type = 'mechanical'");

echo "There are ", $number, " mechanical robots\n";

public function create(): bool;

Inserts a model instance. If the instance already exists in the persistence it will throw an exception Returning true on success or false otherwise.

// Creating a new robot
$robot = new Robots();

$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

$robot->create();

// Passing an array to create
$robot = new Robots();

$robot->assign(
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);

$robot->create();

public function delete(): bool;

Deletes a model instance. Returning true on success or false otherwise.

$robot = Robots::findFirst("id=100");

$robot->delete();

$robots = Robots::find("type = 'mechanical'");

foreach ($robots as $robot) {
    $robot->delete();
}

public function doSave( CollectionInterface $visited ): bool;

Inserted or updates model instance, expects a visited list of objects.

public function dump(): array;

Returns a simple representation of the object that can be used with var_dump()

var_dump(
    $robot->dump()
);

public static function find( mixed $parameters = null );

Query for a set of records that match the specified conditions

// How many robots are there?
$robots = Robots::find();

echo "There are ", count($robots), "\n";

// How many mechanical robots are there?
$robots = Robots::find(
    "type = 'mechanical'"
);

echo "There are ", count($robots), "\n";

// Get and print virtual robots ordered by name
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

foreach ($robots as $robot) {
    echo $robot->name, "\n";
}

// Get first 100 virtual robots ordered by name
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
        "limit" => 100,
    ]
);

foreach ($robots as $robot) {
    echo $robot->name, "\n";
}

// encapsulate find it into an running transaction esp. useful for application unit-tests
// or complex business logic where we wanna control which transactions are used.

$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();

$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);

$newRobot->assign(
    [
        'name' => 'test',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);

$newRobot->save();

$resultInsideTransaction = Robot::find(
    [
        'name' => 'test',
        Model::TRANSACTION_INDEX => $myTransaction,
    ]
);

$resultOutsideTransaction = Robot::find(['name' => 'test']);

foreach ($setInsideTransaction as $robot) {
    echo $robot->name, "\n";
}

foreach ($setOutsideTransaction as $robot) {
    echo $robot->name, "\n";
}

// reverts all not commited changes
$myTransaction->rollback();

// creating two different transactions
$myTransaction1 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction1->begin();
$myTransaction2 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction2->begin();

 // add a new robots
$firstNewRobot = new Robot();
$firstNewRobot->setTransaction($myTransaction1);
$firstNewRobot->assign(
    [
        'name' => 'first-transaction-robot',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);
$firstNewRobot->save();

$secondNewRobot = new Robot();
$secondNewRobot->setTransaction($myTransaction2);
$secondNewRobot->assign(
    [
        'name' => 'second-transaction-robot',
        'type' => 'fictional',
        'year' => 1984,
    ]
);
$secondNewRobot->save();

// this transaction will find the robot.
$resultInFirstTransaction = Robot::find(
    [
        'name'                   => 'first-transaction-robot',
        Model::TRANSACTION_INDEX => $myTransaction1,
    ]
);

// this transaction won't find the robot.
$resultInSecondTransaction = Robot::find(
    [
        'name'                   => 'first-transaction-robot',
        Model::TRANSACTION_INDEX => $myTransaction2,
    ]
);

// this transaction won't find the robot.
$resultOutsideAnyExplicitTransaction = Robot::find(
    [
        'name' => 'first-transaction-robot',
    ]
);

// this transaction won't find the robot.
$resultInFirstTransaction = Robot::find(
    [
        'name'                   => 'second-transaction-robot',
        Model::TRANSACTION_INDEX => $myTransaction2,
    ]
);

// this transaction will find the robot.
$resultInSecondTransaction = Robot::find(
    [
        'name'                   => 'second-transaction-robot',
        Model::TRANSACTION_INDEX => $myTransaction1,
    ]
);

// this transaction won't find the robot.
$resultOutsideAnyExplicitTransaction = Robot::find(
    [
        'name' => 'second-transaction-robot',
    ]
);

$transaction1->rollback();
$transaction2->rollback();

public static function findFirst( mixed $parameters = null ): mixed | null;

Query the first record that matches the specified conditions

// What's the first robot in robots table?
$robot = Robots::findFirst();

echo "The robot name is ", $robot->name;

// What's the first mechanical robot in robots table?
$robot = Robots::findFirst(
    "type = 'mechanical'"
);

echo "The first mechanical robot name is ", $robot->name;

// Get first virtual robot ordered by name
$robot = Robots::findFirst(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

echo "The first virtual robot name is ", $robot->name;

// behaviour with transaction
$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();

$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);
$newRobot->assign(
    [
        'name' => 'test',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);
$newRobot->save();

$findsARobot = Robot::findFirst(
    [
        'name'                   => 'test',
        Model::TRANSACTION_INDEX => $myTransaction,
    ]
);

$doesNotFindARobot = Robot::findFirst(
    [
        'name' => 'test',
    ]
);

var_dump($findARobot);
var_dump($doesNotFindARobot);

$transaction->commit();

$doesFindTheRobotNow = Robot::findFirst(
    [
        'name' => 'test',
    ]
);

public function fireEvent( string $eventName ): bool;

Fires an event, implicitly calls behaviors and listeners in the events manager are notified

public function fireEventCancel( string $eventName ): bool;

Fires an event, implicitly calls behaviors and listeners in the events manager are notified This method stops if one of the callbacks/listeners returns bool false

public function getChangedFields(): array;

Returns a list of changed values.

$robots = Robots::findFirst();
print_r($robots->getChangedFields()); // []

$robots->deleted = 'Y';

$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]

public function getDirtyState(): int;

Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not

public function getEventsManager(): EventsManagerInterface | null;

Returns the custom events manager or null if there is no custom events manager

public function getMessages( mixed $filter = null ): MessageInterface[];

Returns array of validation messages

$robot = new Robots();

$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

if ($robot->save() === false) {
    echo "Umh, We can't store robots right now ";

    $messages = $robot->getMessages();

    foreach ($messages as $message) {
        echo $message;
    }
} else {
    echo "Great, a new robot was saved successfully!";
}

public function getModelsManager(): ManagerInterface;

Returns the models manager related to the entity instance

public function getModelsMetaData(): MetaDataInterface;

public function getOldSnapshotData(): array;

Returns the internal old snapshot data

public function getOperationMade(): int;

Returns the type of the latest operation performed by the ORM Returns one of the OP_* class constants

final public function getReadConnection(): AdapterInterface;

Gets the connection used to read data for the model

final public function getReadConnectionService(): string;

Returns the DependencyInjection connection service name used to read data related the model

public function getRelated( string $alias, mixed $arguments = null );

Returns related records based on defined relations

final public function getSchema(): string | null;

Returns schema name where the mapped table is located

public function getSnapshotData(): array;

Returns the internal snapshot data

final public function getSource(): string;

Returns the table name mapped in the model

public function getTransaction(): TransactionInterface | null;

public function getUpdatedFields(): array;

Returns a list of updated values.

$robots = Robots::findFirst();
print_r($robots->getChangedFields()); // []

$robots->deleted = 'Y';

$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]
$robots->save();
print_r($robots->getChangedFields()); // []
print_r($robots->getUpdatedFields()); // ["deleted"]

final public function getWriteConnection(): AdapterInterface;

Gets the connection used to write data to the model

final public function getWriteConnectionService(): string;

Returns the DependencyInjection connection service name used to write data related to the model

public function hasChanged( mixed $fieldName = null, bool $allFields = bool ): bool;

Check if a specific attribute has changed This only works if the model is keeping data snapshots

$robot = new Robots();

$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

$robot->create();

$robot->type = "hydraulic";

$hasChanged = $robot->hasChanged("type"); // returns true
$hasChanged = $robot->hasChanged(["type", "name"]); // returns true
$hasChanged = $robot->hasChanged(["type", "name"], true); // returns false

public function hasSnapshotData(): bool;

Checks if the object has internal snapshot data

public function hasUpdated( mixed $fieldName = null, bool $allFields = bool ): bool;

Check if a specific attribute was updated This only works if the model is keeping data snapshots

public function isRelationshipLoaded( string $relationshipAlias ): bool;

Checks if saved related records have already been loaded.

Only returns true if the records were previously fetched through the model without any additional parameters.

$robot = Robots::findFirst();
var_dump($robot->isRelationshipLoaded('robotsParts')); // false

$robotsParts = $robot->getRobotsParts(['id > 0']);
var_dump($robot->isRelationshipLoaded('robotsParts')); // false

$robotsParts = $robot->getRobotsParts(); // or $robot->robotsParts
var_dump($robot->isRelationshipLoaded('robotsParts')); // true

$robot->robotsParts = [new RobotsParts()];
var_dump($robot->isRelationshipLoaded('robotsParts')); // false

public function jsonSerialize(): array;

Serializes the object for json_encode

echo json_encode($robot);

public static function maximum( mixed $parameters = null ): mixed;

Returns the maximum value of a column for a result-set of rows that match the specified conditions

// What is the maximum robot id?
$id = Robots::maximum(
    [
        "column" => "id",
    ]
);

echo "The maximum robot id is: ", $id, "\n";

// What is the maximum id of mechanical robots?
$sum = Robots::maximum(
    [
        "type = 'mechanical'",
        "column" => "id",
    ]
);

echo "The maximum robot id of mechanical robots is ", $id, "\n";

public static function minimum( mixed $parameters = null ): mixed;

Returns the minimum value of a column for a result-set of rows that match the specified conditions

// What is the minimum robot id?
$id = Robots::minimum(
    [
        "column" => "id",
    ]
);

echo "The minimum robot id is: ", $id;

// What is the minimum id of mechanical robots?
$sum = Robots::minimum(
    [
        "type = 'mechanical'",
        "column" => "id",
    ]
);

echo "The minimum robot id of mechanical robots is ", $id;

public static function query( DiInterface $container = null ): CriteriaInterface;

Create a criteria for a specific model

public function readAttribute( string $attribute ): mixed | null;

Reads an attribute value by its name

echo $robot->readAttribute("name");

public function refresh(): ModelInterface;

Refreshes the model attributes re-querying the record from the database

public function save(): bool;

Inserts or updates a model instance. Returning true on success or false otherwise.

// Creating a new robot
$robot = new Robots();

$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

$robot->save();

// Updating a robot name
$robot = Robots::findFirst("id = 100");

$robot->name = "Biomass";

$robot->save();

public function serialize(): string;

Serializes the object ignoring connections, services, related objects or static properties

final public function setConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service name

public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Sets the dirty state of the object using one of the DIRTY_STATE_* constants

public function setEventsManager( EventsManagerInterface $eventsManager );

Sets a custom events manager

public function setOldSnapshotData( array $data, mixed $columnMap = null );

Sets the record's old snapshot data. This method is used internally to set old snapshot data when the model was set up to keep snapshot data

final public function setReadConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service name used to read data

public function setSnapshotData( array $data, mixed $columnMap = null ): void;

Sets the record's snapshot data. This method is used internally to set snapshot data when the model was set up to keep snapshot data

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Sets a transaction related to the Model instance

use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;

try {
    $txManager = new TxManager();

    $transaction = $txManager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

    $robot->name       = "WALL·E";
    $robot->created_at = date("Y-m-d");

    if ($robot->save() === false) {
        $transaction->rollback("Can't save robot");
    }

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

    if ($robotPart->save() === false) {
        $transaction->rollback("Robot part cannot be saved");
    }

    $transaction->commit();
} catch (TxFailed $e) {
    echo "Failed, reason: ", $e->getMessage();
}

final public function setWriteConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service name used to write data

public static function setup( array $options ): void;

Enables/disables options in the ORM

public function skipOperation( bool $skip ): void;

Skips the current operation forcing a success state

public static function sum( mixed $parameters = null ): double | ResultsetInterface;

Calculates the sum on a column for a result-set of rows that match the specified conditions

// How much are all robots?
$sum = Robots::sum(
    [
        "column" => "price",
    ]
);

echo "The total price of robots is ", $sum, "\n";

// How much are mechanical robots?
$sum = Robots::sum(
    [
        "type = 'mechanical'",
        "column" => "price",
    ]
);

echo "The total price of mechanical robots is  ", $sum, "\n";

public function toArray( mixed $columns = null, mixed $useGetter = bool ): array;

Returns the instance as an array representation

print_r(
    $robot->toArray()
);

public function unserialize( mixed $data );

Unserializes the object from a serialized string

public function update(): bool;

Updates a model instance. If the instance doesn't exist in the persistence it will throw an exception. Returning true on success or false otherwise.

<?php

use MyApp\Models\Invoices;

$invoice = Invoices::findFirst('inv_id = 4');

$invoice->inv_total = 120;

$invoice->update();

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.

public function validationHasFailed(): bool;

Check whether validation process has generated any messages

use Phalcon\Mvc\Model;
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;

class Subscriptors extends Model
{
    public function validation()
    {
        $validator = new Validation();

        $validator->validate(
            "status",
            new ExclusionIn(
                [
                    "domain" => [
                        "A",
                        "I",
                    ],
                ]
            )
        );

        return $this->validate($validator);
    }
}

public function writeAttribute( string $attribute, mixed $value ): void;

Writes an attribute value by its name

$robot->writeAttribute("name", "Rosey");

protected function allowEmptyStringValues( array $attributes ): void;

Sets a list of attributes that must be skipped from the generated UPDATE statement

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->allowEmptyStringValues(
            [
                "name",
            ]
        );
    }
}

protected function belongsTo( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup a reverse 1-1 or n-1 relation between two models

class RobotsParts extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->belongsTo(
            "robots_id",
            Robots::class,
            "id"
        );
    }
}

protected function cancelOperation();

Cancel the current operation

final protected function checkForeignKeysRestrict(): bool;

Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records to verify that inserted/updated values are present in the related entity

final protected function checkForeignKeysReverseCascade(): bool;

Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records

final protected function checkForeignKeysReverseRestrict(): bool;

Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records

protected function collectRelatedToSave(): array;

Collects previously queried (belongs-to, has-one and has-one-through) related records along with freshly added one

protected function doLowInsert( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table, mixed $identityField ): bool;

Sends a pre-build INSERT SQL statement to the relational database system

protected function doLowUpdate( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table ): bool;

Sends a pre-build UPDATE SQL statement to the relational database system

protected function getRelatedRecords( string $modelName, string $method, array $arguments );

Returns related records defined relations depending on the method name. Returns false if the relation is non-existent.

protected static function groupResult( string $functionName, string $alias, mixed $parameters = null ): ResultsetInterface;

Generate a PHQL SELECT statement for an aggregate

protected function has( MetaDataInterface $metaData, AdapterInterface $connection ): bool;

Checks whether the current record already exists

protected function hasMany( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup a 1-n relation between two models

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->hasMany(
            "id",
            RobotsParts::class,
            "robots_id"
        );
    }
}

protected function hasManyToMany( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup an n-n relation between two models, through an intermediate relation

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        // Setup a many-to-many relation to Parts through RobotsParts
        $this->hasManyToMany(
            "id",
            RobotsParts::class,
            "robots_id",
            "parts_id",
            Parts::class,
            "id",
        );
    }
}

protected function hasOne( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup a 1-1 relation between two models

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->hasOne(
            "id",
            RobotsDescription::class,
            "robots_id"
        );
    }
}

protected function hasOneThrough( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup a 1-1 relation between two models, through an intermediate relation

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        // Setup a 1-1 relation to one item from Parts through RobotsParts
        $this->hasOneThrough(
            "id",
            RobotsParts::class,
            "robots_id",
            "parts_id",
            Parts::class,
            "id",
        );
    }
}

protected function keepSnapshots( bool $keepSnapshot ): void;

Sets if the model must keep the original record snapshot in memory

use Phalcon\Mvc\Model;

class Robots extends Model
{
    public function initialize()
    {
        $this->keepSnapshots(true);
    }
}

final protected function possibleSetter( string $property, mixed $value ): bool;

Check for, and attempt to use, possible setter.

protected function postSave( bool $success, bool $exists ): bool;

Executes internal events after save a record

protected function postSaveRelatedRecords( AdapterInterface $connection, mixed $related, CollectionInterface $visited ): bool;

Save the related records assigned in the has-one/has-many relations

protected function preSave( MetaDataInterface $metaData, bool $exists, mixed $identityField ): bool;

Executes internal hooks before save a record

protected function preSaveRelatedRecords( AdapterInterface $connection, mixed $related, CollectionInterface $visited ): bool;

Saves related records that must be stored prior to save the master record

final protected function setSchema( string $schema ): ModelInterface;

Sets schema name where the mapped table is located

final protected function setSource( string $source ): ModelInterface;

Sets the table name to which model should be mapped

protected function skipAttributes( array $attributes ): void;

Sets a list of attributes that must be skipped from the generated INSERT/UPDATE statement

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->skipAttributes(
            [
                "price",
            ]
        );
    }
}

protected function skipAttributesOnCreate( array $attributes ): void;

Sets a list of attributes that must be skipped from the generated INSERT statement

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->skipAttributesOnCreate(
            [
                "created_at",
            ]
        );
    }
}

protected function skipAttributesOnUpdate( array $attributes ): void;

Sets a list of attributes that must be skipped from the generated UPDATE statement

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->skipAttributesOnUpdate(
            [
                "modified_in",
            ]
        );
    }
}

protected function useDynamicUpdate( bool $dynamicUpdate ): void;

Sets if a model must use dynamic update instead of the all-field update

use Phalcon\Mvc\Model;

class Robots extends Model
{
    public function initialize()
    {
        $this->useDynamicUpdate(true);
    }
}

protected function validate( ValidationInterface $validator ): bool;

Executes validators on every validation call

use Phalcon\Mvc\Model;
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;

class Subscriptors extends Model
{
    public function validation()
    {
        $validator = new Validation();

        $validator->add(
            "status",
            new ExclusionIn(
                [
                    "domain" => [
                        "A",
                        "I",
                    ],
                ]
            )
        );

        return $this->validate($validator);
    }
}

Mvc\Model\Behavior ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
Extends
Implements
- BehaviorInterface

Phalcon\Mvc\Model\Behavior

This is an optional base class for ORM behaviors

Properties¶

/**
 * @var array
 */
protected $options;

Methods¶

public function __construct( array $options = [] );

Phalcon\Mvc\Model\Behavior

public function missingMethod( ModelInterface $model, string $method, array $arguments = [] );

Acts as fallbacks when a missing method is called on the model

public function notify( string $type, ModelInterface $model );

This method receives the notifications from the EventsManager

protected function getOptions( string $eventName = null );

Returns the behavior options related to an event

protected function mustTakeAction( string $eventName ): bool;

Checks whether the behavior must take action on certain event

Mvc\Model\Behavior\SoftDelete¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Behavior
Uses
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Behavior
- Phalcon\Mvc\Model\Exception
Extends

Behavior
Implements

Phalcon\Mvc\Model\Behavior\SoftDelete

Instead of permanently delete a record it marks the record as deleted changing the value of a flag column

Methods¶

public function notify( string $type, ModelInterface $model );

Listens for notifications from the models manager

Mvc\Model\Behavior\Timestampable¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Behavior
Uses
- Closure
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Behavior
- Phalcon\Mvc\Model\Exception
Extends

Behavior
Implements

Phalcon\Mvc\Model\Behavior\Timestampable

Allows to automatically update a model’s attribute saving the datetime when a record is created or updated

Methods¶

public function notify( string $type, ModelInterface $model );

Listens for notifications from the models manager

Mvc\Model\BehaviorInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
Extends
Implements

Phalcon\Mvc\Model\BehaviorInterface

Interface for Phalcon\Mvc\Model\Behavior

Methods¶

public function missingMethod( ModelInterface $model, string $method, array $arguments = [] );

Calls a method when it's missing in the model

public function notify( string $type, ModelInterface $model );

This method receives the notifications from the EventsManager

Mvc\Model\Binder¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Closure
- Phalcon\Cache\Adapter\AdapterInterface
- Phalcon\Mvc\Controller\BindModelInterface
- Phalcon\Mvc\Model\Binder\BindableInterface
- ReflectionFunction
- ReflectionMethod
Extends
Implements
- BinderInterface

Phalcon\Mvc\Model\Binder

This is an class for binding models into params for handler

Properties¶

/**
 * Array for storing active bound models
 *
 * @var array
 */
protected $boundModels;

/**
 * Cache object used for caching parameters for model binding
 *
 * @var AdapterInterface|null
 */
protected $cache;

/**
 * Internal cache for caching parameters for model binding during request
 *
 * @var array
 */
protected $internalCache;

/**
 * Array for original values
 *
 * @var array
 */
protected $originalValues;

Methods¶

public function __construct( AdapterInterface $cache = null );

Phalcon\Mvc\Model\Binder constructor

public function bindToHandler( object $handler, array $params, string $cacheKey, string $methodName = null ): array;

Bind models into params in proper handler

public function getBoundModels(): array;

Return the active bound models

public function getCache(): AdapterInterface;

Sets cache instance

public function getOriginalValues(): array;

Return the array for original values

public function setCache( AdapterInterface $cache ): BinderInterface;

Gets cache instance

protected function findBoundModel( mixed $paramValue, string $className ): mixed | bool;

Find the model by param value.

protected function getParamsFromCache( string $cacheKey ): array | null;

Get params classes from cache by key

protected function getParamsFromReflection( object $handler, array $params, string $cacheKey, string $methodName ): array;

Get modified params for handler using reflection

Mvc\Model\Binder\BindableInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Binder
Uses
Extends
Implements

Phalcon\Mvc\Model\Binder\BindableInterface

Interface for bindable classes

Methods¶

public function getModelName(): string | array;

Return the model name or models names and parameters keys associated with this class

Mvc\Model\BinderInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Cache\Adapter\AdapterInterface
Extends
Implements

Phalcon\Mvc\Model\BinderInterface

Interface for Phalcon\Mvc\Model\Binder

Methods¶

public function bindToHandler( object $handler, array $params, string $cacheKey, string $methodName = null ): array;

Bind models into params in proper handler

public function getBoundModels(): array;

Gets active bound models

public function getCache(): AdapterInterface;

Gets cache instance

public function setCache( AdapterInterface $cache ): BinderInterface;

Sets cache instance

Mvc\Model\Criteria¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Db\Column
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Mvc\Model\Query\BuilderInterface
Extends
Implements
- CriteriaInterface
- InjectionAwareInterface

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

$invoices = Invoices::query()
    ->where("inv_cst_id = :customerId:")
    ->andWhere("inv_created_date < '2000-01-01'")
    ->bind(["customerId" => 1])
    ->limit(5, 10)
    ->orderBy("inv_title")
    ->execute();

Properties¶

/**
 * @var array
 */
protected $bindParams;

/**
 * @var array
 */
protected $bindTypes;

/**
 * @var int
 */
protected $hiddenParamNumber = ;

/**
 * @var string|null
 */
protected $model;

/**
 * @var array
 */
protected $params;

Methods¶

public function andWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Appends a condition to the current conditions using an AND operator

public function betweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;

Appends a BETWEEN condition to the current conditions

$criteria->betweenWhere("price", 100.25, 200.50);

public function bind( array $bindParams, bool $merge = bool ): CriteriaInterface;

Sets the bound parameters in the criteria This method replaces all previously set bound parameters

public function bindTypes( array $bindTypes ): CriteriaInterface;

Sets the bind types in the criteria This method replaces all previously set bound parameters

public function cache( array $cache ): CriteriaInterface;

Sets the cache options in the criteria This method replaces all previously set cache options

public function columns( mixed $columns ): CriteriaInterface;

Sets the columns to be queried. 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

// String, comma separated values
$criteria->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",
    ]
);

public function conditions( string $conditions ): CriteriaInterface;

Adds the conditions parameter to the criteria

public function createBuilder(): BuilderInterface;

Creates a query builder from criteria.

<?php

$invoices = Invoices::query() ->where("inv_cst_id = :customerId:") ->bind(["customerId" => 1]) ->createBuilder();

```php
public function distinct( mixed $distinct ): CriteriaInterface;

Sets SELECT DISTINCT / SELECT ALL flag

public function execute(): ResultsetInterface;

Executes a find using the parameters built with the criteria

public function forUpdate( bool $forUpdate = bool ): CriteriaInterface;

Adds the "for_update" parameter to the criteria

public static function fromInput( DiInterface $container, string $modelName, array $data, string $operator = string ): CriteriaInterface;

Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST

public function getColumns(): string | array | null;

Returns the columns to be queried

public function getConditions(): string | null;

Returns the conditions parameter in the criteria

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getGroupBy();

Returns the group clause in the criteria

public function getHaving();

Returns the having clause in the criteria

public function getLimit(): int | array | null;

Returns the limit parameter in the criteria, which will be

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

public function getModelName(): string;

Returns an internal model name on which the criteria will be applied

public function getOrderBy(): string | null;

Returns the order clause in the criteria

public function getParams(): array;

Returns all the parameters defined in the criteria

public function getWhere(): string | null;

Returns the conditions parameter in the criteria

public function groupBy( mixed $group ): CriteriaInterface;

Adds the group-by clause to the criteria

public function having( mixed $having ): CriteriaInterface;

Adds the having clause to the criteria

public function inWhere( string $expr, array $values ): CriteriaInterface;

Appends an IN condition to the current conditions

$criteria->inWhere("id", [1, 2, 3]);

public function innerJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds an INNER join to the query

<?php

$criteria->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"
);

public function join( string $model, mixed $conditions = null, mixed $alias = null, mixed $type = null ): CriteriaInterface;

Adds an INNER join to the query

<?php

$criteria->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"
);

public function leftJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds a LEFT join to the query

<?php

$criteria->leftJoin(
    Invoices::class,
    "i.inv_cst_id = Customers.cst_id",
    "i"
);

public function limit( int $limit, int $offset = int ): CriteriaInterface;

Adds the limit parameter to the criteria.

$criteria->limit(100);
$criteria->limit(100, 200);
$criteria->limit("100", "200");

public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;

Appends a NOT BETWEEN condition to the current conditions

$criteria->notBetweenWhere("price", 100.25, 200.50);

public function notInWhere( string $expr, array $values ): CriteriaInterface;

Appends a NOT IN condition to the current conditions

$criteria->notInWhere("id", [1, 2, 3]);

public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Appends a condition to the current conditions using an OR operator

public function orderBy( string $orderColumns ): CriteriaInterface;

Adds the order-by clause to the criteria

public function rightJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds a RIGHT join to the query

<?php

$criteria->rightJoin(
    Invoices::class,
    "i.inv_cst_id = Customers.cst_id",
    "i"
);

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setModelName( string $modelName ): CriteriaInterface;

Set a model on which the query will be executed

public function sharedLock( bool $sharedLock = bool ): CriteriaInterface;

Adds the "shared_lock" parameter to the criteria

public function where( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Sets the conditions parameter in the criteria

Mvc\Model\CriteriaInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Di\DiInterface
Extends
Implements

Phalcon\Mvc\Model\CriteriaInterface

Interface for Phalcon\Mvc\Model\Criteria

Methods¶

public function andWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Appends a condition to the current conditions using an AND operator

public function betweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;

Appends a BETWEEN condition to the current conditions

$criteria->betweenWhere("price", 100.25, 200.50);

public function bind( array $bindParams ): CriteriaInterface;

Sets the bound parameters in the criteria This method replaces all previously set bound parameters

public function bindTypes( array $bindTypes ): CriteriaInterface;

Sets the bind types in the criteria This method replaces all previously set bound parameters

public function cache( array $cache ): CriteriaInterface;

Sets the cache options in the criteria This method replaces all previously set cache options

public function conditions( string $conditions ): CriteriaInterface;

Adds the conditions parameter to the criteria

public function distinct( mixed $distinct ): CriteriaInterface;

Sets SELECT DISTINCT / SELECT ALL flag

public function execute(): ResultsetInterface;

Executes a find using the parameters built with the criteria

public function forUpdate( bool $forUpdate = bool ): CriteriaInterface;

Sets the "for_update" parameter to the criteria

public function getColumns(): string | array | null;

Returns the columns to be queried

public function getConditions(): string | null;

Returns the conditions parameter in the criteria

public function getGroupBy();

Returns the group clause in the criteria

public function getHaving();

Returns the having clause in the criteria

public function getLimit(): int | array | null;

Returns the limit parameter in the criteria, which will be

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

public function getModelName(): string;

Returns an internal model name on which the criteria will be applied

public function getOrderBy(): string | null;

Returns the order parameter in the criteria

public function getParams(): array;

Returns all the parameters defined in the criteria

public function getWhere(): string | null;

Returns the conditions parameter in the criteria

public function groupBy( mixed $group ): CriteriaInterface;

Adds the group-by clause to the criteria

public function having( mixed $having ): CriteriaInterface;

Adds the having clause to the criteria

public function inWhere( string $expr, array $values ): CriteriaInterface;

Appends an IN condition to the current conditions

$criteria->inWhere("id", [1, 2, 3]);

public function innerJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds an INNER join to the query

$criteria->innerJoin(
    Robots::class
);

$criteria->innerJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id"
);

$criteria->innerJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function leftJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds a LEFT join to the query

$criteria->leftJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function limit( int $limit, int $offset = int ): CriteriaInterface;

Sets the limit parameter to the criteria

public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;

Appends a NOT BETWEEN condition to the current conditions

$criteria->notBetweenWhere("price", 100.25, 200.50);

public function notInWhere( string $expr, array $values ): CriteriaInterface;

Appends a NOT IN condition to the current conditions

$criteria->notInWhere("id", [1, 2, 3]);

public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Appends a condition to the current conditions using an OR operator

public function orderBy( string $orderColumns ): CriteriaInterface;

Adds the order-by parameter to the criteria

public function rightJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;

Adds a RIGHT join to the query

$criteria->rightJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function setModelName( string $modelName ): CriteriaInterface;

Set a model on which the query will be executed

public function sharedLock( bool $sharedLock = bool ): CriteriaInterface;

Sets the "shared_lock" parameter to the criteria

public function where( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Sets the conditions parameter in the criteria

Mvc\Model\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
Extends

\Exception
Implements

Phalcon\Mvc\Model\Exception

Exceptions thrown in Phalcon\Mvc\Model* classes will use this class

Mvc\Model\Manager¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Db\Adapter\AdapterInterface
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Events\EventsAwareInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Query\Builder
- Phalcon\Mvc\Model\Query\BuilderInterface
- Phalcon\Mvc\Model\Query\StatusInterface
- ReflectionClass
- ReflectionProperty
Extends
Implements
- EventsAwareInterface
- InjectionAwareInterface
- ManagerInterface

Phalcon\Mvc\Model\Manager

This components controls the initialization of models, keeping record of relations between the different models of the application.

A ModelsManager is injected to a model via a Dependency Injector/Services Container such as Phalcon\Di\Di.

use Phalcon\Di\Di;
use Phalcon\Mvc\Model\Manager as ModelsManager;

$di = new Di();

$di->set(
    "modelsManager",
    function() {
        return new ModelsManager();
    }
);

$robot = new Robots($di);

Properties¶

/**
 * @var array
 */
protected $aliases;

/**
 * Models' behaviors
 *
 * @var array
 */
protected $behaviors;

/**
 * Belongs to relations
 *
 * @var array
 */
protected $belongsTo;

/**
 * All the relationships by model
 *
 * @var array
 */
protected $belongsToSingle;

/**
 * @var BuilderInterface|null
 */
protected $builder;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var array
 */
protected $customEventsManager;

/**
 * Does the model use dynamic update, instead of updating all rows?
 *
 * @var array
 */
protected $dynamicUpdate;

/**
 * @var EventsManagerInterface|null
 */
protected $eventsManager;

/**
 * Has many relations
 *
 * @var array
 */
protected $hasMany;

/**
 * Has many relations by model
 *
 * @var array
 */
protected $hasManySingle;

/**
 * Has many-Through relations
 *
 * @var array
 */
protected $hasManyToMany;

/**
 * Has many-Through relations by model
 *
 * @var array
 */
protected $hasManyToManySingle;

/**
 * Has one relations
 *
 * @var array
 */
protected $hasOne;

/**
 * Has one relations by model
 *
 * @var array
 */
protected $hasOneSingle;

/**
 * Has one through relations
 *
 * @var array
 */
protected $hasOneThrough;

/**
 * Has one through relations by model
 *
 * @var array
 */
protected $hasOneThroughSingle;

/**
 * Mark initialized models
 *
 * @var array
 */
protected $initialized;

/**
 * @var array
 */
protected $keepSnapshots;

/**
 * Last model initialized
 *
 * @var ModelInterface|null
 */
protected $lastInitialized;

/**
 * Last query created/executed
 *
 * @var QueryInterface|null
 */
protected $lastQuery;

/**
 * @var array
 */
protected $modelVisibility;

/**
 * @var string
 */
protected $prefix = ;

/**
 * @var array
 */
protected $readConnectionServices;

/**
 * @var array
 */
protected $sources;

/**
 * @var array
 */
protected $schemas;

/**
 * @var array
 */
protected $writeConnectionServices;

/**
 * Stores a list of reusable instances
 *
 * @var array
 */
protected $reusable;

Methods¶

public function __destruct();

Destroys the current PHQL cache

public function addBehavior( ModelInterface $model, BehaviorInterface $behavior ): void;

Binds a behavior to a model

public function addBelongsTo( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a relation reverse many to one between two models

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a relation 1-n between two models

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

Setups a relation n-m between two models

public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a 1-1 relation between two models

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

Setups a relation 1-1 between two models using an intermediate model

public function clearReusableObjects(): void;

Clears the internal reusable list

public function createBuilder( mixed $params = null ): BuilderInterface;

Creates a Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

Creates a Phalcon\Mvc\Model\Query without execute it

public function executeQuery( string $phql, mixed $placeholders = null, mixed $types = null ): mixed;

Creates a Phalcon\Mvc\Model\Query and execute it

$model = new Robots();
$manager = $model->getModelsManager();

// \Phalcon\Mvc\Model\Resultset\Simple
$manager->executeQuery('SELECTFROM Robots');

// \Phalcon\Mvc\Model\Resultset\Complex
$manager->executeQuery('SELECT COUNT(type) FROM Robots GROUP BY type');

// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('INSERT INTO Robots (id) VALUES (1)');

// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('UPDATE Robots SET id = 0 WHERE id = :id:', ['id' => 1]);

// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('DELETE FROM Robots WHERE id = :id:', ['id' => 1]);

public function existsBelongsTo( string $modelName, string $modelRelation ): bool;

Checks whether a model has a belongsTo relation with another model @deprecated

public function existsHasMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasMany relation with another model @deprecated

public function existsHasManyToMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasManyToMany relation with another model @deprecated

public function existsHasOne( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOne relation with another model @deprecated

public function existsHasOneThrough( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOneThrough relation with another model @deprecated

public function getBelongsTo( ModelInterface $model ): RelationInterface[] | array;

Gets all the belongsTo relations defined in a model

$relations = $modelsManager->getBelongsTo(
    new Robots()
);

public function getBelongsToRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;

Gets belongsTo related records from a model

public function getBuilder(): BuilderInterface | null;

Returns the newly created Phalcon\Mvc\Model\Query\Builder or null

public function getConnectionService( ModelInterface $model, array $connectionServices ): string;

Returns the connection service name used to read or write data related to a model depending on the connection services

public function getCustomEventsManager( ModelInterface $model ): EventsManagerInterface | null;

Returns a custom events manager related to a model or null if there is no related events manager

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getEventsManager(): EventsManagerInterface | null;

Returns the internal event manager

public function getHasMany( ModelInterface $model ): RelationInterface[] | array;

Gets hasMany relations defined on a model

public function getHasManyRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;

Gets hasMany related records from a model

public function getHasManyToMany( ModelInterface $model ): RelationInterface[] | array;

Gets hasManyToMany relations defined on a model

public function getHasOne( ModelInterface $model ): array;

Gets hasOne relations defined on a model

public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];

Gets hasOne relations defined on a model

public function getHasOneRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ModelInterface | bool;

Gets belongsTo related records from a model

public function getHasOneThrough( ModelInterface $model ): RelationInterface[] | array;

Gets hasOneThrough relations defined on a model

public function getLastInitialized(): ModelInterface;

Get last initialized model

public function getLastQuery(): QueryInterface;

Returns the last query created or executed in the models manager

public function getModelPrefix(): string;

Returns the prefix for all model sources.

public function getModelSchema( ModelInterface $model ): string | null;

Returns the mapped schema for a model

public function getModelSource( ModelInterface $model ): string;

Returns the mapped source for a model

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to read data related to a model

public function getReadConnectionService( ModelInterface $model ): string;

Returns the connection service name used to read data related to a model

public function getRelationByAlias( string $modelName, string $alias ): RelationInterface | bool;

Returns a relation by its alias

public function getRelationRecords( RelationInterface $relation, ModelInterface $record, mixed $parameters = null, string $method = null );

Helper method to query records based on a relation definition

public function getRelations( string $modelName ): RelationInterface[];

Query all the relationships defined on a model

public function getRelationsBetween( string $first, string $second ): RelationInterface[] | bool;

Query the first relationship defined between two models

public function getReusableRecords( string $modelName, string $key );

Returns a reusable object from the internal list

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to write data related to a model

public function getWriteConnectionService( ModelInterface $model ): string;

Returns the connection service name used to write data related to a model

public function hasBelongsTo( string $modelName, string $modelRelation ): bool;

Checks whether a model has a belongsTo relation with another model

public function hasHasMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasMany relation with another model

public function hasHasManyToMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasManyToMany relation with another model

public function hasHasOne( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOne relation with another model

public function hasHasOneThrough( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOneThrough relation with another model

public function initialize( ModelInterface $model ): bool;

Initializes a model in the model manager

public function isInitialized( string $className ): bool;

Check whether a model is already initialized

public function isKeepingSnapshots( ModelInterface $model ): bool;

Checks if a model is keeping snapshots for the queried records

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

Checks if a model is using dynamic update instead of all-field update

final public function isVisibleModelProperty( ModelInterface $model, string $property ): bool;

Check whether a model property is declared as public.

$isPublic = $manager->isVisibleModelProperty(
    new Robots(),
    "name"
);

public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;

Sets if a model must keep snapshots

public function load( string $modelName ): ModelInterface;

Loads a model throwing an exception if it doesn't exist

public function missingMethod( ModelInterface $model, string $eventName, mixed $data );

Dispatch an event to the listeners and behaviors This method expects that the endpoint listeners/behaviors returns true meaning that a least one was implemented

public function notifyEvent( string $eventName, ModelInterface $model );

Receives events generated in the models and dispatches them to an events-manager if available. Notify the behaviors that are listening in the model

public function setConnectionService( ModelInterface $model, string $connectionService ): void;

Sets both write and read connection service for a model

public function setCustomEventsManager( ModelInterface $model, EventsManagerInterface $eventsManager ): void;

Sets a custom events manager for a specific model

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setEventsManager( EventsManagerInterface $eventsManager ): void;

Sets a global events manager

public function setModelPrefix( string $prefix ): void;

Sets the prefix for all model sources.

use Phalcon\Mvc\Model\Manager;

$di->set(
    "modelsManager",
    function () {
        $modelsManager = new Manager();

        $modelsManager->setModelPrefix("wp_");

        return $modelsManager;
    }
);

$robots = new Robots();

echo $robots->getSource(); // wp_robots

$param string $prefix

public function setModelSchema( ModelInterface $model, string $schema ): void;

Sets the mapped schema for a model

public function setModelSource( ModelInterface $model, string $source ): void;

Sets the mapped source for a model

public function setReadConnectionService( ModelInterface $model, string $connectionService ): void;

Sets read connection service for a model

public function setReusableRecords( string $modelName, string $key, mixed $records ): void;

Stores a reusable record in the internal list

public function setWriteConnectionService( ModelInterface $model, string $connectionService ): void;

Sets write connection service for a model

public function useDynamicUpdate( ModelInterface $model, bool $dynamicUpdate ): void;

Sets if a model must use dynamic update instead of the all-field update

protected function getConnection( ModelInterface $model, array $connectionServices ): AdapterInterface;

Returns the connection to read or write data related to a model depending on the connection services.

final protected function mergeFindParameters( mixed $findParamsOne, mixed $findParamsTwo ): array;

Merge two arrays of find parameters

Mvc\Model\ManagerInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Db\Adapter\AdapterInterface
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Query\BuilderInterface
- Phalcon\Mvc\Model\Query\StatusInterface
Extends
Implements

Phalcon\Mvc\Model\ManagerInterface

Interface for Phalcon\Mvc\Model\Manager

Methods¶

public function addBehavior( ModelInterface $model, BehaviorInterface $behavior ): void;

Binds a behavior to a model

public function addBelongsTo( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a relation reverse 1-1 between two models

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a relation 1-n between two models

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

Setups a relation n-m between two models

public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): RelationInterface;

Setup a 1-1 relation between two models

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

Setups a 1-1 relation between two models using an intermediate table

public function createBuilder( mixed $params = null ): BuilderInterface;

Creates a Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

Creates a Phalcon\Mvc\Model\Query without execute it

public function executeQuery( string $phql, mixed $placeholders = null, mixed $types = null ): mixed;

Creates a Phalcon\Mvc\Model\Query and execute it

public function getBelongsTo( ModelInterface $model ): RelationInterface[] | array;

Gets belongsTo relations defined on a model

public function getBelongsToRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;

Gets belongsTo related records from a model

public function getBuilder(): BuilderInterface | null;

Returns the newly created Phalcon\Mvc\Model\Query\Builder or null

public function getHasMany( ModelInterface $model ): RelationInterface[] | array;

Gets hasMany relations defined on a model

public function getHasManyRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;

Gets hasMany related records from a model

public function getHasManyToMany( ModelInterface $model ): RelationInterface[] | array;

Gets hasManyToMany relations defined on a model

public function getHasOne( ModelInterface $model ): RelationInterface[] | array;

Gets hasOne relations defined on a model

public function getHasOneAndHasMany( ModelInterface $model ): RelationInterface[];

Gets hasOne relations defined on a model

public function getHasOneRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ModelInterface | bool;

Gets hasOne related records from a model

public function getHasOneThrough( ModelInterface $model ): RelationInterface[] | array;

Gets hasOneThrough relations defined on a model

public function getLastInitialized(): ModelInterface;

Get last initialized model

public function getLastQuery(): QueryInterface;

Returns the last query created or executed in the models manager

public function getModelSchema( ModelInterface $model ): string | null;

Returns the mapped schema for a model

public function getModelSource( ModelInterface $model ): string;

Returns the mapped source for a model

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to read data related to a model

public function getReadConnectionService( ModelInterface $model ): string;

Returns the connection service name used to read data related to a model

public function getRelationByAlias( string $modelName, string $alias ): RelationInterface | bool;

Returns a relation by its alias

public function getRelationRecords( RelationInterface $relation, ModelInterface $record, mixed $parameters = null, string $method = null );

Helper method to query records based on a relation definition

public function getRelations( string $modelName ): RelationInterface[];

Query all the relationships defined on a model

public function getRelationsBetween( string $first, string $second ): RelationInterface[] | bool;

Query the relations between two models

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to write data related to a model

public function getWriteConnectionService( ModelInterface $model ): string;

Returns the connection service name used to write data related to a model

public function hasBelongsTo( string $modelName, string $modelRelation ): bool;

Checks whether a model has a belongsTo relation with another model

public function hasHasMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasMany relation with another model

public function hasHasManyToMany( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasManyToMany relation with another model

public function hasHasOne( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOne relation with another model

public function hasHasOneThrough( string $modelName, string $modelRelation ): bool;

Checks whether a model has a hasOneThrough relation with another model

public function initialize( ModelInterface $model );

Initializes a model in the model manager

public function isInitialized( string $className ): bool;

Check of a model is already initialized

public function isKeepingSnapshots( ModelInterface $model ): bool;

Checks if a model is keeping snapshots for the queried records

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

Checks if a model is using dynamic update instead of all-field update

public function isVisibleModelProperty( ModelInterface $model, string $property ): bool;

Check whether a model property is declared as public.

$isPublic = $manager->isVisibleModelProperty(
    new Robots(),
    "name"
);

public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;

Sets if a model must keep snapshots

public function load( string $modelName ): ModelInterface;

Loads a model throwing an exception if it doesn't exist

public function missingMethod( ModelInterface $model, string $eventName, mixed $data );

Dispatch an event to the listeners and behaviors This method expects that the endpoint listeners/behaviors returns true meaning that a least one is implemented

public function notifyEvent( string $eventName, ModelInterface $model );

Receives events generated in the models and dispatches them to an events-manager if available Notify the behaviors that are listening in the model

public function setConnectionService( ModelInterface $model, string $connectionService ): void;

Sets both write and read connection service for a model

public function setModelSchema( ModelInterface $model, string $schema ): void;

Sets the mapped schema for a model

public function setModelSource( ModelInterface $model, string $source ): void;

Sets the mapped source for a model

public function setReadConnectionService( ModelInterface $model, string $connectionService ): void;

Sets read connection service for a model

public function setWriteConnectionService( ModelInterface $model, string $connectionService );

Sets write connection service for a model

public function useDynamicUpdate( ModelInterface $model, bool $dynamicUpdate ): void;

Sets if a model must use dynamic update instead of the all-field update

Mvc\Model\MetaData ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Cache\Adapter\AdapterInterface
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\MetaData\Strategy\Introspection
- Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface
Extends
Implements
- InjectionAwareInterface
- MetaDataInterface

Phalcon\Mvc\Model\MetaData

Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc. This component collect them and store for further querying by Phalcon\Mvc\Model. Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.

A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:

$metaData = new \Phalcon\Mvc\Model\MetaData\Memory();

$attributes = $metaData->getAttributes(
    new Robots()
);

print_r($attributes);

Constants¶

const MODELS_ATTRIBUTES = 0;
const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
const MODELS_COLUMN_MAP = 0;
const MODELS_DATA_TYPES = 4;
const MODELS_DATA_TYPES_BIND = 9;
const MODELS_DATA_TYPES_NUMERIC = 5;
const MODELS_DATE_AT = 6;
const MODELS_DATE_IN = 7;
const MODELS_DEFAULT_VALUES = 12;
const MODELS_EMPTY_STRING_VALUES = 13;
const MODELS_IDENTITY_COLUMN = 8;
const MODELS_NON_PRIMARY_KEY = 2;
const MODELS_NOT_NULL = 3;
const MODELS_PRIMARY_KEY = 1;
const MODELS_REVERSE_COLUMN_MAP = 1;

Properties¶

/**
 * @var CacheAdapterInterface|null
 */
protected $adapter;

/**
 * @var array
 */
protected $columnMap;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var array
 */
protected $metaData;

/**
 * @var StrategyInterface|null
 */
protected $strategy;

Methods¶

public function getAdapter(): CacheAdapterInterface | null;

Return the internal cache adapter

public function getAttributes( ModelInterface $model ): array;

Returns table attributes names (fields)

print_r(
    $metaData->getAttributes(
        new Robots()
    )
);

public function getAutomaticCreateAttributes( ModelInterface $model ): array;

Returns attributes that must be ignored from the INSERT SQL generation

print_r(
    $metaData->getAutomaticCreateAttributes(
        new Robots()
    )
);

public function getAutomaticUpdateAttributes( ModelInterface $model ): array;

Returns attributes that must be ignored from the UPDATE SQL generation

print_r(
    $metaData->getAutomaticUpdateAttributes(
        new Robots()
    )
);

public function getBindTypes( ModelInterface $model ): array;

Returns attributes and their bind data types

print_r(
    $metaData->getBindTypes(
        new Robots()
    )
);

public function getColumnMap( ModelInterface $model ): array | null;

Returns the column map if any

print_r(
    $metaData->getColumnMap(
        new Robots()
    )
);

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getDataTypes( ModelInterface $model ): array;

Returns attributes and their data types

print_r(
    $metaData->getDataTypes(
        new Robots()
    )
);

public function getDataTypesNumeric( ModelInterface $model ): array;

Returns attributes which types are numerical

print_r(
    $metaData->getDataTypesNumeric(
        new Robots()
    )
);

public function getDefaultValues( ModelInterface $model ): array;

Returns attributes (which have default values) and their default values

print_r(
    $metaData->getDefaultValues(
        new Robots()
    )
);

public function getEmptyStringAttributes( ModelInterface $model ): array;

Returns attributes allow empty strings

print_r(
    $metaData->getEmptyStringAttributes(
        new Robots()
    )
);

public function getIdentityField( ModelInterface $model ): string | null;

Returns the name of identity field (if one is present)

print_r(
    $metaData->getIdentityField(
        new Robots()
    )
);

public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;

Returns an array of fields which are not part of the primary key

print_r(
    $metaData->getNonPrimaryKeyAttributes(
        new Robots()
    )
);

public function getNotNullAttributes( ModelInterface $model ): array;

Returns an array of not null attributes

print_r(
    $metaData->getNotNullAttributes(
        new Robots()
    )
);

public function getPrimaryKeyAttributes( ModelInterface $model ): array;

Returns an array of fields which are part of the primary key

print_r(
    $metaData->getPrimaryKeyAttributes(
        new Robots()
    )
);

public function getReverseColumnMap( ModelInterface $model ): array | null;

Returns the reverse column map if any

print_r(
    $metaData->getReverseColumnMap(
        new Robots()
    )
);

public function getStrategy(): StrategyInterface;

Return the strategy to obtain the meta-data

public function hasAttribute( ModelInterface $model, string $attribute ): bool;

Check if a model has certain attribute

var_dump(
    $metaData->hasAttribute(
        new Robots(),
        "name"
    )
);

public function isEmpty(): bool;

Checks if the internal meta-data container is empty

var_dump(
    $metaData->isEmpty()
);

public function read( string $key ): array | null;

Reads metadata from the adapter

final public function readColumnMap( ModelInterface $model ): array | null;

Reads the ordered/reversed column map for certain model

print_r(
    $metaData->readColumnMap(
        new Robots()
    )
);

final public function readColumnMapIndex( ModelInterface $model, int $index ): array | null;

Reads column-map information for certain model using a MODEL_* constant

print_r(
    $metaData->readColumnMapIndex(
        new Robots(),
        MetaData::MODELS_REVERSE_COLUMN_MAP
    )
);

final public function readMetaData( ModelInterface $model ): array | null;

Reads the complete meta-data for certain model

print_r(
    $metaData->readMetaData(
        new Robots()
    )
);

final public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;

Reads meta-data for certain model

print_r(
    $metaData->readMetaDataIndex(
        new Robots(),
        0
    )
);

public function reset(): void;

Resets internal meta-data in order to regenerate it

$metaData->reset();

public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes ): void;

Set the attributes that must be ignored from the INSERT SQL generation

$metaData->setAutomaticCreateAttributes(
    new Robots(),
    [
        "created_at" => true,
    ]
);

public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes ): void;

Set the attributes that must be ignored from the UPDATE SQL generation

$metaData->setAutomaticUpdateAttributes(
    new Robots(),
    [
        "modified_at" => true,
    ]
);

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void;

Set the attributes that allow empty string values

$metaData->setEmptyStringAttributes(
    new Robots(),
    [
        "name" => true,
    ]
);

public function setStrategy( StrategyInterface $strategy ): void;

Set the meta-data extraction strategy

public function write( string $key, array $data ): void;

Writes the metadata to adapter

final public function writeMetaDataIndex( ModelInterface $model, int $index, mixed $data ): void;

Writes meta-data for certain model using a MODEL_* constant

print_r(
    $metaData->writeColumnMapIndex(
        new Robots(),
        MetaData::MODELS_REVERSE_COLUMN_MAP,
        [
            "leName" => "name",
        ]
    )
);

protected function getArrVal( array $collection, mixed $index, mixed $defaultValue = null ): mixed;

@todo Remove this when we get traits

final protected function initialize( ModelInterface $model, mixed $key, mixed $table, mixed $schema );

Initialize old behaviour for compatability

final protected function initializeColumnMap( ModelInterface $model, mixed $key ): bool;

Initialize ColumnMap for a certain table

final protected function initializeMetaData( ModelInterface $model, mixed $key ): bool;

Initialize the metadata for certain table

Mvc\Model\MetaData\Apcu¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData
Uses
- Phalcon\Cache\AdapterFactory
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends

MetaData
Implements

Phalcon\Mvc\Model\MetaData\Apcu

Stores model meta-data in the APCu cache. Data will erased if the web server is restarted

By default meta-data is stored for 48 hours (172800 seconds)

You can query the meta-data by printing apcu_fetch('$PMM$') or apcu_fetch('$PMM$my-app-id')

$metaData = new \Phalcon\Mvc\Model\MetaData\Apcu(
    [
        "prefix"   => "my-app-id",
        "lifetime" => 86400,
    ]
);

Methods¶

public function __construct( AdapterFactory $factory, array $options = null );

Phalcon\Mvc\Model\MetaData\Apcu constructor

Mvc\Model\MetaData\Libmemcached¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData
Uses
- Phalcon\Cache\AdapterFactory
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends

MetaData
Implements

Phalcon\Mvc\Model\MetaData\Libmemcached

Stores model meta-data in the Memcache.

By default meta-data is stored for 48 hours (172800 seconds)

Methods¶

public function __construct( AdapterFactory $factory, array $options = [] );

Phalcon\Mvc\Model\MetaData\Libmemcached constructor

public function reset(): void;

Flush Memcache data and resets internal meta-data in order to regenerate it

Mvc\Model\MetaData\Memory¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData
Uses
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends

MetaData
Implements

Phalcon\Mvc\Model\MetaData\Memory

Stores model meta-data in memory. Data will be erased when the request finishes

Methods¶

public function __construct( mixed $options = null );

Phalcon\Mvc\Model\MetaData\Memory constructor

public function read( string $key ): array | null;

Reads the meta-data from temporal memory

public function write( string $key, array $data ): void;

Writes the meta-data to temporal memory

Mvc\Model\MetaData\Redis¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData
Uses
- Phalcon\Cache\AdapterFactory
- Phalcon\Mvc\Model\MetaData
Extends

MetaData
Implements

Phalcon\Mvc\Model\MetaData\Redis

Stores model meta-data in the Redis.

By default meta-data is stored for 48 hours (172800 seconds)

use Phalcon\Mvc\Model\MetaData\Redis;

$metaData = new Redis(
    [
        "host"       => "127.0.0.1",
        "port"       => 6379,
        "persistent" => 0,
        "lifetime"   => 172800,
        "index"      => 2,
    ]
);

Methods¶

public function __construct( AdapterFactory $factory, array $options = [] );

Phalcon\Mvc\Model\MetaData\Redis constructor

public function reset(): void;

Flush Redis data and resets internal meta-data in order to regenerate it

Mvc\Model\MetaData\Strategy\Annotations¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData\Strategy
Uses
- Phalcon\Db\Column
- Phalcon\Di\DiInterface
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends
Implements
- StrategyInterface

This file is part of the Phalcon Framework.

(c) Phalcon Team team@phalcon.io

For the full copyright and license information, please view the LICENSE.txt file that was distributed with this source code.

Methods¶

final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;

Read the model's column map, this can't be inferred

final public function getMetaData( ModelInterface $model, DiInterface $container ): array;

The meta-data is obtained by reading the column descriptions from the database information schema

Mvc\Model\MetaData\Strategy\Introspection¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData\Strategy
Uses
- Phalcon\Db\Adapter\AdapterInterface
- Phalcon\Db\Column
- Phalcon\Di\DiInterface
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends
Implements
- StrategyInterface

Phalcon\Mvc\Model\MetaData\Strategy\Introspection

Queries the table meta-data in order to introspect the model's metadata

Methods¶

final public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;

Read the model's column map, this can't be inferred

final public function getMetaData( ModelInterface $model, DiInterface $container ): array;

The meta-data is obtained by reading the column descriptions from the database information schema

Mvc\Model\MetaData\Strategy\StrategyInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData\Strategy
Uses
- Phalcon\Di\DiInterface
- Phalcon\Mvc\ModelInterface
Extends
Implements

This file is part of the Phalcon Framework.

(c) Phalcon Team team@phalcon.io

For the full copyright and license information, please view the LICENSE.txt file that was distributed with this source code.

Methods¶

public function getColumnMaps( ModelInterface $model, DiInterface $container ): array;

Read the model's column map, this can't be inferred

@todo Not implemented

public function getMetaData( ModelInterface $model, DiInterface $container ): array;

The meta-data is obtained by reading the column descriptions from the database information schema

Mvc\Model\MetaData\Stream¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\MetaData
Uses
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\MetaData
Extends

MetaData
Implements

Phalcon\Mvc\Model\MetaData\Stream

Stores model meta-data in PHP files.

$metaData = new \Phalcon\Mvc\Model\MetaData\Files(
    [
        "metaDataDir" => "app/cache/metadata/",
    ]
);

Properties¶

/**
 * @var string
 */
protected $metaDataDir = ./;

Methods¶

public function __construct( array $options = [] );

Phalcon\Mvc\Model\MetaData\Files constructor

public function read( string $key ): array | null;

Reads meta-data from files

public function write( string $key, array $data ): void;

Writes the meta-data to files

Mvc\Model\MetaDataInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface
Extends
Implements

Phalcon\Mvc\Model\MetaDataInterface

Interface for Phalcon\Mvc\Model\MetaData

Methods¶

public function getAttributes( ModelInterface $model ): array;

Returns table attributes names (fields)

public function getAutomaticCreateAttributes( ModelInterface $model ): array;

Returns attributes that must be ignored from the INSERT SQL generation

public function getAutomaticUpdateAttributes( ModelInterface $model ): array;

Returns attributes that must be ignored from the UPDATE SQL generation

public function getBindTypes( ModelInterface $model ): array;

Returns attributes and their bind data types

public function getColumnMap( ModelInterface $model ): array | null;

Returns the column map if any

public function getDataTypes( ModelInterface $model ): array;

Returns attributes and their data types

public function getDataTypesNumeric( ModelInterface $model ): array;

Returns attributes which types are numerical

public function getDefaultValues( ModelInterface $model ): array;

Returns attributes (which have default values) and their default values

public function getEmptyStringAttributes( ModelInterface $model ): array;

Returns attributes allow empty strings

public function getIdentityField( ModelInterface $model ): string | null;

Returns the name of identity field (if one is present)

public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;

Returns an array of fields which are not part of the primary key

public function getNotNullAttributes( ModelInterface $model ): array;

Returns an array of not null attributes

public function getPrimaryKeyAttributes( ModelInterface $model ): array;

Returns an array of fields which are part of the primary key

public function getReverseColumnMap( ModelInterface $model ): array | null;

Returns the reverse column map if any

public function getStrategy(): StrategyInterface;

Return the strategy to obtain the meta-data

public function hasAttribute( ModelInterface $model, string $attribute ): bool;

Check if a model has certain attribute

public function isEmpty(): bool;

Checks if the internal meta-data container is empty

public function read( string $key ): array | null;

Reads meta-data from the adapter

public function readColumnMap( ModelInterface $model ): array | null;

Reads the ordered/reversed column map for certain model

public function readColumnMapIndex( ModelInterface $model, int $index ): array | null;

Reads column-map information for certain model using a MODEL_* constant

public function readMetaData( ModelInterface $model ): array | null;

Reads meta-data for certain model

public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;

Reads meta-data for certain model using a MODEL_* constant

public function reset();

Resets internal meta-data in order to regenerate it

public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes );

Set the attributes that must be ignored from the INSERT SQL generation

public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes );

Set the attributes that must be ignored from the UPDATE SQL generation

public function setEmptyStringAttributes( ModelInterface $model, array $attributes ): void;

Set the attributes that allow empty string values

public function setStrategy( StrategyInterface $strategy );

Set the meta-data extraction strategy

public function write( string $key, array $data ): void;

Writes meta-data to the adapter

public function writeMetaDataIndex( ModelInterface $model, int $index, mixed $data );

Writes meta-data for certain model using a MODEL_* constant

Mvc\Model\Query¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- 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\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
Extends
Implements
- InjectionAwareInterface
- QueryInterface

Phalcon\Mvc\Model\Query

This class takes a PHQL intermediate representation and executes it.

$phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
         WHERE b.name = :name: ORDER BY c.name";

$result = $manager->executeQuery(
    $phql,
    [
        "name" => "Lamborghini",
    ]
);

foreach ($result as $row) {
    echo "Name: ",  $row->cars->name, "\n";
    echo "Price: ", $row->cars->price, "\n";
    echo "Taxes: ", $row->taxes, "\n";
}

// with transaction
use Phalcon\Mvc\Model\Query;
use Phalcon\Mvc\Model\Transaction;

// $di needs to have the service "db" registered for this to work
$di = Phalcon\Di\FactoryDefault::getDefault();

$phql = 'SELECTFROM robot';

$myTransaction = new Transaction($di);
$myTransaction->begin();

$newRobot = new Robot();
$newRobot->setTransaction($myTransaction);
$newRobot->type = "mechanical";
$newRobot->name = "Astro Boy";
$newRobot->year = 1952;
$newRobot->save();

$queryWithTransaction = new Query($phql, $di);
$queryWithTransaction->setTransaction($myTransaction);

$resultWithEntries = $queryWithTransaction->execute();

$queryWithOutTransaction = new Query($phql, $di);
$resultWithOutEntries = $queryWithTransaction->execute();

Constants¶

const TYPE_DELETE = 303;
const TYPE_INSERT = 306;
const TYPE_SELECT = 309;
const TYPE_UPDATE = 300;

Properties¶

/**
 * @var array
 * TODO: Add default value, instead of null, also remove type check
 */
protected $ast;

/**
 * @var array
 */
protected $bindParams;

/**
 * @var array
 */
protected $bindTypes;

/**
 * @var mixed|null
 */
protected $cache;

/**
 * @var array|null
 */
protected $cacheOptions;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var bool
 */
protected $enableImplicitJoins;

/**
 * @var array
 */
protected $intermediate;

/**
 * @var \Phalcon\Mvc\Model\ManagerInterface|null
 */
protected $manager;

/**
 * @var \Phalcon\Mvc\Model\MetaDataInterface|null
 */
protected $metaData;

/**
 * @var array
 */
protected $models;

/**
 * @var array
 */
protected $modelsInstances;

/**
 * @var int
 */
protected $nestingLevel = -1;

/**
 * @var string|null
 */
protected $phql;

/**
 * @var bool
 */
protected $sharedLock = false;

/**
 * @var array
 */
protected $sqlAliases;

/**
 * @var array
 */
protected $sqlAliasesModels;

/**
 * @var array
 */
protected $sqlAliasesModelsInstances;

/**
 * @var array
 */
protected $sqlColumnAliases;

/**
 * @var array
 */
protected $sqlModelsAliases;

/**
 * @var int|null
 */
protected $type;

/**
 * @var bool
 */
protected $uniqueRow = false;

/**
 * TransactionInterface so that the query can wrap a transaction
 * around batch updates and intermediate selects within the transaction.
 * however if a model got a transaction set inside it will use the local
 * transaction instead of this one
 *
 * @var TransactionInterface|null
 */
protected $transaction;

/**
 * @var array|null
 */
protected static $internalPhqlCache;

Methods¶

public function __construct( string $phql = null, DiInterface $container = null, array $options = [] );

Phalcon\Mvc\Model\Query constructor

public function cache( array $cacheOptions ): QueryInterface;

Sets the cache parameters of the query

public static function clean(): void;

Destroys the internal PHQL cache

public function execute( array $bindParams = [], array $bindTypes = [] );

Executes a parsed PHQL statement

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getCache(): AdapterInterface;

Returns the current cache backend instance

public function getCacheOptions(): array;

Returns the current cache options

public function getDI(): DiInterface;

Returns the dependency injection container

public function getIntermediate(): array;

Returns the intermediate representation of the PHQL statement

public function getSingleResult( array $bindParams = [], array $bindTypes = [] ): ModelInterface;

Executes the query returning the first result

public function getSql(): array;

Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)

public function getTransaction(): TransactionInterface | null;

public function getType(): int;

Gets the type of PHQL statement executed

public function getUniqueRow(): bool;

Check if the query is programmed to get only the first row in the resultset

public function parse(): array;

Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query

public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setDI( DiInterface $container ): void;

Sets the dependency injection container

public function setIntermediate( array $intermediate ): QueryInterface;

Allows to set the IR to be executed

public function setSharedLock( bool $sharedLock = bool ): QueryInterface;

Set SHARED LOCK clause

public function setTransaction( TransactionInterface $transaction ): QueryInterface;

allows to wrap a transaction around all queries

public function setType( int $type ): QueryInterface;

Sets the type of PHQL statement to be executed

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Tells to the query if only the first row in the resultset must be returned

final protected function _prepareDelete(): array;

Analyzes a DELETE intermediate code and produces an array to be executed later

final protected function _prepareInsert(): array;

Analyzes an INSERT intermediate code and produces an array to be executed later

final protected function _prepareSelect( mixed $ast = null, bool $merge = bool ): array;

Analyzes a SELECT intermediate code and produces an array to be executed later

final protected function _prepareUpdate(): array;

Analyzes an UPDATE intermediate code and produces an array to be executed later

final protected function executeDelete( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function executeInsert( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function executeSelect( array $intermediate, array $bindParams, array $bindTypes, bool $simulate = bool ): ResultsetInterface | array;

Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset

final protected function executeUpdate( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function getCallArgument( array $argument ): array;

Resolves an expression in a single call argument

final protected function getCaseExpression( array $expr ): array;

Resolves an expression in a single call argument

final protected function getExpression( array $expr, bool $quoting = bool ): array;

Resolves an expression from its intermediate code into an array

final protected function getFunctionCall( array $expr ): array;

Resolves an expression in a single call argument

final protected function getGroupClause( array $group ): array;

Returns a processed group clause for a SELECT statement

final protected function getJoin( ManagerInterface $manager, array $join ): array;

Resolves a JOIN clause checking if the associated models exist

final protected function getJoinType( array $join ): string;

Resolves a JOIN type

final protected function getJoins( array $select ): array;

Processes the JOINs in the query returning an internal representation for the database dialect

final protected function getLimitClause( array $limitClause ): array;

Returns a processed limit clause for a SELECT statement

final protected function getMultiJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;

Resolves joins involving many-to-many relations

final protected function getOrderClause( mixed $order ): array;

Returns a processed order clause for a SELECT statement

final protected function getQualified( array $expr ): array;

Replaces the model's name to its source name in a qualified-name expression

protected function getReadConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;

Gets the read connection from the model if there is no transaction set inside the query object

final protected function getRelatedRecords( ModelInterface $model, array $intermediate, array $bindParams, array $bindTypes ): ResultsetInterface;

Query the records on which the UPDATE/DELETE operation will be done

final protected function getSelectColumn( array $column ): array;

Resolves a column from its intermediate representation into an array used to determine if the resultset produced is simple or complex

final protected function getSingleJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;

Resolves joins involving has-one/belongs-to/has-many relations

final protected function getTable( ManagerInterface $manager, array $qualifiedName );

Resolves a table in a SELECT statement checking if the model exists

protected function getWriteConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;

Gets the write connection from the model if there is no transaction inside the query object

Mvc\Model\Query\Builder¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Query
Uses
- Phalcon\Db\Column
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\QueryInterface
Extends
Implements
- BuilderInterface
- InjectionAwareInterface

Helps to create PHQL queries using an OO interface

$params = [
    "models"     => [
        Users::class,
    ],
    "columns"    => ["id", "name", "status"],
    "conditions" => [
        [
            "created > :min: AND created < :max:",
            [
                "min" => "2013-01-01",
                "max" => "2014-01-01",
            ],
            [
                "min" => PDO::PARAM_STR,
                "max" => PDO::PARAM_STR,
            ],
        ],
    ],
    // or "conditions" => "created > '2013-01-01' AND created < '2014-01-01'",
    "group"      => ["id", "name"],
    "having"     => "name = 'Kamil'",
    "order"      => ["name", "id"],
    "limit"      => 20,
    "offset"     => 20,
    // or "limit" => [20, 20],
];

$queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);

Properties¶

/**
 * @var array
 */
protected $bindParams;

/**
 * @var array
 */
protected $bindTypes;

/**
 * @var array|string|null
 */
protected $columns;

/**
 * @var array|string|null
 */
protected $conditions;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var mixed
 */
protected $distinct;

/**
 * @var bool
 */
protected $forUpdate = false;

/**
 * @var array
 */
protected $group;

/**
 * @var string|null
 */
protected $having;

/**
 * @var int
 */
protected $hiddenParamNumber = ;

/**
 * @var array
 */
protected $joins;

/**
 * @var array|string
 */
protected $limit;

/**
 * @var array|string
 */
protected $models;

/**
 * @var int
 */
protected $offset = ;

/**
 * @var array|string
 */
protected $order;

/**
 * @var bool
 */
protected $sharedLock = false;

Methods¶

public function __construct( mixed $params = null, DiInterface $container = null );

Phalcon\Mvc\Model\Query\Builder constructor

public function addFrom( string $model, string $alias = null ): BuilderInterface;

Add a model to take part of the query

// Load data from models Robots
$builder->addFrom(
    Robots::class
);

// Load data from model 'Robots' using 'r' as alias in PHQL
$builder->addFrom(
    Robots::class,
    "r"
);

public function andHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current HAVING conditions clause using a AND operator

$builder->andHaving("SUM(Robots.price) > 0");

$builder->andHaving(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);

public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current WHERE conditions using a AND operator

$builder->andWhere("name = 'Peter'");

$builder->andWhere(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);

final public function autoescape( string $identifier ): string;

Automatically escapes identifiers but only if they need to be escaped.

public function betweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current HAVING conditions clause

$builder->betweenHaving("SUM(Robots.price)", 100.25, 200.50);

public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current WHERE conditions

$builder->betweenWhere("price", 100.25, 200.50);

public function columns( mixed $columns ): BuilderInterface;

Sets the columns to be queried. 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

// String, comma separated values
$builder->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",
    ]
);

public function distinct( mixed $distinct ): BuilderInterface;

Sets SELECT DISTINCT / SELECT ALL flag

$builder->distinct("status");
$builder->distinct(null);

public function forUpdate( bool $forUpdate ): BuilderInterface;

Sets a FOR UPDATE clause

$builder->forUpdate(true);

public function from( mixed $models ): BuilderInterface;

Sets the models who makes part of the query

$builder->from(
    Robots::class
);

$builder->from(
    [
        Robots::class,
        RobotsParts::class,
    ]
);

$builder->from(
    [
        "r"  => Robots::class,
        "rp" => RobotsParts::class,
    ]
);

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getColumns();

Return the columns to be queried

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getDistinct(): bool;

Returns SELECT DISTINCT / SELECT ALL flag

public function getFrom();

Return the models who makes part of the query

public function getGroupBy(): array;

Returns the GROUP BY clause

public function getHaving(): string;

Return the current having clause

public function getJoins(): array;

Return join parts of the query

public function getLimit();

Returns the current LIMIT clause

public function getModels(): string | array | null;

Returns the models involved in the query

public function getOffset(): int;

Returns the current OFFSET clause

public function getOrderBy();

Returns the set ORDER BY clause

final public function getPhql(): string;

Returns a PHQL statement built based on the builder parameters

public function getQuery(): QueryInterface;

Returns the query built

public function getWhere();

Return the conditions for the query

public function groupBy( mixed $group ): BuilderInterface;

Sets a GROUP BY clause

$builder->groupBy(
    [
        "Robots.name",
    ]
);

public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets the HAVING condition clause

$builder->having("SUM(Robots.price) > 0");

$builder->having(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);

public function inHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current HAVING conditions clause

$builder->inHaving("SUM(Robots.price)", [100, 200]);

public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current WHERE conditions

$builder->inWhere(
    "id",
    [1, 2, 3]
);

public function innerJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds an INNER join to the query

// Inner Join model 'Robots' with automatic conditions and alias
$builder->innerJoin(
    Robots::class
);

// Inner Join model 'Robots' specifying conditions
$builder->innerJoin(
    Robots::class,
    "Robots.id = RobotsParts.robots_id"
);

// Inner Join model 'Robots' specifying conditions and alias
$builder->innerJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function join( string $model, string $conditions = null, string $alias = null, string $type = null ): BuilderInterface;

Adds an :type: join (by default type - INNER) to the query

// Inner Join model 'Robots' with automatic conditions and alias
$builder->join(
    Robots::class
);

// Inner Join model 'Robots' specifying conditions
$builder->join(
    Robots::class,
    "Robots.id = RobotsParts.robots_id"
);

// Inner Join model 'Robots' specifying conditions and alias
$builder->join(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

// Left Join model 'Robots' specifying conditions, alias and type of join
$builder->join(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r",
    "LEFT"
);

public function leftJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a LEFT join to the query

$builder->leftJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function limit( int $limit, mixed $offset = null ): BuilderInterface;

Sets a LIMIT clause, optionally an offset clause

$builder->limit(100);
$builder->limit(100, 20);
$builder->limit("100", "20");

public function notBetweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current HAVING conditions clause

$builder->notBetweenHaving("SUM(Robots.price)", 100.25, 200.50);

public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current WHERE conditions

$builder->notBetweenWhere("price", 100.25, 200.50);

public function notInHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current HAVING conditions clause

$builder->notInHaving("SUM(Robots.price)", [100, 200]);

public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current WHERE conditions

$builder->notInWhere("id", [1, 2, 3]);

public function offset( int $offset ): BuilderInterface;

Sets an OFFSET clause

$builder->offset(30);

public function orHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current HAVING conditions clause using an OR operator

$builder->orHaving("SUM(Robots.price) > 0");

$builder->orHaving(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);

public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using an OR operator

$builder->orWhere("name = 'Peter'");

$builder->orWhere(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);

public function orderBy( mixed $orderBy ): BuilderInterface;

Sets an ORDER BY condition clause

$builder->orderBy("Robots.name");
$builder->orderBy(["1", "Robots.name"]);
$builder->orderBy(["Robots.name DESC"]);

public function rightJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a RIGHT join to the query

$builder->rightJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;

Set default bind types

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets the query WHERE conditions

$builder->where(100);

$builder->where("name = 'Peter'");

$builder->where(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);

protected function conditionBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;

Appends a BETWEEN condition

protected function conditionIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;

Appends an IN condition

protected function conditionNotBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;

Appends a NOT BETWEEN condition

protected function conditionNotIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;

Appends a NOT IN condition

Mvc\Model\Query\BuilderInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Query
Uses
- Phalcon\Mvc\Model\QueryInterface
Extends
Implements

Phalcon\Mvc\Model\Query\BuilderInterface

Interface for Phalcon\Mvc\Model\Query\Builder

Constants¶

const OPERATOR_AND = and;
const OPERATOR_OR = or;

Methods¶

public function addFrom( string $model, string $alias = null ): BuilderInterface;

Add a model to take part of the query

public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using a AND operator

public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current conditions

public function columns( mixed $columns ): BuilderInterface;

Sets the columns to be queried. 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

// String, comma separated values
$builder->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",
    ]
);

public function distinct( mixed $distinct ): BuilderInterface;

Sets SELECT DISTINCT / SELECT ALL flag

$builder->distinct("status");
$builder->distinct(null);

public function forUpdate( bool $forUpdate ): BuilderInterface;

Sets a FOR UPDATE clause

$builder->forUpdate(true);

public function from( mixed $models ): BuilderInterface;

Sets the models who makes part of the query

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getColumns();

Return the columns to be queried

public function getDistinct(): bool;

Returns SELECT DISTINCT / SELECT ALL flag

public function getFrom();

Return the models who makes part of the query

public function getGroupBy(): array;

Returns the GROUP BY clause

public function getHaving(): string;

Returns the HAVING condition clause

public function getJoins(): array;

Return join parts of the query

public function getLimit();

Returns the current LIMIT clause

public function getModels(): string | array | null;

Returns the models involved in the query

public function getOffset(): int;

Returns the current OFFSET clause

public function getOrderBy();

Return the set ORDER BY clause

public function getPhql(): string;

Returns a PHQL statement built based on the builder parameters

public function getQuery(): QueryInterface;

Returns the query built

public function getWhere();

Return the conditions for the query

public function groupBy( mixed $group ): BuilderInterface;

Sets a GROUP BY clause

public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets a HAVING condition clause

public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current conditions

public function innerJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds an INNER join to the query

public function join( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds an :type: join (by default type - INNER) to the query

public function leftJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a LEFT join to the query

public function limit( int $limit, mixed $offset = null ): BuilderInterface;

Sets a LIMIT clause

public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current conditions

public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current conditions

public function offset( int $offset ): BuilderInterface;

Sets an OFFSET clause

public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using an OR operator

public function orderBy( mixed $orderBy ): BuilderInterface;

Sets an ORDER BY condition clause

public function rightJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a RIGHT join to the query

public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;

Set default bind types

public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets conditions for the query

Mvc\Model\Query\Lang ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Query
Uses
Extends
Implements

Phalcon\Mvc\Model\Query\Lang

PHQL is implemented as a parser (written in C) that translates syntax in that of the target RDBMS. It allows Phalcon to offer a unified SQL language to the developer, while internally doing all the work of translating PHQL instructions to the most optimal SQL instructions depending on the RDBMS type associated with a model.

To achieve the highest performance possible, we wrote a parser that uses the same technology as SQLite. This technology provides a small in-memory parser with a very low memory footprint that is also thread-safe.

use Phalcon\Mvc\Model\Query\Lang;

$intermediate = Lang::parsePHQL(
    "SELECT r.* FROM Robots r LIMIT 10"
);

Methods¶

public static function parsePHQL( string $phql ): array;

Parses a PHQL statement returning an intermediate representation (IR)

Mvc\Model\Query\Status¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Query
Uses
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\ModelInterface
Extends
Implements
- StatusInterface

Phalcon\Mvc\Model\Query\Status

This class represents the status returned by a PHQL statement like INSERT, UPDATE or DELETE. It offers context information and the related messages produced by the model which finally executes the operations when it fails

$phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";

$status = $app->modelsManager->executeQuery(
    $phql,
    [
        "id"   => 100,
        "name" => "Astroy Boy",
        "type" => "mechanical",
        "year" => 1959,
    ]
);

// Check if the update was successful
if ($status->success()) {
    echo "OK";
}

Properties¶

/**
 * @var ModelInterface|null
 */
protected $model;

/**
 * @var bool
 */
protected $success;

Methods¶

public function __construct( bool $success, ModelInterface $model = null );

Phalcon\Mvc\Model\Query\Status

public function getMessages(): MessageInterface[];

Returns the messages produced because of a failed operation

public function getModel(): ModelInterface;

Returns the model that executed the action

public function success(): bool;

Allows to check if the executed operation was successful

Mvc\Model\Query\StatusInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Query
Uses
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\ModelInterface
Extends
Implements

Phalcon\Mvc\Model\Query\StatusInterface

Interface for Phalcon\Mvc\Model\Query\Status

Methods¶

public function getMessages(): MessageInterface[];

Returns the messages produced by an operation failed

public function getModel(): ModelInterface;

Returns the model which executed the action

public function success(): bool;

Allows to check if the executed operation was successful

Mvc\Model\QueryInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
Extends
Implements

Phalcon\Mvc\Model\QueryInterface

Interface for Phalcon\Mvc\Model\Query

Methods¶

public function cache( array $cacheOptions ): QueryInterface;

Sets the cache parameters of the query

public function execute( array $bindParams = [], array $bindTypes = [] );

Executes a parsed PHQL statement

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getCacheOptions(): array;

Returns the current cache options

public function getSingleResult( array $bindParams = [], array $bindTypes = [] ): ModelInterface;

Executes the query returning the first result

public function getSql(): array;

Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)

public function getUniqueRow(): bool;

Check if the query is programmed to get only the first row in the resultset

public function parse(): array;

Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query

public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setSharedLock( bool $sharedLock = bool ): QueryInterface;

Set SHARED LOCK clause

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Tells to the query if only the first row in the resultset must be returned

Mvc\Model\Relation¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
Extends
Implements
- RelationInterface

Phalcon\Mvc\Model\Relation

This class represents a relationship between two models

Constants¶

const ACTION_CASCADE = 2;
const ACTION_RESTRICT = 1;
const BELONGS_TO = 0;
const HAS_MANY = 2;
const HAS_MANY_THROUGH = 4;
const HAS_ONE = 1;
const HAS_ONE_THROUGH = 3;
const NO_ACTION = 0;

Properties¶

/**
 * @var array|string
 */
protected $fields;

/**
 * @var array|string
 */
protected $intermediateFields;

/**
 * @var string|null
 */
protected $intermediateModel;

/**
 * @var array|string
 */
protected $intermediateReferencedFields;

/**
 * @var array
 */
protected $options;

/**
 * @var array|string
 */
protected $referencedFields;

/**
 * @var string
 */
protected $referencedModel;

/**
 * @var int
 */
protected $type;

Methods¶

public function __construct( int $type, string $referencedModel, mixed $fields, mixed $referencedFields, array $options = [] );

Phalcon\Mvc\Model\Relation constructor

public function getFields();

Returns the fields

public function getForeignKey();

Returns the foreign key configuration

public function getIntermediateFields();

Gets the intermediate fields for has-*-through relations

public function getIntermediateModel(): string;

Gets the intermediate model for has-*-through relations

public function getIntermediateReferencedFields();

Gets the intermediate referenced fields for has-*-through relations

public function getOption( string $name );

Returns an option by the specified name If the option doesn't exist null is returned

public function getOptions(): array;

Returns the options

public function getParams();

Returns parameters that must be always used when the related records are obtained

public function getReferencedFields();

Returns the referenced fields

public function getReferencedModel(): string;

Returns the referenced model

public function getType(): int;

Returns the relation type

public function isForeignKey(): bool;

Check whether the relation act as a foreign key

public function isReusable(): bool;

Check if records returned by getting belongs-to/has-many are implicitly cached during the current request

public function isThrough(): bool;

Check whether the relation is a 'many-to-many' relation or not

public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );

Sets the intermediate model data for has-*-through relations

Mvc\Model\RelationInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
Extends
Implements

Phalcon\Mvc\Model\RelationInterface

Interface for Phalcon\Mvc\Model\Relation

Methods¶

public function getFields();

Returns the fields

public function getForeignKey();

Returns the foreign key configuration

public function getIntermediateFields();

Gets the intermediate fields for has-*-through relations

public function getIntermediateModel(): string;

Gets the intermediate model for has-*-through relations

public function getIntermediateReferencedFields();

Gets the intermediate referenced fields for has-*-through relations

public function getOption( string $name );

Returns an option by the specified name If the option doesn't exist null is returned

public function getOptions(): array;

Returns the options

public function getParams();

Returns parameters that must be always used when the related records are obtained

public function getReferencedFields();

Returns the referenced fields

public function getReferencedModel(): string;

Returns the referenced model

public function getType(): int;

Returns the relations type

public function isForeignKey(): bool;

Check whether the relation act as a foreign key

public function isReusable(): bool;

Check if records returned by getting belongs-to/has-many are implicitly cached during the current request

public function isThrough(): bool;

Check whether the relation is a 'many-to-many' relation or not

public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );

Sets the intermediate model data for has-*-through relations

Mvc\Model\ResultInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
Extends
Implements

Phalcon\Mvc\Model\ResultInterface

All single objects passed as base objects to Resultsets must implement this interface

Methods¶

public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Sets the object's state

Mvc\Model\Resultset ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- ArrayAccess
- Closure
- Countable
- Iterator
- JsonSerializable
- Phalcon\Cache\CacheInterface
- Phalcon\Db\Enum
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\Model
- Phalcon\Mvc\ModelInterface
- Phalcon\Storage\Serializer\SerializerInterface
- SeekableIterator
- Serializable
Extends
Implements
- ArrayAccess
- Countable
- Iterator
- JsonSerializable
- ResultsetInterface
- SeekableIterator
- Serializable

Phalcon\Mvc\Model\Resultset

This component allows to Phalcon\Mvc\Model returns large resultsets with the minimum memory consumption Resultsets can be traversed using a standard foreach or a while statement. If a resultset is serialized it will dump all the rows into a big array. Then unserialize will retrieve the rows as they were before serializing.

// Using a standard foreach
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

foreach ($robots as robot) {
    echo robot->name, "\n";
}

// Using a while
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

$robots->rewind();

while ($robots->valid()) {
    $robot = $robots->current();

    echo $robot->name, "\n";

    $robots->next();
}

Constants¶

const HYDRATE_ARRAYS = 1;
const HYDRATE_OBJECTS = 2;
const HYDRATE_RECORDS = 0;
const TYPE_RESULT_FULL = 0;
const TYPE_RESULT_PARTIAL = 1;

Properties¶

/**
 * @var mixed|null
 */
protected $activeRow;

/**
 * @var CacheInterface|null
 */
protected $cache;

/**
 * @var int
 */
protected $count = ;

/**
 * @var array
 */
protected $errorMessages;

/**
 * @var int
 */
protected $hydrateMode = ;

/**
 * @var bool
 */
protected $isFresh = true;

/**
 * @var int
 */
protected $pointer = ;

/**
 * @var mixed|null
 */
protected $row;

/**
 * @var array|null
 */
protected $rows;

/**
 * Phalcon\Db\ResultInterface or false for empty resultset
 *
 * @var ResultInterface|bool
 */
protected $result;

Methods¶

public function __construct( mixed $result, mixed $cache = null );

Phalcon\Mvc\Model\Resultset constructor

final public function count(): int;

Counts how many rows are in the resultset

public function delete( Closure $conditionCallback = null ): bool;

Deletes every record in the resultset

public function filter( callable $filter ): ModelInterface[];

Filters a resultset returning only those the developer requires

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);

public function getCache(): CacheInterface | null;

Returns the associated cache for the resultset

public function getFirst(): mixed | null;

Get first row in the resultset

$model = new Robots();
$manager = $model->getModelsManager();

// \Robots
$manager->createQuery('SELECTFROM Robots')
        ->execute()
        ->getFirst();

// \Phalcon\Mvc\Model\Row
$manager->createQuery('SELECT r.id FROM Robots AS r')
        ->execute()
        ->getFirst();

// NULL
$manager->createQuery('SELECT r.id FROM Robots AS r WHERE r.name = "NON-EXISTENT"')
        ->execute()
        ->getFirst();

public function getHydrateMode(): int;

Returns the current hydration mode

public function getLast(): ModelInterface | null;

Get last row in the resultset

public function getMessages(): MessageInterface[];

Returns the error messages produced by a batch operation

public function getType(): int;

Returns the internal type of data retrieval that the resultset is using

public function isFresh(): bool;

Tell if the resultset if fresh or an old one cached

public function jsonSerialize(): array;

Returns serialised model objects as array for json_encode. Calls jsonSerialize on each object if present

$robots = Robots::find();

echo json_encode($robots);

public function key(): int | null;

Gets pointer number of active row in the resultset

public function next(): void;

Moves cursor to next row in the resultset

public function offsetExists( mixed $index ): bool;

Checks whether offset exists in the resultset

public function offsetGet( mixed $index ): mixed;

Gets row in a specific position of the resultset

public function offsetSet( mixed $offset, mixed $value ): void;

Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;

Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

final public function rewind(): void;

Rewinds resultset to its beginning

final public function seek( mixed $position ): void;

Changes the internal pointer to a specific position in the resultset. Set the new position if required, and then set this->row

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Sets the hydration mode in the resultset

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Set if the resultset is fresh or an old one cached

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Updates every record in the resultset

public function valid(): bool;

Check whether internal resource has rows to fetch

Mvc\Model\Resultset\Complex¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Resultset
Uses
- Phalcon\Db\ResultInterface
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Mvc\Model
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\Resultset
- Phalcon\Mvc\Model\ResultsetInterface
- Phalcon\Mvc\Model\Row
- Phalcon\Storage\Serializer\SerializerInterface
- stdClass
Extends

Resultset
Implements
- ResultsetInterface

Phalcon\Mvc\Model\Resultset\Complex

Complex resultsets may include complete objects and scalar values. This class builds every complex row as it is required

Properties¶

/**
 * @var array
 */
protected $columnTypes;

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

Methods¶

public function __construct( mixed $columnTypes, ResultInterface $result = null, mixed $cache = null );

Phalcon\Mvc\Model\Resultset\Complex constructor

public function __serialize(): array;

public function __unserialize( array $data ): void;

final public function current(): mixed;

Returns current row in the resultset

public function serialize(): string;

Serializing a resultset will dump all related rows into a big array, serialize it and return the resulting string

public function toArray(): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.

public function unserialize( mixed $data ): void;

Unserializing a resultset will allow to only works on the rows present in the saved state

Mvc\Model\Resultset\Simple¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Resultset
Uses
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Mvc\Model
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Exception
- Phalcon\Mvc\Model\Resultset
- Phalcon\Mvc\Model\Row
- Phalcon\Storage\Serializer\SerializerInterface
Extends

Resultset
Implements

Phalcon\Mvc\Model\Resultset\Simple

Simple resultsets only contains a complete objects This class builds every complete object as it is required

Properties¶

/**
 * @var array|string
 */
protected $columnMap;

/**
 * @var ModelInterface|Row
 */
protected $model;

/**
 * @var bool
 */
protected $keepSnapshots = false;

Methods¶

public function __construct( mixed $columnMap, mixed $model, mixed $result, mixed $cache = null, bool $keepSnapshots = bool );

Phalcon\Mvc\Model\Resultset\Simple constructor

public function __serialize(): array;

public function __unserialize( array $data ): void;

final public function current(): ModelInterface | null;

Returns current row in the resultset

public function serialize(): string;

Serializing a resultset will dump all related rows into a big array

public function toArray( bool $renameColumns = bool ): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does. Export the resultset to an array couldn't be faster with a large number of records

public function unserialize( mixed $data ): void;

Unserializing a resultset will allow to only works on the rows present in the saved state

Mvc\Model\ResultsetInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Closure
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\ModelInterface
Extends
Implements

Phalcon\Mvc\Model\ResultsetInterface

Interface for Phalcon\Mvc\Model\Resultset

Methods¶

public function delete( Closure $conditionCallback = null ): bool;

Deletes every record in the resultset

public function filter( callable $filter ): ModelInterface[];

Filters a resultset returning only those the developer requires

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);

public function getCache(): mixed | null;

Returns the associated cache for the resultset

public function getFirst(): mixed | null;

Get first row in the resultset

public function getHydrateMode(): int;

Returns the current hydration mode

public function getLast(): ModelInterface | null;

Get last row in the resultset

public function getMessages(): MessageInterface[];

Returns the error messages produced by a batch operation

public function getType(): int;

Returns the internal type of data retrieval that the resultset is using

public function isFresh(): bool;

Tell if the resultset if fresh or an old one cached

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Sets the hydration mode in the resultset

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Set if the resultset is fresh or an old one cached

public function toArray(): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Updates every record in the resultset

Mvc\Model\Row¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- ArrayAccess
- JsonSerializable
- Phalcon\Mvc\EntityInterface
- Phalcon\Mvc\ModelInterface
Extends

\stdClass
Implements
- ArrayAccess
- EntityInterface
- JsonSerializable
- ResultInterface

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].

Methods¶

public function jsonSerialize(): array;

Serializes the object for json_encode

public function offsetExists( mixed $index ): bool;

Checks whether offset exists in the row

public function offsetGet( mixed $index ): mixed;

Gets a record in a specific position of the row

public function offsetSet( mixed $offset, mixed $value ): void;

Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;

Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function readAttribute( string $attribute );

Reads an attribute value by its name

echo $robot->readAttribute("name");

public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Set the current object's state

public function toArray(): array;

Returns the instance as an array representation

public function writeAttribute( string $attribute, mixed $value ): void;

Writes an attribute value by its name

$robot->writeAttribute("name", "Rosey");

Mvc\Model\Transaction¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
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
Extends
Implements
- TransactionInterface

Phalcon\Mvc\Model\Transaction

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. Phalcon\Transaction is intended to be used with Phalcon_Model_Base. Phalcon Transactions should be created using Phalcon\Transaction\Manager.

use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;

try {
    $manager = new Manager();

    $transaction = $manager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

    $robot->name       = "WALL·E";
    $robot->created_at = date("Y-m-d");

    if ($robot->save() === false) {
        $transaction->rollback("Can't save robot");
    }

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

    if ($robotPart->save() === false) {
        $transaction->rollback("Can't save robot part");
    }

    $transaction->commit();
} catch(Failed $e) {
    echo "Failed, reason: ", $e->getMessage();
}

Properties¶

/**
 * @var bool
 */
protected $activeTransaction = false;

/**
 * @var AdapterInterface
 */
protected $connection;

/**
 * @var bool
 */
protected $isNewTransaction = true;

/**
 * @var ManagerInterface|null
 */
protected $manager;

/**
 * @var array
 */
protected $messages;

/**
 * @var ModelInterface|null
 */
protected $rollbackRecord;

/**
 * @var bool
 */
protected $rollbackOnAbort = false;

/**
 * @var bool
 */
protected $rollbackThrowException = false;

Methods¶

public function __construct( DiInterface $container, bool $autoBegin = bool, string $service = string );

Phalcon\Mvc\Model\Transaction constructor

public function begin(): bool;

Starts the transaction

public function commit(): bool;

Commits the transaction

public function getConnection(): AdapterInterface;

Returns the connection related to transaction

public function getMessages(): array;

Returns validations messages from last save try

public function isManaged(): bool;

Checks whether transaction is managed by a transaction manager

public function isValid(): bool;

Checks whether internal connection is under an active transaction

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Rollbacks the transaction

public function setIsNewTransaction( bool $isNew ): void;

Sets if is a reused transaction or new once

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Sets flag to rollback on abort the HTTP connection

public function setRollbackedRecord( ModelInterface $record ): void;

Sets object which generates rollback action

public function setTransactionManager( ManagerInterface $manager ): void;

Sets transaction manager related to the transaction

public function throwRollbackException( bool $status ): TransactionInterface;

Enables throwing exception

Mvc\Model\Transaction\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Transaction
Uses
Extends

\Phalcon\Mvc\Model\Exception
Implements

Phalcon\Mvc\Model\Transaction\Exception

Exceptions thrown in Phalcon\Mvc\Model\Transaction will use this class

Mvc\Model\Transaction\Failed¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Transaction
Uses
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\ModelInterface
Extends

Exception
Implements

Phalcon\Mvc\Model\Transaction\Failed

This class will be thrown to exit a try/catch block for isolated transactions

Properties¶

/**
 * @var ModelInterface|null
 */
protected $record;

Methods¶

public function __construct( string $message, ModelInterface $record = null );

Phalcon\Mvc\Model\Transaction\Failed constructor

public function getRecord(): ModelInterface;

Returns validation record messages which stop the transaction

public function getRecordMessages(): MessageInterface[];

Returns validation record messages which stop the transaction

Mvc\Model\Transaction\Manager¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Transaction
Uses
- Phalcon\Di\Di
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Mvc\Model\Transaction
- Phalcon\Mvc\Model\TransactionInterface
Extends
Implements
- InjectionAwareInterface
- ManagerInterface

Phalcon\Mvc\Model\Transaction\Manager

A transaction acts on a single database connection. If you have multiple class-specific databases, the transaction will not protect interaction among them.

This class manages the objects that compose a transaction. A transaction produces a unique connection that is passed to every object part of the transaction.

use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;

try {
   $transactionManager = new Manager();

   $transaction = $transactionManager->get();

   $robot = new Robots();

   $robot->setTransaction($transaction);

   $robot->name       = "WALL·E";
   $robot->created_at = date("Y-m-d");

   if ($robot->save() === false) {
       $transaction->rollback("Can't save robot");
   }

   $robotPart = new RobotParts();

   $robotPart->setTransaction($transaction);

   $robotPart->type = "head";

   if ($robotPart->save() === false) {
       $transaction->rollback("Can't save robot part");
   }

   $transaction->commit();
} catch (Failed $e) {
   echo "Failed, reason: ", $e->getMessage();
}

Properties¶

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var bool
 */
protected $initialized = false;

/**
 * @var int
 */
protected $number = ;

/**
 * @var bool
 */
protected $rollbackPendent = true;

/**
 * @var string
 */
protected $service = db;

/**
 * @var array
 */
protected $transactions;

Methods¶

public function __construct( DiInterface $container = null );

Phalcon\Mvc\Model\Transaction\Manager constructor

public function collectTransactions(): void;

Remove all the transactions from the manager

public function commit();

Commits active transactions within the manager

public function get( bool $autoBegin = bool ): TransactionInterface;

Returns a new \Phalcon\Mvc\Model\Transaction or an already created once This method registers a shutdown function to rollback active connections

public function getDI(): DiInterface;

Returns the dependency injection container

public function getDbService(): string;

Returns the database service used to isolate the transaction

public function getOrCreateTransaction( bool $autoBegin = bool ): TransactionInterface;

Create/Returns a new transaction or an existing one

public function getRollbackPendent(): bool;

Check if the transaction manager is registering a shutdown function to clean up pendent transactions

public function has(): bool;

Checks whether the manager has an active transaction

public function notifyCommit( TransactionInterface $transaction ): void;

Notifies the manager about a committed transaction

public function notifyRollback( TransactionInterface $transaction ): void;

Notifies the manager about a rollbacked transaction

public function rollback( bool $collect = bool ): void;

Rollbacks active transactions within the manager Collect will remove the transaction from the manager

public function rollbackPendent(): void;

Rollbacks active transactions within the manager

public function setDI( DiInterface $container ): void;

Sets the dependency injection container

public function setDbService( string $service ): ManagerInterface;

Sets the database service used to run the isolated transactions

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Set if the transaction manager must register a shutdown function to clean up pendent transactions

protected function collectTransaction( TransactionInterface $transaction ): void;

Removes transactions from the TransactionManager

Mvc\Model\Transaction\ManagerInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model\Transaction
Uses
- Phalcon\Mvc\Model\TransactionInterface
Extends
Implements

Phalcon\Mvc\Model\Transaction\ManagerInterface

Interface for Phalcon\Mvc\Model\Transaction\Manager

Methods¶

public function collectTransactions(): void;

Remove all the transactions from the manager

public function commit();

Commits active transactions within the manager

public function get( bool $autoBegin = bool ): TransactionInterface;

Returns a new \Phalcon\Mvc\Model\Transaction or an already created once

public function getDbService(): string;

Returns the database service used to isolate the transaction

public function getRollbackPendent(): bool;

Check if the transaction manager is registering a shutdown function to clean up pendent transactions

public function has(): bool;

Checks whether manager has an active transaction

public function notifyCommit( TransactionInterface $transaction ): void;

Notifies the manager about a committed transaction

public function notifyRollback( TransactionInterface $transaction ): void;

Notifies the manager about a rollbacked transaction

public function rollback( bool $collect = bool ): void;

Rollbacks active transactions within the manager Collect will remove transaction from the manager

public function rollbackPendent(): void;

Rollbacks active transactions within the manager

public function setDbService( string $service ): ManagerInterface;

Sets the database service used to run the isolated transactions

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Set if the transaction manager must register a shutdown function to clean up pendent transactions

Mvc\Model\TransactionInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Mvc\ModelInterface
- Phalcon\Mvc\Model\Transaction\ManagerInterface
Extends
Implements

Phalcon\Mvc\Model\TransactionInterface

Interface for Phalcon\Mvc\Model\Transaction

Methods¶

public function begin(): bool;

Starts the transaction

public function commit(): bool;

Commits the transaction

public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;

Returns connection related to transaction

public function getMessages(): array;

Returns validations messages from last save try

public function isManaged(): bool;

Checks whether transaction is managed by a transaction manager

public function isValid(): bool;

Checks whether internal connection is under an active transaction

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Rollbacks the transaction

public function setIsNewTransaction( bool $isNew ): void;

Sets if is a reused transaction or new once

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Sets flag to rollback on abort the HTTP connection

public function setRollbackedRecord( ModelInterface $record ): void;

Sets object which generates rollback action

public function setTransactionManager( ManagerInterface $manager ): void;

Sets transaction manager related to the transaction

public function throwRollbackException( bool $status ): TransactionInterface;

Enables throwing exception

Mvc\Model\ValidationFailed¶

Source on GitHub

Namespace
- Phalcon\Mvc\Model
Uses
- Phalcon\Messages\Message
- Phalcon\Mvc\ModelInterface
Extends

Exception
Implements

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

Properties¶

/**
 * @var array
 */
protected $messages;

/**
 * @var ModelInterface
 */
protected $model;

Methods¶

public function __construct( ModelInterface $model, array $validationMessages );

Phalcon\Mvc\Model\ValidationFailed constructor

public function getMessages(): Message[];

Returns the complete group of messages produced in the validation

public function getModel(): ModelInterface;

Returns the model that generated the messages

Mvc\ModelInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Db\Adapter\AdapterInterface
- Phalcon\Di\DiInterface
- Phalcon\Messages\MessageInterface
- Phalcon\Mvc\Model\CriteriaInterface
- Phalcon\Mvc\Model\MetaDataInterface
- Phalcon\Mvc\Model\Resultset
- Phalcon\Mvc\Model\ResultsetInterface
- Phalcon\Mvc\Model\TransactionInterface
Extends
Implements

Phalcon\Mvc\ModelInterface

Interface for Phalcon\Mvc\Model

Methods¶

public function appendMessage( MessageInterface $message ): ModelInterface;

Appends a customized message on the validation process

public function assign( array $data, mixed $whiteList = null, mixed $dataColumnMap = null ): ModelInterface;

Assigns values to a model from an array

public static function average( array $parameters = [] ): double | ResultsetInterface;

Allows to calculate the average value on a column matching the specified conditions

public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;

Assigns values to a model from an array returning a new model

public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = bool ): ModelInterface;

Assigns values to a model from an array returning a new model

public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );

Returns an hydrated result based on the data and the column map

public static function count( mixed $parameters = null ): int | ResultsetInterface;

Allows to count how many records match the specified conditions

Returns an integer for simple queries or a ResultsetInterface instance for when the GROUP condition is used. The results will contain the count of each group.

public function create(): bool;

Inserts a model instance. If the instance already exists in the persistence it will throw an exception. Returning true on success or false otherwise.

public function delete(): bool;

Deletes a model instance. Returning true on success or false otherwise.

public static function find( mixed $parameters = null );

Allows to query a set of records that match the specified conditions

public static function findFirst( mixed $parameters = null ): mixed | null;

Allows to query the first record that match the specified conditions

public function fireEvent( string $eventName ): bool;

Fires an event, implicitly calls behaviors and listeners in the events manager are notified

public function fireEventCancel( string $eventName ): bool;

Fires an event, implicitly calls behaviors and listeners in the events manager are notified. This method stops if one of the callbacks/listeners returns bool false

public function getDirtyState(): int;

Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not

public function getMessages(): MessageInterface[];

Returns array of validation messages

public function getModelsMetaData(): MetaDataInterface;

Returns the models meta-data service related to the entity instance.

public function getOperationMade(): int;

Returns the type of the latest operation performed by the ORM Returns one of the OP_* class constants

public function getReadConnection(): AdapterInterface;

Gets internal database connection

public function getReadConnectionService(): string;

Returns DependencyInjection connection service used to read data

public function getRelated( string $alias, mixed $arguments = null );

Returns related records based on defined relations

public function getSchema(): string | null;

Returns schema name where table mapped is located

public function getSource(): string;

Returns table name mapped in the model

public function getWriteConnection(): AdapterInterface;

Gets internal database connection

public function getWriteConnectionService(): string;

Returns DependencyInjection connection service used to write data

public static function maximum( mixed $parameters = null ): mixed;

Allows to get the maximum value of a column that match the specified conditions

public static function minimum( mixed $parameters = null ): mixed;

Allows to get the minimum value of a column that match the specified conditions

public static function query( DiInterface $container = null ): CriteriaInterface;

Create a criteria for a specific model

public function refresh(): ModelInterface;

Refreshes the model attributes re-querying the record from the database

public function save(): bool;

Inserts or updates a model instance. Returning true on success or false otherwise.

public function setConnectionService( string $connectionService ): void;

Sets both read/write connection services

public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Sets the dirty state of the object using one of the DIRTY_STATE_* constants

public function setReadConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service used to read data

public function setSnapshotData( array $data, mixed $columnMap = null ): void;

Sets the record's snapshot data. This method is used internally to set snapshot data when the model was set up to keep snapshot data

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Sets a transaction related to the Model instance

public function setWriteConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service used to write data

public function skipOperation( bool $skip ): void;

Skips the current operation forcing a success state

public static function sum( mixed $parameters = null ): double | ResultsetInterface;

Allows to calculate a sum on a column that match the specified conditions

public function update(): bool;

Updates a model instance. If the instance doesn't exist in the persistence it will throw an exception. Returning true on success or false otherwise.

public function validationHasFailed(): bool;

Check whether validation process has generated any messages

Mvc\ModuleDefinitionInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Di\DiInterface
Extends
Implements

Phalcon\Mvc\ModuleDefinitionInterface

This interface must be implemented by class module definitions

Methods¶

public function registerAutoloaders( DiInterface $container = null );

Registers an autoloader related to the module

public function registerServices( DiInterface $container );

Registers services related to the module

Mvc\Router¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Di\AbstractInjectionAware
- Phalcon\Di\DiInterface
- Phalcon\Events\EventsAwareInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Http\RequestInterface
- Phalcon\Mvc\Router\Exception
- Phalcon\Mvc\Router\GroupInterface
- Phalcon\Mvc\Router\Route
- Phalcon\Mvc\Router\RouteInterface
Extends

AbstractInjectionAware
Implements
- EventsAwareInterface
- RouterInterface

Phalcon\Mvc\Router

Phalcon\Mvc\Router is the standard framework router. Routing is the process of taking a URI endpoint (that part of the URI which comes after the base URL) and decomposing it into parameters to determine which module, controller, and action of that controller should receive the request

use Phalcon\Mvc\Router;

$router = new Router();

$router->add(
    "/documentation/{chapter}/{name}\.{type:[a-z]+}",
    [
        "controller" => "documentation",
        "action"     => "show",
    ]
);

$router->handle(
    "/documentation/1/examples.html"
);

echo $router->getControllerName();

Constants¶

const POSITION_FIRST = 0;
const POSITION_LAST = 1;

Properties¶

/**
 * @var string
 */
protected $action = ;

/**
 * @var string
 */
protected $controller = ;

/**
 * @var string
 */
protected $defaultAction = ;

/**
 * @var string
 */
protected $defaultController = ;

/**
 * @var string
 */
protected $defaultModule = ;

/**
 * @var string
 */
protected $defaultNamespace = ;

/**
 * @var array
 */
protected $defaultParams;

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

/**
 * @var array
 */
protected $keyRouteNames;

/**
 * @var array
 */
protected $keyRouteIds;

/**
 * @var RouteInterface|null
 */
protected $matchedRoute;

/**
 * @var array
 */
protected $matches;

/**
 * @var string
 */
protected $module = ;

/**
 * @var string
 */
protected $namespaceName = ;

/**
 * @var array|string|null
 */
protected $notFoundPaths;

/**
 * @var array
 */
protected $params;

/**
 * @var bool
 */
protected $removeExtraSlashes = false;

/**
 * @var array
 */
protected $routes;

/**
 * @var bool
 */
protected $wasMatched = false;

Methods¶

public function __construct( bool $defaultRoutes = bool );

Phalcon\Mvc\Router constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router without any HTTP constraint

use Phalcon\Mvc\Router;

$router->add("/about", "About::index");

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"]
);

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"],
    Router::POSITION_FIRST
);

public function addConnect( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, int $position = static-constant-access ): RouterInterface;

Attach Route object to the routes stack.

use Phalcon\Mvc\Router;
use Phalcon\Mvc\Router\Route;

class CustomRoute extends Route {
     // ...
}

$router = new Router();

$router->attach(
    new CustomRoute("/about", "About::index", ["GET", "HEAD"]),
    Router::POSITION_FIRST
);

public function clear(): void;

Removes all the pre-defined routes

public function getActionName(): string;

Returns the processed action name

public function getControllerName(): string;

Returns the processed controller name

public function getDefaults(): array;

Returns an array of default parameters

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getKeyRouteIds(): array;

public function getKeyRouteNames(): array;

public function getMatchedRoute(): RouteInterface | null;

Returns the route that matches the handled URI

public function getMatches(): array;

Returns the sub expressions in the regular expression matched

public function getModuleName(): string;

Returns the processed module name

public function getNamespaceName(): string;

Returns the processed namespace name

public function getParams(): array;

Returns the processed parameters

public function getRouteById( mixed $id ): RouteInterface | bool;

Returns a route object by its id

public function getRouteByName( string $name ): RouteInterface | bool;

Returns a route object by its name

public function getRoutes(): RouteInterface[];

Returns all the routes defined in the router

public function handle( string $uri ): void;

Handles routing information received from the rewrite engine

// Passing a URL
$router->handle("/posts/edit/1");

public function isExactControllerName(): bool;

Returns whether controller name should not be mangled

public function mount( GroupInterface $group ): RouterInterface;

Mounts a group of routes in the router

public function notFound( mixed $paths ): RouterInterface;

Set a group of paths to be returned when none of the defined routes are matched

public function removeExtraSlashes( bool $remove ): RouterInterface;

Set whether router must remove the extra slashes in the handled routes

public function setDefaultAction( string $actionName ): RouterInterface;

Sets the default action name

public function setDefaultController( string $controllerName ): RouterInterface;

Sets the default controller name

public function setDefaultModule( string $moduleName ): RouterInterface;

Sets the name of the default module

public function setDefaultNamespace( string $namespaceName ): RouterInterface;

Sets the name of the default namespace

@parma string namespaceName

public function setDefaults( array $defaults ): RouterInterface;

Sets an array of default paths. If a route is missing a path the router will use the defined here. This method must not be used to set a 404 route

$router->setDefaults(
    [
        "module" => "common",
        "action" => "index",
    ]
);

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setKeyRouteIds( array $routeIds ): Router;

public function setKeyRouteNames( array $routeNames ): Router;

public function wasMatched(): bool;

Checks if the router matches any of the defined routes

Mvc\Router\Annotations¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
- Phalcon\Annotations\Annotation
- Phalcon\Di\DiInterface
- Phalcon\Mvc\Router
Extends

Router
Implements

Phalcon\Mvc\Router\Annotations

A router that reads routes annotations from classes/resources

use Phalcon\Mvc\Router\Annotations;

$di->setShared(
    "router",
    function() {
        // Use the annotations router
        $router = new Annotations(false);

        // This will do the same as above but only if the handled uri starts with /robots
        $router->addResource("Robots", "/robots");

        return $router;
    }
);

Properties¶

/**
 * @var string
 */
protected $actionSuffix = Action;

/**
 * @var callable|string|null
 */
protected $actionPreformatCallback;

/**
 * @var string
 */
protected $controllerSuffix = Controller;

/**
 * @var array
 */
protected $handlers;

/**
 * @var string
 */
protected $routePrefix = ;

Methods¶

public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations The class is located in a module

public function addResource( string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations

public function getActionPreformatCallback();

public function getResources(): array;

Return the registered resources

public function handle( string $uri ): void;

Produce the routing parameters from the rewrite information

public function processActionAnnotation( string $module, string $namespaceName, string $controller, string $action, Annotation $annotation ): void;

Checks for annotations in the public methods of the controller

public function processControllerAnnotation( string $handler, Annotation $annotation );

Checks for annotations in the controller docblock

public function setActionPreformatCallback( mixed $callback = null );

Sets the action preformat callback $action here already without suffix 'Action'

// Array as callback
$annotationRouter->setActionPreformatCallback(
     [
         new Uncamelize(),
         '__invoke'
     ]
 );

// Function as callback
$annotationRouter->setActionPreformatCallback(
    function ($action) {
        return $action;
    }
);

// String as callback
$annotationRouter->setActionPreformatCallback('strtolower');

// If empty method constructor called [null], sets uncamelize with - delimiter
$annotationRouter->setActionPreformatCallback();

public function setActionSuffix( string $actionSuffix );

Changes the action method suffix

public function setControllerSuffix( string $controllerSuffix );

Changes the controller class suffix

Mvc\Router\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
Extends

\Exception
Implements

Phalcon\Mvc\Router\Exception

Exceptions thrown in Phalcon\Mvc\Router will use this class

Mvc\Router\Group¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
Extends
Implements
- GroupInterface

Phalcon\Mvc\Router\Group

Helper class to create a group of routes with common attributes

$router = new \Phalcon\Mvc\Router();

//Create a group with a common module and controller
$blog = new Group(
    [
        "module"     => "blog",
        "controller" => "index",
    ]
);

//All the routes start with /blog
$blog->setPrefix("/blog");

//Add a route to the group
$blog->add(
    "/save",
    [
        "action" => "save",
    ]
);

//Add another route to the group
$blog->add(
    "/edit/{id}",
    [
        "action" => "edit",
    ]
);

//This route maps to a controller different than the default
$blog->add(
    "/blog",
    [
        "controller" => "about",
        "action"     => "index",
    ]
);

//Add the group to the router
$router->mount($blog);

Properties¶

/**
 * @var callable|null
 */
protected $beforeMatch;

/**
 * @var string|null
 */
protected $hostname;

/**
 * @var array|string|null
 */
protected $paths;

/**
 * @var string|null
 */
protected $prefix;

/**
 * @var array
 */
protected $routes;

Methods¶

public function __construct( mixed $paths = null );

Phalcon\Mvc\Router\Group constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Adds a route to the router on any HTTP method

$router->add("/about", "About::index");

public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function beforeMatch( callable $beforeMatch ): GroupInterface;

Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched

public function clear(): void;

Removes all the pre-defined routes

public function getBeforeMatch(): callable;

Returns the 'before match' callback if any

public function getHostname(): string;

Returns the hostname restriction

public function getPaths(): array | string;

Returns the common paths defined for this group

public function getPrefix(): string;

Returns the common prefix for all the routes

public function getRoutes(): RouteInterface[];

Returns the routes added to the group

public function setHostname( string $hostname ): GroupInterface;

Set a hostname restriction for all the routes in the group

public function setPaths( mixed $paths ): GroupInterface;

Set common paths for all the routes in the group

public function setPrefix( string $prefix ): GroupInterface;

Set a common uri prefix for all the routes in this group

protected function addRoute( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Adds a route applying the common attributes

Mvc\Router\GroupInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
Extends
Implements

Phalcon\Mvc\Router\GroupInterface

$router = new \Phalcon\Mvc\Router();

// Create a group with a common module and controller
$blog = new Group(
    [
        "module"     => "blog",
        "controller" => "index",
    ]
);

// All the routes start with /blog
$blog->setPrefix("/blog");

// Add a route to the group
$blog->add(
    "/save",
    [
        "action" => "save",
    ]
);

// Add another route to the group
$blog->add(
    "/edit/{id}",
    [
        "action" => "edit",
    ]
);

// This route maps to a controller different than the default
$blog->add(
    "/blog",
    [
        "controller" => "about",
        "action"     => "index",
    ]
);

// Add the group to the router
$router->mount($blog);

Methods¶

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Adds a route to the router on any HTTP method

router->add("/about", "About::index");

public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function beforeMatch( callable $beforeMatch ): GroupInterface;

Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched

public function clear(): void;

Removes all the pre-defined routes

public function getBeforeMatch(): callable;

Returns the 'before match' callback if any

public function getHostname(): string;

Returns the hostname restriction

public function getPaths(): array | string;

Returns the common paths defined for this group

public function getPrefix(): string;

Returns the common prefix for all the routes

public function getRoutes(): RouteInterface[];

Returns the routes added to the group

public function setHostname( string $hostname ): GroupInterface;

Set a hostname restriction for all the routes in the group

public function setPaths( mixed $paths ): GroupInterface;

Set common paths for all the routes in the group

public function setPrefix( string $prefix ): GroupInterface;

Set a common uri prefix for all the routes in this group

Mvc\Router\Route¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
Extends
Implements
- RouteInterface

Phalcon\Mvc\Router\Route

This class represents every route added to the router

Properties¶

/**
 * @var callable|null
 */
protected $beforeMatch;

/**
 * @var string|null
 */
protected $compiledPattern;

/**
 * @var array
 */
protected $converters;

/**
 * @var GroupInterface|null
 */
protected $group;

/**
 * @var string|null
 */
protected $hostname;

/**
 * @var string
 */
protected $id = ;

/**
 * @var array|string
 */
protected $methods;

/**
 * @var callable|null
 */
protected $match;

/**
 * @var string|null
 */
protected $name;

/**
 * @var array
 */
protected $paths;

/**
 * @var string
 */
protected $pattern;

/**
 * @var int
 */
protected static $uniqueId = ;

Methods¶

public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );

Phalcon\Mvc\Router\Route constructor

public function beforeMatch( callable $callback ): RouteInterface;

Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched

$router->add(
    "/login",
    [
        "module"     => "admin",
        "controller" => "session",
    ]
)->beforeMatch(
    function ($uri, $route) {
        // Check if the request was made with Ajax
        if ($_SERVER["HTTP_X_REQUESTED_WITH"] === "xmlhttprequest") {
            return false;
        }

        return true;
    }
);

public function compilePattern( string $pattern ): string;

Replaces placeholders from pattern returning a valid PCRE regular expression

public function convert( string $name, mixed $converter ): RouteInterface;

public function extractNamedParams( string $pattern ): array | bool;

Extracts parameters from a string

public function getBeforeMatch(): callable;

Returns the 'before match' callback if any

public function getCompiledPattern(): string;

Returns the route's compiled pattern

public function getConverters(): array;

Returns the router converter

public function getGroup(): GroupInterface | null;

Returns the group associated with the route

public function getHostname(): string | null;

Returns the hostname restriction if any

public function getHttpMethods(): array | string;

Returns the HTTP methods that constraint matching the route

public function getId(): string;

public function getMatch(): callable;

Returns the 'match' callback if any

public function getName(): string | null;

Returns the route's name

public function getPaths(): array;

Returns the paths

public function getPattern(): string;

Returns the route's pattern

public function getReversedPaths(): array;

Returns the paths using positions as keys and names as values

public function getRouteId(): string;

Returns the route's id

public static function getRoutePaths( mixed $paths = null ): array;

Returns routePaths

public function match( mixed $callback ): RouteInterface;

Allows to set a callback to handle the request directly in the route

$router->add(
    "/help",
    []
)->match(
    function () {
        return $this->getResponse()->redirect("https://support.google.com/", true);
    }
);

public function reConfigure( string $pattern, mixed $paths = null ): void;

Reconfigure the route adding a new pattern and a set of paths

public static function reset(): void;

Resets the internal route id generator

public function setGroup( GroupInterface $group ): RouteInterface;

Sets the group associated with the route

public function setHostname( string $hostname ): RouteInterface;

Sets a hostname restriction to the route

$route->setHostname("localhost");

public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Sets a set of HTTP methods that constraint the matching of the route (alias of via)

$route->setHttpMethods("GET");

$route->setHttpMethods(
    [
        "GET",
        "POST",
    ]
);

public function setName( string $name ): RouteInterface;

Sets the route's name

$router->add(
    "/about",
    [
        "controller" => "about",
    ]
)->setName("about");

public function via( mixed $httpMethods ): RouteInterface;

Set one or more HTTP methods that constraint the matching of the route

$route->via("GET");

$route->via(
    [
        "GET",
        "POST",
    ]
);

Mvc\Router\RouteInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Router
Uses
Extends
Implements

Phalcon\Mvc\Router\RouteInterface

Interface for Phalcon\Mvc\Router\Route

Methods¶

public function compilePattern( string $pattern ): string;

Replaces placeholders from pattern returning a valid PCRE regular expression

public function convert( string $name, mixed $converter ): RouteInterface;

Adds a converter to perform an additional transformation for certain parameter.

public function getCompiledPattern(): string;

Returns the route's pattern

public function getHostname(): string | null;

Returns the hostname restriction if any

public function getHttpMethods(): string | array;

Returns the HTTP methods that constraint matching the route

public function getName(): string | null;

Returns the route's name

public function getPaths(): array;

Returns the paths

public function getPattern(): string;

Returns the route's pattern

public function getReversedPaths(): array;

Returns the paths using positions as keys and names as values

public function getRouteId(): string;

Returns the route's id

public function reConfigure( string $pattern, mixed $paths = null ): void;

Reconfigure the route adding a new pattern and a set of paths

public static function reset(): void;

Resets the internal route id generator

public function setHostname( string $hostname ): RouteInterface;

Sets a hostname restriction to the route

public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Sets a set of HTTP methods that constraint the matching of the route

public function setName( string $name ): RouteInterface;

Sets the route's name

public function via( mixed $httpMethods ): RouteInterface;

Set one or more HTTP methods that constraint the matching of the route

Mvc\RouterInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Mvc\Router\GroupInterface
- Phalcon\Mvc\Router\RouteInterface
Extends
Implements

Interface for Phalcon\Mvc\Router

Methods¶

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router on any HTTP method

public function addConnect( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, int $position = static-constant-access ): RouterInterface;

Attach Route object to the routes stack.

public function clear(): void;

Removes all the defined routes

public function getActionName(): string;

Returns processed action name

public function getControllerName(): string;

Returns processed controller name

public function getMatchedRoute(): RouteInterface | null;

Returns the route that matches the handled URI

public function getMatches(): array;

Return the sub expressions in the regular expression matched

public function getModuleName(): string;

Returns processed module name

public function getNamespaceName(): string;

Returns processed namespace name

public function getParams(): array;

Returns processed extra params

public function getRouteById( mixed $id ): RouteInterface | bool;

Returns a route object by its id

public function getRouteByName( string $name ): RouteInterface | bool;

Returns a route object by its name

public function getRoutes(): RouteInterface[];

Return all the routes defined in the router

public function handle( string $uri ): void;

Handles routing information received from the rewrite engine

public function mount( GroupInterface $group ): RouterInterface;

Mounts a group of routes in the router

public function setDefaultAction( string $actionName ): RouterInterface;

Sets the default action name

public function setDefaultController( string $controllerName ): RouterInterface;

Sets the default controller name

public function setDefaultModule( string $moduleName ): RouterInterface;

Sets the name of the default module

public function setDefaults( array $defaults ): RouterInterface;

Sets an array of default paths

public function wasMatched(): bool;

Check if the router matches any of the defined routes

Mvc\Url¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Di\AbstractInjectionAware
- Phalcon\Di\DiInterface
- Phalcon\Mvc\RouterInterface
- Phalcon\Mvc\Router\RouteInterface
- Phalcon\Mvc\Url\Exception
- Phalcon\Mvc\Url\UrlInterface
Extends

AbstractInjectionAware
Implements
- UrlInterface

This components helps in the generation of: URIs, URLs and Paths

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2012",
    ]
);

Properties¶

/**
 * @var null | string
 */
protected $baseUri;

/**
 * @var null | string
 */
protected $basePath;

/**
 * @var RouterInterface | null
 */
protected $router;

/**
 * @var null | string
 */
protected $staticBaseUri;

Methods¶

public function __construct( RouterInterface $router = null );

public function get( mixed $uri = null, mixed $args = null, bool $local = null, mixed $baseUri = null ): string;

Generates a URL

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2015",
    ]
);

// Generate a URL with GET arguments (/show/products?id=1&name=Carrots)
echo $url->get(
    "show/products",
    [
        "id"   => 1,
        "name" => "Carrots",
    ]
);

// Generate an absolute URL by setting the third parameter as false.
echo $url->get(
    "https://phalcon.io/",
    null,
    false
);

public function getBasePath(): string;

Returns the base path

public function getBaseUri(): string;

Returns the prefix for all the generated urls. By default /

public function getStatic( mixed $uri = null ): string;

Generates a URL for a static resource

// Generate a URL for a static resource
echo $url->getStatic("img/logo.png");

// Generate a URL for a static predefined route
echo $url->getStatic(
    [
        "for" => "logo-cdn",
    ]
);

public function getStaticBaseUri(): string;

Returns the prefix for all the generated static urls. By default /

public function path( string $path = null ): string;

Generates a local path

public function setBasePath( string $basePath ): UrlInterface;

Sets a base path for all the generated paths

$url->setBasePath("/var/www/htdocs/");

public function setBaseUri( string $baseUri ): UrlInterface;

Sets a prefix for all the URIs to be generated

$url->setBaseUri("/invo/");

$url->setBaseUri("/invo/index.php/");

public function setStaticBaseUri( string $staticBaseUri ): UrlInterface;

Sets a prefix for all static URLs generated

$url->setStaticBaseUri("/invo/");

Mvc\Url\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\Url
Uses
Extends

\Exception
Implements

Phalcon\Mvc\Url\Exception

Exceptions thrown in Phalcon\Mvc\Url will use this class

Mvc\Url\UrlInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\Url
Uses
Extends
Implements

Interface for Phalcon\Mvc\Url\UrlInterface

Methods¶

public function get( mixed $uri = null, mixed $args = null, bool $local = null ): string;

Generates a URL

public function getBasePath(): string;

Returns a base path

public function getBaseUri(): string;

Returns the prefix for all the generated urls. By default /

public function path( string $path = null ): string;

Generates a local path

public function setBasePath( string $basePath ): UrlInterface;

Sets a base paths for all the generated paths

public function setBaseUri( string $baseUri ): UrlInterface;

Sets a prefix to all the urls generated

Mvc\View¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Closure
- Phalcon\Di\DiInterface
- Phalcon\Di\Injectable
- Phalcon\Events\EventsAwareInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Mvc\View\Engine\Php
- Phalcon\Mvc\View\Exception
Extends

Injectable
Implements
- EventsAwareInterface
- ViewInterface

Phalcon\Mvc\View

Phalcon\Mvc\View is a class for working with the "view" portion of the model-view-controller pattern. That is, it exists to help keep the view script separate from the model and controller scripts. It provides a system of helpers, output filters, and variable escaping.

use Phalcon\Mvc\View;

$view = new View();

// Setting views directory
$view->setViewsDir("app/views/");

$view->start();

// Shows recent posts view (app/views/posts/recent.phtml)
$view->render("posts", "recent");
$view->finish();

// Printing views output
echo $view->getContent();

Constants¶

const LEVEL_ACTION_VIEW = 1;
const LEVEL_AFTER_TEMPLATE = 4;
const LEVEL_BEFORE_TEMPLATE = 2;
const LEVEL_LAYOUT = 3;
const LEVEL_MAIN_LAYOUT = 5;
const LEVEL_NO_RENDER = 0;

Properties¶

/**
 * @var string
 */
protected $actionName;

/**
 * @var array
 */
protected $activeRenderPaths;

/**
 * @var string
 */
protected $basePath = ;

/**
 * @var string
 */
protected $content = ;

/**
 * @var string
 */
protected $controllerName;

/**
 * @var int
 */
protected $currentRenderLevel = ;

/**
 * @var bool
 */
protected $disabled = false;

/**
 * @var array
 */
protected $disabledLevels;

/**
 * @var array|bool
 */
protected $engines = false;

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

/**
 * @var string|null
 */
protected $layout;

/**
 * @var string
 */
protected $layoutsDir = ;

/**
 * @var string
 */
protected $mainView = index;

/**
 * @var array
 */
protected $options;

/**
 * @var array
 */
protected $params;

/**
 * @var array|null
 */
protected $pickView;

/**
 * @var string
 */
protected $partialsDir = ;

/**
 * @var array
 */
protected $registeredEngines;

/**
 * @var int
 */
protected $renderLevel = 5;

/**
 * @var array
 */
protected $templatesAfter;

/**
 * @var array
 */
protected $templatesBefore;

/**
 * @var array
 */
protected $viewsDirs;

/**
 * @var array
 */
protected $viewParams;

Methods¶

public function __construct( array $options = [] );

Phalcon\Mvc\View constructor

public function __get( string $key ): mixed | null;

Magic method to retrieve a variable passed to the view

echo $this->view->products;

public function __isset( string $key ): bool;

Magic method to retrieve if a variable is set in the view

echo isset($this->view->products);

public function __set( string $key, mixed $value );

Magic method to pass variables to the views

$this->view->products = $products;

public function cleanTemplateAfter(): View;

Resets any template before layouts

public function cleanTemplateBefore(): View;

Resets any "template before" layouts

public function disable(): View;

Disables the auto-rendering process

public function disableLevel( mixed $level ): ViewInterface;

Disables a specific level of rendering

// Render all levels except ACTION level
$this->view->disableLevel(
    View::LEVEL_ACTION_VIEW
);

public function enable(): View;

Enables the auto-rendering process

public function exists( string $view ): bool;

Checks whether view exists @deprecated

public function finish(): View;

Finishes the render process by stopping the output buffering

public function getActionName(): string;

Gets the name of the action rendered

public function getActiveRenderPath(): string | array;

Returns the path (or paths) of the views that are currently rendered

public function getBasePath(): string;

Gets base path

public function getContent(): string;

Returns output from another view stage

public function getControllerName(): string;

Gets the name of the controller rendered

public function getCurrentRenderLevel(): int;

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getLayout(): string;

Returns the name of the main view

public function getLayoutsDir(): string;

Gets the current layouts sub-directory

public function getMainView(): string;

Returns the name of the main view

public function getParamsToView(): array;

Returns parameters to views

public function getPartial( string $partialPath, mixed $params = null ): string;

Renders a partial view

// Retrieve the contents of a partial
echo $this->getPartial("shared/footer");

// Retrieve the contents of a partial with arguments
echo $this->getPartial(
    "shared/footer",
    [
        "content" => $html,
    ]
);

public function getPartialsDir(): string;

Gets the current partials sub-directory

public function getRegisteredEngines(): array;

public function getRender( string $controllerName, string $actionName, array $params = [], mixed $configCallback = null ): string;

Perform the automatic rendering returning the output as a string

$template = $this->view->getRender(
    "products",
    "show",
    [
        "products" => $products,
    ]
);

public function getRenderLevel(): int;

public function getVar( string $key ): mixed | null;

Returns a parameter previously set in the view

public function getViewsDir(): string | array;

Gets views directory

public function has( string $view ): bool;

Checks whether view exists

public function isDisabled(): bool;

Whether automatic rendering is enabled

public function partial( string $partialPath, mixed $params = null );

Renders a partial view

// Show a partial inside another view
$this->partial("shared/footer");

// Show a partial inside another view with parameters
$this->partial(
    "shared/footer",
    [
        "content" => $html,
    ]
);

public function pick( mixed $renderView ): View;

Choose a different view to render instead of last-controller/last-action

use Phalcon\Mvc\Controller;

class ProductsController extends Controller
{
    public function saveAction()
    {
        // Do some save stuff...

        // Then show the list view
        $this->view->pick("products/list");
    }
}

public function processRender( string $controllerName, string $actionName, array $params = [], bool $fireEvents = bool ): bool;

Processes the view and templates; Fires events if needed

public function registerEngines( array $engines ): View;

Register templating engines

$this->view->registerEngines(
    [
        ".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
        ".volt"  => \Phalcon\Mvc\View\Engine\Volt::class,
        ".mhtml" => \MyCustomEngine::class,
    ]
);

public function render( string $controllerName, string $actionName, array $params = [] ): View | bool;

Executes render process from dispatching data

// Shows recent posts view (app/views/posts/recent.phtml)
$view->start()->render("posts", "recent")->finish();

public function reset(): View;

Resets the view component to its factory default values

public function setBasePath( string $basePath ): View;

Sets base path. Depending of your platform, always add a trailing slash or backslash

$view->setBasePath(__DIR__ . "/");

public function setContent( string $content ): View;

Externally sets the view content

$this->view->setContent("<h1>hello</h1>");

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setLayout( string $layout ): View;

Change the layout to be used instead of using the name of the latest controller name

$this->view->setLayout("main");

public function setLayoutsDir( string $layoutsDir ): View;

Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

$view->setLayoutsDir("../common/layouts/");

public function setMainView( string $viewPath ): View;

Sets default view name. Must be a file without extension in the views directory

// Renders as main view views-dir/base.phtml
$this->view->setMainView("base");

public function setParamToView( string $key, mixed $value ): View;

Adds parameters to views (alias of setVar)

$this->view->setParamToView("products", $products);

public function setPartialsDir( string $partialsDir ): View;

Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

$view->setPartialsDir("../common/partials/");

public function setRenderLevel( int $level ): ViewInterface;

Sets the render level for the view

// Render the view related to the controller only
$this->view->setRenderLevel(
    View::LEVEL_LAYOUT
);

public function setTemplateAfter( mixed $templateAfter ): View;

Sets a "template after" controller layout

public function setTemplateBefore( mixed $templateBefore ): View;

Sets a template before the controller layout

public function setVar( string $key, mixed $value ): View;

Set a single view parameter

$this->view->setVar("products", $products);

public function setVars( array $params, bool $merge = bool ): View;

Set all the render params

$this->view->setVars(
    [
        "products" => $products,
    ]
);

public function setViewsDir( mixed $viewsDir ): View;

Sets the views directory. Depending of your platform, always add a trailing slash or backslash

public function start(): View;

Starts rendering process enabling the output buffering

public function toString( string $controllerName, string $actionName, array $params = [] ): string;

Renders the view and returns it as a string

protected function engineRender( array $engines, string $viewPath, bool $silence, bool $mustClean = bool );

Checks whether view exists on registered extensions and render it

protected function getViewsDirs(): array;

Gets views directories

final protected function isAbsolutePath( string $path );

Checks if a path is absolute or not

protected function loadTemplateEngines(): array;

Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php

Mvc\View\Engine\AbstractEngine ¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine
Uses
- Phalcon\Di\DiInterface
- Phalcon\Di\Injectable
- Phalcon\Mvc\ViewBaseInterface
Extends

Injectable
Implements
- EngineInterface

All the template engine adapters must inherit this class. This provides basic interfacing between the engine and the Phalcon\Mvc\View component.

Properties¶

/**
 * @var ViewBaseInterface
 */
protected $view;

Methods¶

public function __construct( ViewBaseInterface $view, DiInterface $container = null );

Phalcon\Mvc\View\Engine constructor

public function getContent(): string;

Returns cached output on another view stage

public function getView(): ViewBaseInterface;

Returns the view component related to the adapter

public function partial( string $partialPath, mixed $params = null ): void;

Renders a partial inside another view

Mvc\View\Engine\EngineInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine
Uses
Extends
Implements

Interface for Phalcon\Mvc\View engine adapters

Methods¶

public function getContent(): string;

Returns cached output on another view stage

public function partial( string $partialPath, mixed $params = null ): void;

Renders a partial inside another view

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

TODO: Change params to array type

Mvc\View\Engine\Php¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine
Uses
Extends

AbstractEngine
Implements

Adapter to use PHP itself as templating engine

Methods¶

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

Mvc\View\Engine\Volt¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine
Uses
- Phalcon\Di\DiInterface
- Phalcon\Events\EventsAwareInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Html\Link\Link
- Phalcon\Html\Link\Serializer\Header
- Phalcon\Mvc\View\Engine\Volt\Compiler
- Phalcon\Mvc\View\Exception
Extends

AbstractEngine
Implements
- EventsAwareInterface

Designer friendly and fast template engine for PHP written in Zephir/C

Properties¶

/**
 * @var Compiler
 */
protected $compiler;

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

/**
 * @var array
 */
protected $macros;

/**
 * @var array
 */
protected $options;

Methods¶

public function callMacro( string $name, array $arguments = [] ): mixed;

Checks if a macro is defined and calls it

public function convertEncoding( string $text, string $from, string $to ): string;

Performs a string conversion

public function getCompiler(): Compiler;

Returns the Volt's compiler

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getOptions(): array;

Return Volt's options

public function isIncluded( mixed $needle, mixed $haystack ): bool;

Checks if the needle is included in the haystack

public function length( mixed $item ): int;

Length filter. If an array/object is passed a count is performed otherwise a strlen/mb_strlen

public function preload( mixed $parameters ): string;

Parses the preload element passed and sets the necessary link headers @todo find a better way to handle this

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setOptions( array $options );

Set Volt's options

public function slice( mixed $value, int $start = int, mixed $end = null );

Extracts a slice from a string/array/traversable object value

public function sort( array $value ): array;

Sorts an array

Mvc\View\Engine\Volt\Compiler¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine\Volt
Uses
- Closure
- Phalcon\Di\DiInterface
- Phalcon\Di\InjectionAwareInterface
- Phalcon\Mvc\ViewBaseInterface
Extends
Implements
- InjectionAwareInterface

This class reads and compiles Volt templates into PHP plain code

$compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();

$compiler->compile("views/partials/header.volt");

require $compiler->getCompiledTemplatePath();

Properties¶

/**
 * @var bool
 */
protected $autoescape = false;

/**
 * @var int
 */
protected $blockLevel = ;

/**
 * @var array|null
 *
 * TODO: Make array only?
 */
protected $blocks;

/**
 * @var DiInterface|null
 */
protected $container;

/**
 * @var string|null
 */
protected $compiledTemplatePath;

/**
 * @var string|null
 */
protected $currentBlock;

/**
 * @var string|null
 */
protected $currentPath;

/**
 * @var int
 */
protected $exprLevel = ;

/**
 * @var bool
 */
protected $extended = false;

/**
 * @var array
 */
protected $extensions;

/**
 * @var array|bool
 *
 * TODO: Make it always array
 */
protected $extendedBlocks;

/**
 * @var array
 */
protected $filters;

/**
 * @var int
 */
protected $foreachLevel = ;

/**
 * @var array
 */
protected $forElsePointers;

/**
 * @var array
 */
protected $functions;

/**
 * @var int
 */
protected $level = ;

/**
 * @var array
 */
protected $loopPointers;

/**
 * @var array
 */
protected $macros;

/**
 * @var array
 */
protected $options;

/**
 * @var string
 */
protected $prefix = ;

/**
 * @var ViewBaseInterface|null
 */
protected $view;

Methods¶

public function __construct( ViewBaseInterface $view = null );

Phalcon\Mvc\View\Engine\Volt\Compiler

public function addExtension( mixed $extension ): Compiler;

Registers a Volt's extension

@var mixed extension

public function addFilter( string $name, mixed $definition ): Compiler;

Register a new filter in the compiler

public function addFunction( string $name, mixed $definition ): Compiler;

Register a new function in the compiler

public function attributeReader( array $expr ): string;

Resolves attribute reading

public function compile( string $templatePath, bool $extendsMode = bool );

Compiles a template into a file applying the compiler options This method does not return the compiled path if the template was not compiled

$compiler->compile("views/layouts/main.volt");

require $compiler->getCompiledTemplatePath();

public function compileAutoEscape( array $statement, bool $extendsMode ): string;

Compiles a "autoescape" statement returning PHP code

public function compileCall( array $statement, bool $extendsMode );

Compiles calls to macros

public function compileCase( array $statement, bool $caseClause = bool ): string;

Compiles a "case"/"default" clause returning PHP code

public function compileDo( array $statement ): string;

Compiles a "do" statement returning PHP code

public function compileEcho( array $statement ): string;

Compiles a {% raw %}{{ }} statement returning PHP code

public function compileElseIf( array $statement ): string;

Compiles a "elseif" statement returning PHP code

public function compileFile( string $path, string $compiledPath, bool $extendsMode = bool );

Compiles a template into a file forcing the destination path

$compiler->compileFile(
    "views/layouts/main.volt",
    "views/layouts/main.volt.php"
);

public function compileForElse(): string;

Generates a 'forelse' PHP code

public function compileForeach( array $statement, bool $extendsMode = bool ): string;

Compiles a "foreach" intermediate code representation into plain PHP code

public function compileIf( array $statement, bool $extendsMode = bool ): string;

Compiles a 'if' statement returning PHP code

public function compileInclude( array $statement ): string;

Compiles a 'include' statement returning PHP code

public function compileMacro( array $statement, bool $extendsMode ): string;

Compiles macros

public function compileReturn( array $statement ): string;

Compiles a "return" statement returning PHP code

@throws \Phalcon\Mvc\View\Engine\Volt\Exception

public function compileSet( array $statement ): string;

Compiles a "set" statement returning PHP code. 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

use Phalcon\Mvc\View\Engine\Volt\Compiler;

$compiler = new Compiler();

// {% set a = ['first': 1] %}

$source = [
    "type" => 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);
// <?php $a = ['first' => 1]; ?>";

public function compileString( string $viewCode, bool $extendsMode = bool ): string;

Compiles a template into a string

echo $compiler->compileString({% raw %}'{{ "hello world" }}'{% endraw %});

public function compileSwitch( array $statement, bool $extendsMode = bool ): string;

Compiles a 'switch' statement returning PHP code

final public function expression( array $expr, bool $doubleQuotes = bool ): string;

Resolves an expression node in an AST volt tree

final public function fireExtensionEvent( string $name, array $arguments = [] );

Fires an event to registered extensions

public function functionCall( array $expr, bool $doubleQuotes = bool ): string;

Resolves function intermediate code into PHP function calls

public function getCompiledTemplatePath(): string;

Returns the path to the last compiled template

public function getDI(): DiInterface;

Returns the internal dependency injector

public function getExtensions(): array;

Returns the list of extensions registered in Volt

public function getFilters(): array;

Register the user registered filters

public function getFunctions(): array;

Register the user registered functions

public function getOption( string $option ): string | null;

Returns a compiler's option

public function getOptions(): array;

Returns the compiler options

public function getTemplatePath(): string;

Returns the path that is currently being compiled

public function getUniquePrefix(): string;

Return a unique prefix to be used as prefix for compiled variables and contexts

public function parse( string $viewCode ): array;

Parses a Volt template returning its intermediate representation

print_r(
    $compiler->parse("{% raw %}{{ 3 + 2 }}{% endraw %}")
);

public function resolveTest( array $test, string $left ): string;

Resolves filter intermediate code into a valid PHP expression

public function setDI( DiInterface $container ): void;

Sets the dependency injector

public function setOption( string $option, mixed $value );

Sets a single compiler option

public function setOptions( array $options );

Sets the compiler options

public function setUniquePrefix( string $prefix ): Compiler;

Set a unique prefix to be used as prefix for compiled variables

protected function compileSource( string $viewCode, bool $extendsMode = bool ): string;

Compiles a Volt source code returning a PHP plain version

protected function getFinalPath( string $path );

Gets the final path with VIEW

final protected function resolveFilter( array $filter, string $left ): string;

Resolves filter intermediate code into PHP function calls

final protected function statementList( array $statements, bool $extendsMode = bool ): string;

Traverses a statement list compiling each of its nodes

final protected function statementListOrExtends( mixed $statements );

Compiles a block of statements

Mvc\View\Engine\Volt\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\View\Engine\Volt
Uses
- Phalcon\Mvc\View\Exception
Extends

BaseException
Implements

Class for exceptions thrown by Phalcon\Mvc\View

Properties¶

/**
 * @var array
 */
protected $statement;

Methods¶

public function __construct( string $message = string, array $statement = [], int $code = int, \Exception $previous = null );

public function getStatement(): array;

Gets currently parsed statement (if any).

Mvc\View\Exception¶

Source on GitHub

Namespace
- Phalcon\Mvc\View
Uses
Extends

\Exception
Implements

Phalcon\Mvc\View\Exception

Class for exceptions thrown by Phalcon\Mvc\View

Mvc\View\Simple¶

Source on GitHub

Namespace
- Phalcon\Mvc\View
Uses
- Closure
- Phalcon\Di\DiInterface
- Phalcon\Di\Injectable
- Phalcon\Events\EventsAwareInterface
- Phalcon\Events\ManagerInterface
- Phalcon\Mvc\ViewBaseInterface
- Phalcon\Mvc\View\Engine\EngineInterface
- Phalcon\Mvc\View\Engine\Php
Extends

Injectable
Implements
- EventsAwareInterface
- ViewBaseInterface

Phalcon\Mvc\View\Simple

This component allows to render views without hierarchical levels

use Phalcon\Mvc\View\Simple as View;

$view = new View();

// Render a view
echo $view->render(
    "templates/my-view",
    [
        "some" => $param,
    ]
);

// Or with filename with extension
echo $view->render(
    "templates/my-view.volt",
    [
        "parameter" => $here,
    ]
);

Properties¶

/**
 * @var string
 */
protected $activeRenderPath;

/**
 * @var string
 */
protected $content;

/**
 * @var EngineInterface[]|false
 */
protected $engines = false;

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

/**
 * @var array
 */
protected $options;

/**
 * @var array
 */
protected $registeredEngines;

/**
 * @var string
 */
protected $viewsDir;

/**
 * @var array
 */
protected $viewParams;

Methods¶

public function __construct( array $options = [] );

Phalcon\Mvc\View\Simple constructor

public function __get( string $key ): mixed | null;

Magic method to retrieve a variable passed to the view

echo $this->view->products;

public function __set( string $key, mixed $value ): void;

Magic method to pass variables to the views

$this->view->products = $products;

public function getActiveRenderPath(): string;

Returns the path of the view that is currently rendered

public function getContent(): string;

Returns output from another view stage

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getParamsToView(): array;

Returns parameters to views

public function getRegisteredEngines(): array;

public function getVar( string $key ): mixed | null;

Returns a parameter previously set in the view

public function getViewsDir(): string;

Gets views directory

public function partial( string $partialPath, mixed $params = null ): void;

Renders a partial view

// Show a partial inside another view
$this->partial("shared/footer");

// Show a partial inside another view with parameters
$this->partial(
    "shared/footer",
    [
        "content" => $html,
    ]
);

public function registerEngines( array $engines ): void;

Register templating engines

$this->view->registerEngines(
    [
        ".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
        ".volt"  => \Phalcon\Mvc\View\Engine\Volt::class,
        ".mhtml" => \MyCustomEngine::class,
    ]
);

public function render( string $path, array $params = [] ): string;

Renders a view

public function setContent( string $content ): Simple;

Externally sets the view content

$this->view->setContent("<h1>hello</h1>");

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setParamToView( string $key, mixed $value ): Simple;

Adds parameters to views (alias of setVar)

$this->view->setParamToView("products", $products);

public function setVar( string $key, mixed $value ): Simple;

Set a single view parameter

$this->view->setVar("products", $products);

public function setVars( array $params, bool $merge = bool ): Simple;

Set all the render params

$this->view->setVars(
    [
        "products" => $products,
    ]
);

public function setViewsDir( string $viewsDir ): void;

Sets views directory

final protected function internalRender( string $path, mixed $params ): void;

Tries to render the view with every engine registered in the component

protected function loadTemplateEngines(): array;

Loads registered template engines, if none are registered it will use Phalcon\Mvc\View\Engine\Php

Mvc\ViewBaseInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
- Phalcon\Cache\Adapter\AdapterInterface
Extends
Implements

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple

Methods¶

public function getContent(): string;

Returns cached output from another view stage

public function getParamsToView(): array;

Returns parameters to views

public function getViewsDir(): string | array;

Gets views directory

public function partial( string $partialPath, mixed $params = null );

Renders a partial view

public function setContent( string $content );

Externally sets the view content

public function setParamToView( string $key, mixed $value );

Adds parameters to views (alias of setVar)

public function setVar( string $key, mixed $value );

Adds parameters to views

public function setViewsDir( string $viewsDir );

Sets views directory. Depending of your platform, always add a trailing slash or backslash

Mvc\ViewInterface ¶

Source on GitHub

Namespace
- Phalcon\Mvc
Uses
Extends

ViewBaseInterface
Implements

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View

Methods¶

public function cleanTemplateAfter();

Resets any template before layouts

public function cleanTemplateBefore();

Resets any template before layouts

public function disable();

Disables the auto-rendering process

public function enable();

Enables the auto-rendering process

public function finish();

Finishes the render process by stopping the output buffering

public function getActionName(): string;

Gets the name of the action rendered

public function getActiveRenderPath(): string | array;

Returns the path of the view that is currently rendered

public function getBasePath(): string;

Gets base path

public function getControllerName(): string;

Gets the name of the controller rendered

public function getLayout(): string;

Returns the name of the main view

public function getLayoutsDir(): string;

Gets the current layouts sub-directory

public function getMainView(): string;

Returns the name of the main view

public function getPartialsDir(): string;

Gets the current partials sub-directory

public function isDisabled(): bool;

Whether the automatic rendering is disabled

public function pick( string $renderView );

Choose a view different to render than last-controller/last-action

public function registerEngines( array $engines );

Register templating engines

public function render( string $controllerName, string $actionName, array $params = [] ): ViewInterface | bool;

Executes render process from dispatching data

public function reset();

Resets the view component to its factory default values

public function setBasePath( string $basePath );

Sets base path. Depending of your platform, always add a trailing slash or backslash

public function setLayout( string $layout );

Change the layout to be used instead of using the name of the latest controller name

public function setLayoutsDir( string $layoutsDir );

Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

public function setMainView( string $viewPath );

Sets default view name. Must be a file without extension in the views directory

public function setPartialsDir( string $partialsDir );

Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

public function setRenderLevel( int $level ): ViewInterface;

Sets the render level for the view

public function setTemplateAfter( mixed $templateAfter );

Appends template after controller layout

public function setTemplateBefore( mixed $templateBefore );

Appends template before controller layout

public function start();

Starts rendering process enabling the output buffering