Skip to content

Class Phalcon\Mvc\Application

Source on GitHub

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

Phalcon\Mvc\Application

This component encapsulates all the complex operations behind instantiating every component needed and integrating it with the rest to allow the MVC pattern to operate as desired.

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

//
protected implicitView = true;

//
protected sendCookies = true;

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

Class Phalcon\Mvc\Application\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Application | | Extends | \Phalcon\Application\Exception |

Phalcon\Mvc\Application\Exception

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

Abstract Class Phalcon\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

Interface Phalcon\Mvc\Controller\BindModelInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Controller |

Phalcon\Mvc\Controller\BindModelInterface

Interface for Phalcon\Mvc\Controller

Methods

public static function getModelName(): string;
Return the model name associated with this controller

Interface Phalcon\Mvc\ControllerInterface

Source on GitHub

| Namespace | Phalcon\Mvc |

Phalcon\Mvc\ControllerInterface

Interface for controller handlers

Class Phalcon\Mvc\Dispatcher

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Mvc\Dispatcher\Exception, Phalcon\Events\ManagerInterface, Phalcon\Http\ResponseInterface, Phalcon\Dispatcher\AbstractDispatcher | | Extends | BaseDispatcher | | Implements | DispatcherInterface |

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

$di = new \Phalcon\Di();

$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

Class Phalcon\Mvc\Dispatcher\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Dispatcher | | Extends | \Phalcon\Dispatcher\Exception |

Phalcon\Mvc\Dispatcher\Exception

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

Interface Phalcon\Mvc\DispatcherInterface

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Dispatcher\DispatcherInterface | | Extends | DispatcherInterfaceBase |

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

Interface Phalcon\Mvc\EntityInterface

Source on GitHub

| Namespace | Phalcon\Mvc |

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

Class Phalcon\Mvc\Micro

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | ArrayAccess, Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Di\FactoryDefault, Phalcon\Mvc\Micro\Exception, Phalcon\Di\ServiceInterface, Phalcon\Mvc\Micro\Collection, Phalcon\Mvc\Micro\LazyLoader, Phalcon\Http\ResponseInterface, Phalcon\Mvc\Model\BinderInterface, Phalcon\Mvc\Router\RouteInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\Micro\MiddlewareInterface, Phalcon\Mvc\Micro\CollectionInterface, Throwable | | Extends | Injectable | | Implements | ArrayAccess, EventsAwareInterface |

Phalcon\Mvc\Micro

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

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

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

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

Properties

//
protected activeHandler;

//
protected afterBindingHandlers;

//
protected afterHandlers;

//
protected beforeHandlers;

//
protected container;

//
protected errorHandler;

//
protected eventsManager;

//
protected finishHandlers;

//
protected handlers;

//
protected modelBinder;

//
protected notFoundHandler;

//
protected responseHandler;

//
protected returnedValue;

//
protected router;

//
protected stopped;

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 $alias ): bool;
Check if a service is registered in the internal services container using the array syntax

public function offsetGet( mixed $alias ): mixed;
Allows to obtain a shared service in the internal services container using the array syntax

var_dump(
    $app["request"]
);


public function offsetSet( mixed $alias, mixed $definition ): 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 $alias ): 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();
Stops the middleware execution avoiding than other middlewares be executed

Class Phalcon\Mvc\Micro\Collection

Source on GitHub

| Namespace | Phalcon\Mvc\Micro | | Implements | CollectionInterface |

Phalcon\Mvc\Micro\Collection

Groups Micro-Mvc handlers as controllers

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

$collection = new Collection();

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

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

$app->mount($collection);

Properties

//
protected handler;

//
protected handlers;

//
protected lazy;

//
protected prefix;

Methods

public function delete( string $routePattern, mixed $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, mixed $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, mixed $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, mixed $handler, string $name = null ): CollectionInterface;
Maps a route to a handler.

public function mapVia( string $routePattern, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $handler, string $name );
Internal function to add a handler to the group.

Interface Phalcon\Mvc\Micro\CollectionInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Micro |

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

Class Phalcon\Mvc\Micro\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Micro | | Extends | \Phalcon\Exception |

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

Class Phalcon\Mvc\Micro\LazyLoader

Source on GitHub

| Namespace | Phalcon\Mvc\Micro | | Uses | Phalcon\Mvc\Model\BinderInterface |

Phalcon\Mvc\Micro\LazyLoader

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

Properties

//
protected handler;

//
protected definition;

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

public function getHandler()

Interface Phalcon\Mvc\Micro\MiddlewareInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Micro | | Uses | Phalcon\Mvc\Micro |

Allows to implement Phalcon\Mvc\Micro middleware in classes

Methods

public function call( Micro $application );
Calls the middleware

Abstract Class Phalcon\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, Phalcon\Di\DiInterface, Phalcon\Events\ManagerInterface, Phalcon\Helper\Arr, Phalcon\Messages\Message, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model\BehaviorInterface, Phalcon\Mvc\Model\Criteria, Phalcon\Mvc\Model\CriteriaInterface, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\ManagerInterface, Phalcon\Mvc\Model\MetaDataInterface, Phalcon\Mvc\Model\Query, Phalcon\Mvc\Model\Query\Builder, Phalcon\Mvc\Model\Query\BuilderInterface, Phalcon\Mvc\Model\QueryInterface, Phalcon\Mvc\Model\ResultInterface, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Relation, Phalcon\Mvc\Model\RelationInterface, Phalcon\Mvc\Model\TransactionInterface, Phalcon\Mvc\Model\ValidationFailed, Phalcon\Mvc\ModelInterface, Phalcon\Validation\ValidationInterface, Serializable | | Extends | AbstractInjectionAware | | Implements | EntityInterface, ModelInterface, ResultInterface, Serializable, JsonSerializable |

Phalcon\Mvc\Model

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

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

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

$robot = new Robots();

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

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

    $messages = $robot->getMessages();

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

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

//
protected dirtyState = 1;

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

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

//
protected modelsManager;

//
protected modelsMetaData;

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

//
protected operationMade = 0;

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

//
protected skipped;

//
protected snapshot;

//
protected transaction;

//
protected uniqueKey;

//
protected uniqueParams;

//
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 __set( string $property, mixed $value );
Magic method to assign values to the 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( mixed $parameters = null ): double | ResultsetInterface;
Returns the average value on a column for a result-set of rows matching the specified conditions.

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

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

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

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

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


public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;
Assigns values to a model from an array returning a new model

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


public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = null ): ModelInterface;
Assigns values to a model from an array, returning a new model.

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


public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );
Returns an hydrated result based on the data and the column map

public static function count( mixed $parameters = null ): int | ResultsetInterface;
Counts how many records match the specified conditions.

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

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

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

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

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


public function create(): bool;
Inserts a model instance. If the instance already exists in the persistence it will throw an exception Returning true on success or false otherwise.

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

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

$robot->create();

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

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

$robot->create();


public function delete(): bool;
Deletes a model instance. Returning true on success or false otherwise.

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

$robot->delete();

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

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


public function dump(): array;
Returns a simple representation of the object that can be used with var_dump()

var_dump(
    $robot->dump()
);


public static function find( mixed $parameters = null ): ResultsetInterface;
Query for a set of records that match the specified conditions

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

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

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

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

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

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

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

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

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

$myTransaction = new Transaction(\Phalcon\Di::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::getDefault());
$myTransaction1->begin();
$myTransaction2 = new Transaction(\Phalcon\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 ): ModelInterface | 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::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;
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()


public function getUpdatedFields(): array;
Returns a list of updated values.

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

$robots->deleted = 'Y';

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


final public function getWriteConnection(): AdapterInterface;
Gets the connection used to write data to the model

final public function getWriteConnectionService(): string;
Returns the DependencyInjection connection service name used to write data related to the model

public function hasChanged( mixed $fieldName = null, bool $allFields = bool ): bool;
Check if a specific attribute has changed This only works if the model is keeping data snapshots

$robot = new Robots();

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

$robot->create();

$robot->type = "hydraulic";

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


public function hasSnapshotData(): bool;
Checks if the object has internal snapshot data

public function hasUpdated( mixed $fieldName = null, bool $allFields = bool ): bool;
Check if a specific attribute was updated This only works if the model is keeping data snapshots

public function isRelationshipLoaded( string $relationshipAlias ): bool;
Checks if saved related records have already been loaded.

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

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

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

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

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


public function jsonSerialize(): array;
Serializes the object for json_encode

echo json_encode($robot);


public static function maximum( mixed $parameters = null ): mixed;
Returns the maximum value of a column for a result-set of rows that match the specified conditions

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

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

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

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


public static function minimum( mixed $parameters = null ): mixed;
Returns the minimum value of a column for a result-set of rows that match the specified conditions

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

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

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

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


public static function query( DiInterface $container = null ): CriteriaInterface;
Create a criteria for a specific model

public function readAttribute( string $attribute ): mixed | null;
Reads an attribute value by its name

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


public function refresh(): ModelInterface;
Refreshes the model attributes re-querying the record from the database

public function save(): bool;
Inserts or updates a model instance. Returning true on success or false otherwise.

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

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

$robot->save();

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

$robot->name = "Biomass";

$robot->save();


public function serialize(): string;
Serializes the object ignoring connections, services, related objects or static properties

final public function setConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name

public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Sets the dirty state of the object using one of the DIRTY_STATE_* constants

public function setEventsManager( EventsManagerInterface $eventsManager );
Sets a custom events manager

public function setOldSnapshotData( array $data, mixed $columnMap = null );
Sets the record's old snapshot data. This method is used internally to set old snapshot data when the model was set up to keep snapshot data

final public function setReadConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name used to read data

public function setSnapshotData( array $data, mixed $columnMap = null ): void;
Sets the record's snapshot data. This method is used internally to set snapshot data when the model was set up to keep snapshot data

public function setTransaction( TransactionInterface $transaction ): ModelInterface;
Sets a transaction related to the Model instance

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

try {
    $txManager = new TxManager();

    $transaction = $txManager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

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

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

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

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

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


final public function setWriteConnectionService( string $connectionService ): void;
Sets the DependencyInjection connection service name used to write data

public static function setup( array $options ): void;
Enables/disables options in the ORM

public function skipOperation( bool $skip ): void;
Skips the current operation forcing a success state

public static function sum( mixed $parameters = null ): double | ResultsetInterface;
Calculates the sum on a column for a result-set of rows that match the specified conditions

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

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

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

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


public function toArray( mixed $columns = null ): array;
Returns the instance as an array representation

print_r(
    $robot->toArray()
);


public function unserialize( mixed $data );
Unserializes the object from a serialized string

public function update(): bool;
Updates a model instance. If the instance doesn't exist in the persistence it will throw an exception. Returning true on success or false otherwise.

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

$robot->name = "Biomass";

$robot->update();


public function validationHasFailed(): bool;
Check whether validation process has generated any messages

use Phalcon\Mvc\Model;
use Phalcon\Validation;
use Phalcon\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 _cancelOperation();
Cancel the current operation

@todo Remove in v5.0 @deprecated Use cancelOperation()

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 _doLowInsert( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table, mixed $identityField ): bool;
Sends a pre-build INSERT SQL statement to the relational database system

@todo Remove in v5.0 @deprecated Use doLowInsert()

protected function _doLowUpdate( MetaDataInterface $metaData, AdapterInterface $connection, mixed $table ): bool;
Sends a pre-build UPDATE SQL statement to the relational database system

@todo Remove in v5.0 @deprecated Use doLowUpdate()

protected function _exists( MetaDataInterface $metaData, AdapterInterface $connection ): bool;
Checks whether the current record already exists

@todo Remove in v5.0 @deprecated Use exists()

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.

@todo Remove in v5.0 @deprecated Use getRelatedRecords()

protected static function _groupResult( string $functionName, string $alias, mixed $parameters ): ResultsetInterface;
Generate a PHQL SELECT statement for an aggregate

@todo Remove in v5.0 @deprecated Use groupResult()

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

@todo Remove in v5.0 @deprecated Use postSave()

protected function _postSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Save the related records assigned in the has-one/has-many relations

@todo Remove in v5.0 @deprecated Use postSaveRelatedRecords()

protected function _preSave( MetaDataInterface $metaData, bool $exists, mixed $identityField ): bool;
Executes internal hooks before save a record

@todo Remove in v5.0 @deprecated Use preSave()

protected function _preSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Saves related records that must be stored prior to save the master record

@todo Remove in v5.0 @deprecated Use preSaveRelatedRecords()

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, mixed $options = null ): 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

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 exists( MetaDataInterface $metaData, AdapterInterface $connection ): bool;
Checks whether the current record already exists

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 ): ResultsetInterface;
Generate a PHQL SELECT statement for an aggregate

protected function hasMany( mixed $fields, string $referenceModel, mixed $referencedFields, mixed $options = null ): 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, mixed $options = null ): 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, mixed $options = null ): 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, mixed $options = null ): 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);
    }
}


protected function postSave( bool $success, bool $exists ): bool;
Executes internal events after save a record

protected function postSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Save the related records assigned in the has-one/has-many relations

protected function preSave( MetaDataInterface $metaData, bool $exists, mixed $identityField ): bool;
Executes internal hooks before save a record

protected function preSaveRelatedRecords( AdapterInterface $connection, mixed $related ): bool;
Saves related records that must be stored prior to save the master record

final protected function setSchema( string $schema ): ModelInterface;
Sets schema name where the mapped table is located

final protected function setSource( string $source ): ModelInterface;
Sets the table name to which model should be mapped

protected function skipAttributes( array $attributes );
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\Validation;
use Phalcon\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);
    }
}

Abstract Class Phalcon\Mvc\Model\Behavior

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface | | 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

Class Phalcon\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 |

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

Class Phalcon\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 |

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

Interface Phalcon\Mvc\Model\BehaviorInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface |

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

Class Phalcon\Mvc\Model\Binder

Source on GitHub

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

Phalcon\Mvc\Model\Binder

This is an class for binding models into params for handler

Properties

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

/**
 * Cache object used for caching parameters for model binding
 */
protected cache;

/**
 * Internal cache for caching parameters for model binding during request
 */
protected internalCache;

/**
 * Array for original values
 */
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


public function getCache(): AdapterInterface;
Sets cache instance

public function getOriginalValues()


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

Interface Phalcon\Mvc\Model\Binder\BindableInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Binder |

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

Interface Phalcon\Mvc\Model\BinderInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Cache\Adapter\AdapterInterface |

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

Class Phalcon\Mvc\Model\Criteria

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Di, Phalcon\Db\Column, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\Query\BuilderInterface | | Implements | CriteriaInterface, InjectionAwareInterface |

Phalcon\Mvc\Model\Criteria

This class is used to build the array parameter required by Phalcon\Mvc\Model::find() and Phalcon\Mvc\Model::findFirst() using an object-oriented interface.

$robots = Robots::query()
    ->where("type = :type:")
    ->andWhere("year < 2000")
    ->bind(["type" => "mechanical"])
    ->limit(5, 10)
    ->orderBy("name")
    ->execute();

Properties

//
protected bindParams;

//
protected bindTypes;

//
protected hiddenParamNumber = 0;

//
protected model;

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

$criteria->columns(
    [
        "id",
        "name",
    ]
);


public function conditions( string $conditions ): CriteriaInterface;
Adds the conditions parameter to the criteria

public function createBuilder(): BuilderInterface;
Creates a query builder from criteria.

$builder = Robots::query()
    ->where("type = :type:")
    ->bind(["type" => "mechanical"])
    ->createBuilder();


public function distinct( mixed $distinct ): CriteriaInterface;
Sets SELECT DISTINCT / SELECT ALL flag

public function execute(): ResultsetInterface;
Executes a find using the parameters built with the criteria

public function forUpdate( bool $forUpdate = bool ): CriteriaInterface;
Adds the "for_update" parameter to the criteria

public static function fromInput( DiInterface $container, string $modelName, array $data, string $operator = string ): CriteriaInterface;
Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST

public function getColumns(): string | array | null;
Returns the columns to be queried

public function getConditions(): string | null;
Returns the conditions parameter in the criteria

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

public function getGroupBy();
Returns the group clause in the criteria

public function getHaving();
Returns the having clause in the criteria

public function getLimit(): int | array | null;
Returns the limit parameter in the criteria, which will be

  • 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

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

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

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


public function join( string $model, mixed $conditions = null, mixed $alias = null, mixed $type = null ): CriteriaInterface;
Adds an INNER join to the query

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

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

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

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


public function leftJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a LEFT join to the query

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


public function limit( int $limit, int $offset = int ): CriteriaInterface;
Adds the limit parameter to the criteria.

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


public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;
Appends a NOT BETWEEN condition to the current conditions

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


public function notInWhere( string $expr, array $values ): CriteriaInterface;
Appends a NOT IN condition to the current conditions

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


public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Appends a condition to the current conditions using an OR operator

public function orderBy( string $orderColumns ): CriteriaInterface;
Adds the order-by clause to the criteria

public function rightJoin( string $model, mixed $conditions = null, mixed $alias = null ): CriteriaInterface;
Adds a RIGHT join to the query

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


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

public function setModelName( string $modelName ): CriteriaInterface;
Set a model on which the query will be executed

public function sharedLock( bool $sharedLock = bool ): CriteriaInterface;
Adds the "shared_lock" parameter to the criteria

public function where( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
Sets the conditions parameter in the criteria

Interface Phalcon\Mvc\Model\CriteriaInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Di\DiInterface |

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

Class Phalcon\Mvc\Model\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Extends | \Phalcon\Exception |

Phalcon\Mvc\Model\Exception

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

Class Phalcon\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 | | Implements | ManagerInterface, InjectionAwareInterface, EventsAwareInterface |

Phalcon\Mvc\Model\Manager

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

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

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

$di = new Di();

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

$robot = new Robots($di);

Properties

//
protected aliases;

/**
 * Models' behaviors
 */
protected behaviors;

/**
 * Belongs to relations
 */
protected belongsTo;

/**
 * All the relationships by model
 */
protected belongsToSingle;

//
protected container;

//
protected customEventsManager;

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

//
protected eventsManager;

/**
 * Has many relations
 */
protected hasMany;

/**
 * Has many relations by model
 */
protected hasManySingle;

/**
 * Has many-Through relations
 */
protected hasManyToMany;

/**
 * Has many-Through relations by model
 */
protected hasManyToManySingle;

/**
 * Has one relations
 */
protected hasOne;

/**
 * Has one relations by model
 */
protected hasOneSingle;

/**
 * Has one through relations
 */
protected hasOneThrough;

/**
 * Has one through relations by model
 */
protected hasOneThroughSingle;

/**
 * Mark initialized models
 */
protected initialized;

//
protected keepSnapshots;

/**
 * Last model initialized
 */
protected lastInitialized;

/**
 * Last query created/executed
 */
protected lastQuery;

//
protected modelVisibility;

//
protected prefix = ;

//
protected readConnectionServices;

//
protected sources;

//
protected schemas;

//
protected writeConnectionServices;

/**
 * Stores a list of reusable instances
 */
protected reusable;

Methods

public function __destruct();
Destroys the current PHQL cache

public function _getConnectionService( ModelInterface $model, mixed $connectionServices ): string;
Returns the connection service name used to read or write data related to a model depending on the connection services

@todo Remove in v5.0 @deprecated Use getConnectionService()

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, mixed $options = null ): RelationInterface;
Setup a relation reverse many to one between two models

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, mixed $options = null ): 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, mixed $options = null ): RelationInterface;
Setups a relation n-m between two models

public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, mixed $options = null ): 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, mixed $options = null ): 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

public function existsHasMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasMany relation with another model

public function existsHasManyToMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasManyToMany relation with another model

public function existsHasOne( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOne relation with another model

public function existsHasOneThrough( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOneThrough relation with another model

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 getConnectionService( ModelInterface $model, mixed $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;
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;
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 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


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, mixed $connectionServices ): AdapterInterface;
Returns the connection to read or write data related to a model depending on the connection services.

@todo Remove in v5.0 @deprecated Use getConnection()

final protected function _mergeFindParameters( mixed $findParamsOne, mixed $findParamsTwo ): array;
Merge two arrays of find parameters

protected function getConnection( ModelInterface $model, mixed $connectionServices ): AdapterInterface;
Returns the connection to read or write data related to a model depending on the connection services.

Interface Phalcon\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 |

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, mixed $options = null ): RelationInterface;
Setup a relation reverse 1-1 between two models

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, mixed $options = null ): 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, mixed $options = null ): RelationInterface;
Setups a relation n-m between two models

public function addHasOne( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, mixed $options = null ): 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, mixed $options = null ): 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 existsBelongsTo( string $modelName, string $modelRelation ): bool;
Checks whether a model has a belongsTo relation with another model

public function existsHasMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasMany relation with another model

public function existsHasManyToMany( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasManyToMany relation with another model

public function existsHasOne( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOne relation with another model

public function existsHasOneThrough( string $modelName, string $modelRelation ): bool;
Checks whether a model has a hasOneThrough relation with another model

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 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;
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 ): Relation | 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 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

Abstract Class Phalcon\Mvc\Model\MetaData

Source on GitHub

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

Phalcon\Mvc\Model\MetaData

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

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

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

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

print_r($attributes);

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
 */
protected adapter;

//
protected columnMap;

//
protected container;

//
protected metaData;

//
protected strategy;

Methods

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 );
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;
Reads the complete meta-data for certain model

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


final public function readMetaDataIndex( ModelInterface $model, int $index );
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",
        ]
    )
);


final protected function initialize( ModelInterface $model, mixed $key, mixed $table, mixed $schema );
Initialize the metadata for certain table

Class Phalcon\Mvc\Model\MetaData\Apcu

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData | | Uses | Phalcon\Helper\Arr, Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception, Phalcon\Cache\AdapterFactory | | Extends | MetaData |

Phalcon\Mvc\Model\MetaData\Apcu

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

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

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

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

Methods

public function __construct( AdapterFactory $factory, array $options = null );
Phalcon\Mvc\Model\MetaData\Apcu constructor

Class Phalcon\Mvc\Model\MetaData\Libmemcached

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData | | Uses | Phalcon\Helper\Arr, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\MetaData, Phalcon\Cache\AdapterFactory | | Extends | MetaData |

Phalcon\Mvc\Model\MetaData\Libmemcached

Stores model meta-data in the Memcache.

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

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

Class Phalcon\Mvc\Model\MetaData\Memory

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData | | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception | | Extends | MetaData |

Phalcon\Mvc\Model\MetaData\Memory

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

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

Class Phalcon\Mvc\Model\MetaData\Redis

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData | | Uses | Phalcon\Helper\Arr, Phalcon\Mvc\Model\MetaData, Phalcon\Cache\AdapterFactory | | Extends | MetaData |

Phalcon\Mvc\Model\MetaData\Redis

Stores model meta-data in the Redis.

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

use Phalcon\Mvc\Model\MetaData\Redis;

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

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

Class Phalcon\Mvc\Model\MetaData\Strategy\Annotations

Source on GitHub

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

This file is part of the Phalcon Framework.

(c) Phalcon Team 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

Class Phalcon\Mvc\Model\MetaData\Strategy\Introspection

Source on GitHub

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

Phalcon\Mvc\Model\MetaData\Strategy\Introspection

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

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

Interface Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData\Strategy | | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Di\DiInterface |

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

Class Phalcon\Mvc\Model\MetaData\Stream

Source on GitHub

| Namespace | Phalcon\Mvc\Model\MetaData | | Uses | Phalcon\Mvc\Model\MetaData, Phalcon\Mvc\Model\Exception | | Extends | MetaData |

Phalcon\Mvc\Model\MetaData\Stream

Stores model meta-data in PHP files.

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

Properties

//
protected metaDataDir = ./;

Methods

public function __construct( mixed $options = null );
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

Interface Phalcon\Mvc\Model\MetaDataInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface |

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 );
Reads column-map information for certain model using a MODEL_* constant

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

public function readMetaDataIndex( ModelInterface $model, int $index ): mixed;
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

Class Phalcon\Mvc\Model\Query

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Db\Column, Phalcon\Db\RawValue, Phalcon\Db\ResultInterface, Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Helper\Arr, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Query\Status, Phalcon\Mvc\Model\Resultset\Complex, Phalcon\Mvc\Model\Query\StatusInterface, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Resultset\Simple, Phalcon\Di\InjectionAwareInterface, Phalcon\Db\DialectInterface, Phalcon\Mvc\Model\Query\Lang | | Implements | QueryInterface, InjectionAwareInterface |

Phalcon\Mvc\Model\Query

This class takes a PHQL intermediate representation and executes it.

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

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

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

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

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

$phql = 'SELECTFROM robot';

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

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

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

$resultWithEntries = $queryWithTransaction->execute();

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

Constants

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

Properties

//
protected ast;

//
protected bindParams;

//
protected bindTypes;

//
protected cache;

//
protected cacheOptions;

//
protected container;

//
protected enableImplicitJoins;

//
protected intermediate;

//
protected manager;

//
protected metaData;

//
protected models;

//
protected modelsInstances;

//
protected nestingLevel = -1;

//
protected phql;

//
protected sharedLock;

//
protected sqlAliases;

//
protected sqlAliasesModels;

//
protected sqlAliasesModelsInstances;

//
protected sqlColumnAliases;

//
protected sqlModelsAliases;

//
protected type;

//
protected uniqueRow;

//
static protected _irPhqlCache;

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

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


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 _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 ): string;
Resolves an expression from its intermediate code into a string

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

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

@todo Remove in v5.0 @deprecated Use getRelatedRecords()

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

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

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

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

Class Phalcon\Mvc\Model\Query\Builder

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Query | | Uses | Phalcon\Di, Phalcon\Db\Column, Phalcon\Di\DiInterface, Phalcon\Helper\Arr, Phalcon\Mvc\Model\Exception, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\QueryInterface | | Implements | BuilderInterface, InjectionAwareInterface |

Phalcon\Mvc\Model\Query\Builder

Helps to create PHQL queries using an OO interface

$params = [
    "models"     => [
        Users::class,
    ],
    "columns"    => ["id", "name", "status"],
    "conditions" => [
        [
            "created > :min: AND created < :max:",
            [
                "min" => "2013-01-01",
                "max" => "2014-01-01",
            ],
            [
                "min" => PDO::PARAM_STR,
                "max" => PDO::PARAM_STR,
            ],
        ],
    ],
    // or "conditions" => "created > '2013-01-01' AND created < '2014-01-01'",
    "group"      => ["id", "name"],
    "having"     => "name = 'Kamil'",
    "order"      => ["name", "id"],
    "limit"      => 20,
    "offset"     => 20,
    // or "limit" => [20, 20],
];

$queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);

Properties

//
protected bindParams;

//
protected bindTypes;

//
protected columns;

//
protected conditions;

//
protected container;

//
protected distinct;

//
protected forUpdate;

/**
 * @var array
 */
protected group;

//
protected having;

//
protected hiddenParamNumber = 0;

//
protected joins;

//
protected limit;

/**
 * @var array|string
 */
protected models;

//
protected offset;

//
protected order;

//
protected sharedLock;

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

$builder->columns("id, name");

$builder->columns(
    [
        "id",
        "name",
    ]
);

$builder->columns(
    [
        "name",
        "number" => "COUNT(*)",
    ]
);


public function distinct( mixed $distinct ): BuilderInterface;
Sets SELECT DISTINCT / SELECT ALL flag

$builder->distinct("status");
$builder->distinct(null);


public function forUpdate( bool $forUpdate ): BuilderInterface;
Sets a FOR UPDATE clause

$builder->forUpdate(true);


public function from( mixed $models ): BuilderInterface;
Sets the models who makes part of the query

$builder->from(
    Robots::class
);

$builder->from(
    [
        Robots::class,
        RobotsParts::class,
    ]
);

$builder->from(
    [
        "r"  => Robots::class,
        "rp" => RobotsParts::class,
    ]
);


public function getBindParams(): array;
Returns default bind params

public function getBindTypes(): array;
Returns default bind types

public function getColumns();
Return the columns to be queried

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

public function getDistinct(): bool;
Returns SELECT DISTINCT / SELECT ALL flag

public function getFrom();
Return the models who makes part of the query

public function getGroupBy(): array;
Returns the GROUP BY clause

public function getHaving(): string;
Return the current having clause

public function getJoins(): array;
Return join parts of the query

public function getLimit();
Returns the current LIMIT clause

public function getModels(): string | array | null;
Returns the models involved in the query

public function getOffset(): int;
Returns the current OFFSET clause

public function getOrderBy();
Returns the set ORDER BY clause

final public function getPhql(): string;
Returns a PHQL statement built based on the builder parameters

public function getQuery(): QueryInterface;
Returns the query built

public function getWhere();
Return the conditions for the query

public function groupBy( mixed $group ): BuilderInterface;
Sets a GROUP BY clause

$builder->groupBy(
    [
        "Robots.name",
    ]
);


public function having( mixed $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

Interface Phalcon\Mvc\Model\Query\BuilderInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Query | | Uses | Phalcon\Mvc\Model\QueryInterface |

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

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 $having ): 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( string $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

Abstract Class Phalcon\Mvc\Model\Query\Lang

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Query |

Phalcon\Mvc\Model\Query\Lang

PHQL is implemented as a parser (written in C) that translates syntax in that of the target RDBMS. It allows Phalcon to offer a unified SQL language to the developer, while internally doing all the work of translating PHQL instructions to the most optimal SQL instructions depending on the RDBMS type associated with a model.

To achieve the highest performance possible, we wrote a parser that uses the same technology as SQLite. This technology provides a small in-memory parser with a very low memory footprint that is also thread-safe.

use Phalcon\Mvc\Model\Query\Lang;

$intermediate = Lang::parsePHQL(
    "SELECT r.* FROM Robots r LIMIT 10"
);

Methods

public static function parsePHQL( string $phql ): array;
Parses a PHQL statement returning an intermediate representation (IR)

Class Phalcon\Mvc\Model\Query\Status

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Query | | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface | | Implements | StatusInterface |

Phalcon\Mvc\Model\Query\Status

This class represents the status returned by a PHQL statement like INSERT, UPDATE or DELETE. It offers context information and the related messages produced by the model which finally executes the operations when it fails

$phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";

$status = $app->modelsManager->executeQuery(
    $phql,
    [
        "id"   => 100,
        "name" => "Astroy Boy",
        "type" => "mechanical",
        "year" => 1959,
    ]
);

// Check if the update was successful
if ($status->success()) {
    echo "OK";
}

Properties

//
protected model;

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

Interface Phalcon\Mvc\Model\Query\StatusInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Query | | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface |

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

Interface Phalcon\Mvc\Model\QueryInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface |

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

Class Phalcon\Mvc\Model\Relation

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | 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

//
protected fields;

//
protected intermediateFields;

//
protected intermediateModel;

//
protected intermediateReferencedFields;

//
protected options;

//
protected referencedFields;

//
protected referencedModel;

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

Interface Phalcon\Mvc\Model\RelationInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model |

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

Interface Phalcon\Mvc\Model\ResultInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface |

Phalcon\Mvc\Model\ResultInterface

All single objects passed as base objects to Resultsets must implement this interface

Methods

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

Abstract Class Phalcon\Mvc\Model\Resultset

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | ArrayAccess, Closure, Countable, Iterator, JsonSerializable, Phalcon\Db\Enum, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model, Phalcon\Mvc\ModelInterface, Phalcon\Cache\Adapter\AdapterInterface, Phalcon\Storage\Serializer\SerializerInterface, SeekableIterator, Serializable | | Implements | ResultsetInterface, Iterator, SeekableIterator, Countable, ArrayAccess, Serializable, JsonSerializable |

Phalcon\Mvc\Model\Resultset

This component allows to Phalcon\Mvc\Model returns large resultsets with the minimum memory consumption Resultsets can be traversed using a standard foreach or a while statement. If a resultset is serialized it will dump all the rows into a big array. Then unserialize will retrieve the rows as they were before serializing.

// Using a standard foreach
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

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

// Using a while
$robots = Robots::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

$robots->rewind();

while ($robots->valid()) {
    $robot = $robots->current();

    echo $robot->name, "\n";

    $robots->next();
}

Constants

const HYDRATE_ARRAYS = 1;
const HYDRATE_OBJECTS = 2;
const HYDRATE_RECORDS = 0;
const TYPE_RESULT_FULL = 0;
const TYPE_RESULT_PARTIAL = 1;

Properties

//
protected activeRow;

//
protected cache;

//
protected count = 0;

//
protected errorMessages;

//
protected hydrateMode = 0;

//
protected isFresh = true;

//
protected pointer = 0;

//
protected row;

//
protected rows;

/**
 * Phalcon\Db\ResultInterface or false for empty resultset
 */
protected result;

Methods

public function __construct( mixed $result, AdapterInterface $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(): AdapterInterface;
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 ): ModelInterface | bool;
Gets row in a specific position of the resultset

public function offsetSet( mixed $index, mixed $value ): void;
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;
Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

final public function rewind(): void;
Rewinds resultset to its beginning

final public function seek( mixed $position ): void;
Changes the internal pointer to a specific position in the resultset. Set the new position if required, and then set this->row

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;
Sets the hydration mode in the resultset

public function setIsFresh( bool $isFresh ): ResultsetInterface;
Set if the resultset is fresh or an old one cached

public function update( mixed $data, Closure $conditionCallback = null ): bool;
Updates every record in the resultset

public function valid(): bool;
Check whether internal resource has rows to fetch

Class Phalcon\Mvc\Model\Resultset\Complex

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Resultset | | Uses | Phalcon\Cache\Adapter\AdapterInterface, Phalcon\Di, Phalcon\Di\DiInterface, Phalcon\Db\ResultInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface, stdClass | | Extends | Resultset | | Implements | ResultsetInterface |

Phalcon\Mvc\Model\Resultset\Complex

Complex resultsets may include complete objects and scalar values. This class builds every complex row as it is required

Properties

//
protected columnTypes;

/**
 * Unserialised result-set hydrated all rows already. unserialise() sets
 * disableHydration to true
 */
protected disableHydration = false;

Methods

public function __construct( mixed $columnTypes, ResultInterface $result = null, AdapterInterface $cache = null );
Phalcon\Mvc\Model\Resultset\Complex constructor

final public function current(): ModelInterface | bool;
Returns current row in the resultset

public function serialize(): string;
Serializing a resultset will dump all related rows into a big array

public function toArray(): array;
Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.

public function unserialize( mixed $data ): void;
Unserializing a resultset will allow to only works on the rows present in the saved state

Class Phalcon\Mvc\Model\Resultset\Simple

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Resultset | | Uses | Phalcon\Cache\Adapter\AdapterInterface, Phalcon\Di, Phalcon\Di\DiInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface | | Extends | Resultset |

Phalcon\Mvc\Model\Resultset\Simple

Simple resultsets only contains a complete objects This class builds every complete object as it is required

Properties

//
protected columnMap;

//
protected model;

/**
 * @var bool
 */
protected keepSnapshots = false;

Methods

public function __construct( mixed $columnMap, mixed $model, mixed $result, AdapterInterface $cache = null, bool $keepSnapshots = null );
Phalcon\Mvc\Model\Resultset\Simple constructor

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

Interface Phalcon\Mvc\Model\ResultsetInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Closure, Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface, Phalcon\Cache\Adapter\AdapterInterface |

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

Class Phalcon\Mvc\Model\Row

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | ArrayAccess, JsonSerializable, Phalcon\Mvc\EntityInterface, Phalcon\Mvc\ModelInterface | | Implements | EntityInterface, ResultInterface, ArrayAccess, JsonSerializable |

Phalcon\Mvc\Model\Row

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 $index, mixed $value ): void;
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;
Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function readAttribute( string $attribute );
Reads an attribute value by its name

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


public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Set the current object's state

public function toArray(): array;
Returns the instance as an array representation

public function writeAttribute( string $attribute, mixed $value ): void;
Writes an attribute value by its name

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

Class Phalcon\Mvc\Model\Transaction

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Di\DiInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\Failed, Phalcon\Mvc\Model\Transaction\ManagerInterface, Phalcon\Mvc\Model\TransactionInterface | | Implements | TransactionInterface |

Phalcon\Mvc\Model\Transaction

Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. Phalcon\Transaction is intended to be used with Phalcon_Model_Base. Phalcon Transactions should be created using Phalcon\Transaction\Manager.

use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;

try {
    $manager = new Manager();

    $transaction = $manager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

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

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

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

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

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

Properties

//
protected activeTransaction = false;

//
protected connection;

//
protected isNewTransaction = true;

//
protected manager;

//
protected messages;

//
protected rollbackRecord;

//
protected rollbackOnAbort = false;

//
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(): \Phalcon\Db\Adapter\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

Class Phalcon\Mvc\Model\Transaction\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Transaction | | Extends | \Phalcon\Mvc\Model\Exception |

Phalcon\Mvc\Model\Transaction\Exception

Exceptions thrown in Phalcon\Mvc\Model\Transaction will use this class

Class Phalcon\Mvc\Model\Transaction\Failed

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Transaction | | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface | | Extends | Exception |

Phalcon\Mvc\Model\Transaction\Failed

This class will be thrown to exit a try/catch block for isolated transactions

Properties

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

Class Phalcon\Mvc\Model\Transaction\Manager

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Transaction | | Uses | Phalcon\Di, Phalcon\Di\DiInterface, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\Transaction, Phalcon\Mvc\Model\TransactionInterface | | Implements | ManagerInterface, InjectionAwareInterface |

Phalcon\Mvc\Model\Transaction\Manager

A transaction acts on a single database connection. If you have multiple class-specific databases, the transaction will not protect interaction among them.

This class manages the objects that compose a transaction. A transaction produces a unique connection that is passed to every object part of the transaction.

use Phalcon\Mvc\Model\Transaction\Failed;
use Phalcon\Mvc\Model\Transaction\Manager;

try {
   $transactionManager = new Manager();

   $transaction = $transactionManager->get();

   $robot = new Robots();

   $robot->setTransaction($transaction);

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

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

   $robotPart = new RobotParts();

   $robotPart->setTransaction($transaction);

   $robotPart->type = "head";

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

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

Properties

//
protected container;

//
protected initialized = false;

//
protected number = 0;

//
protected rollbackPendent = true;

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

Interface Phalcon\Mvc\Model\Transaction\ManagerInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model\Transaction | | Uses | Phalcon\Mvc\Model\TransactionInterface |

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

Interface Phalcon\Mvc\Model\TransactionInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\ManagerInterface |

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

Class Phalcon\Mvc\Model\ValidationFailed

Source on GitHub

| Namespace | Phalcon\Mvc\Model | | Uses | Phalcon\Mvc\ModelInterface | | Extends | Exception |

Phalcon\Mvc\Model\ValidationFailed

This exception is generated when a model fails to save a record Phalcon\Mvc\Model must be set up to have this behavior

Properties

//
protected messages;

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

Interface Phalcon\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\ResultsetInterface, Phalcon\Mvc\Model\TransactionInterface |

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( mixed $parameters = null ): 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 = null ): ModelInterface;
Assigns values to a model from an array returning a new model

public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );
Returns an hydrated result based on the data and the column map

public static function count( mixed $parameters = null ): int | ResultsetInterface;
Allows to count how many records match the specified conditions

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

public function create(): bool;
Inserts a model instance. If the instance already exists in the persistence it will throw an exception. Returning true on success or false otherwise.

public function delete(): bool;
Deletes a model instance. Returning true on success or false otherwise.

public static function find( mixed $parameters = null ): ResultsetInterface;
Allows to query a set of records that match the specified conditions

public static function findFirst( mixed $parameters = null ): mixed | null;
Allows to query the first record that match the specified conditions

public function fireEvent( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified

public function fireEventCancel( string $eventName ): bool;
Fires an event, implicitly calls behaviors and listeners in the events manager are notified. This method stops if one of the callbacks/listeners returns bool false

public function getDirtyState(): int;
Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not

public function getMessages(): MessageInterface[];
Returns array of validation messages

public function getModelsMetaData(): MetaDataInterface;
Returns the models meta-data service related to the entity instance.

public function getOperationMade(): int;
Returns the type of the latest operation performed by the ORM Returns one of the OP_* class constants

public function getReadConnection(): AdapterInterface;
Gets internal database connection

public function getReadConnectionService(): string;
Returns DependencyInjection connection service used to read data

public function getRelated( string $alias, mixed $arguments = null );
Returns related records based on defined relations

public function getSchema(): string;
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

Interface Phalcon\Mvc\ModuleDefinitionInterface

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Di\DiInterface |

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

Class Phalcon\Mvc\Router

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Http\RequestInterface, Phalcon\Mvc\Router\Exception, Phalcon\Mvc\Router\GroupInterface, Phalcon\Mvc\Router\Route, Phalcon\Mvc\Router\RouteInterface | | Extends | AbstractInjectionAware | | Implements | RouterInterface, EventsAwareInterface |

Phalcon\Mvc\Router

Phalcon\Mvc\Router is the standard framework router. Routing is the process of taking a URI endpoint (that part of the URI which comes after the base URL) and decomposing it into parameters to determine which module, controller, and action of that controller should receive the request

use Phalcon\Mvc\Router;

$router = new Router();

$router->add(
    "/documentation/{chapter}/{name}\.{type:[a-z]+}",
    [
        "controller" => "documentation",
        "action"     => "show",
    ]
);

$router->handle(
    "/documentation/1/examples.html"
);

echo $router->getControllerName();

Constants

const POSITION_FIRST = 0;
const POSITION_LAST = 1;

Properties

//
protected action;

//
protected controller;

//
protected defaultAction;

//
protected defaultController;

//
protected defaultModule;

//
protected defaultNamespace;

//
protected defaultParams;

//
protected eventsManager;

//
protected keyRouteNames;

//
protected keyRouteIds;

//
protected matchedRoute;

//
protected matches;

//
protected module;

//
protected namespaceName;

//
protected notFoundPaths;

//
protected params;

//
protected removeExtraSlashes;

//
protected routes;

//
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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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, mixed $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;
Returns the internal event manager

public function getKeyRouteIds()

public function getKeyRouteNames()


public function getMatchedRoute(): RouteInterface;
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

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( $keyRouteIds )

public function setKeyRouteNames( $keyRouteNames )


public function wasMatched(): bool;
Checks if the router matches any of the defined routes

Class Phalcon\Mvc\Router\Annotations

Source on GitHub

| Namespace | Phalcon\Mvc\Router | | Uses | Phalcon\Di\DiInterface, Phalcon\Mvc\Router, Phalcon\Annotations\Annotation | | Extends | Router |

Phalcon\Mvc\Router\Annotations

A router that reads routes annotations from classes/resources

use Phalcon\Mvc\Router\Annotations;

$di->setShared(
    "router",
    function() {
        // Use the annotations router
        $router = new Annotations(false);

        // This will do the same as above but only if the handled uri starts with /robots
        $router->addResource("Robots", "/robots");

        return $router;
    }
);

Properties

//
protected actionSuffix = Action;

//
protected actionPreformatCallback;

//
protected controllerSuffix = Controller;

//
protected handlers;

//
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 );
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([Text::class, 'uncamelize']);

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

Class Phalcon\Mvc\Router\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\Router | | Extends | \Phalcon\Exception |

Phalcon\Mvc\Router\Exception

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

Class Phalcon\Mvc\Router\Group

Source on GitHub

| Namespace | Phalcon\Mvc\Router | | Implements | GroupInterface |

Phalcon\Mvc\Router\Group

Helper class to create a group of routes with common attributes

$router = new \Phalcon\Mvc\Router();

//Create a group with a common module and controller
$blog = new Group(
    [
        "module"     => "blog",
        "controller" => "index",
    ]
);

//All the routes start with /blog
$blog->setPrefix("/blog");

//Add a route to the group
$blog->add(
    "/save",
    [
        "action" => "save",
    ]
);

//Add another route to the group
$blog->add(
    "/edit/{id}",
    [
        "action" => "edit",
    ]
);

//This route maps to a controller different than the default
$blog->add(
    "/blog",
    [
        "controller" => "about",
        "action"     => "index",
    ]
);

//Add the group to the router
$router->mount($blog);

Properties

//
protected beforeMatch;

//
protected hostname;

//
protected paths;

//
protected prefix;

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

Interface Phalcon\Mvc\Router\GroupInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Router |

Phalcon\Mvc\Router\GroupInterface

$router = new \Phalcon\Mvc\Router();

// Create a group with a common module and controller
$blog = new Group(
    [
        "module"     => "blog",
        "controller" => "index",
    ]
);

// All the routes start with /blog
$blog->setPrefix("/blog");

// Add a route to the group
$blog->add(
    "/save",
    [
        "action" => "save",
    ]
);

// Add another route to the group
$blog->add(
    "/edit/{id}",
    [
        "action" => "edit",
    ]
);

// This route maps to a controller different than the default
$blog->add(
    "/blog",
    [
        "controller" => "about",
        "action"     => "index",
    ]
);

// Add the group to the router
$router->mount($blog);

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

Class Phalcon\Mvc\Router\Route

Source on GitHub

| Namespace | Phalcon\Mvc\Router | | Implements | RouteInterface |

Phalcon\Mvc\Router\Route

This class represents every route added to the router

Properties

//
protected beforeMatch;

//
protected compiledPattern;

//
protected converters;

//
protected group;

//
protected hostname;

//
protected id;

//
protected methods;

//
protected match;

//
protected name;

//
protected paths;

//
protected pattern;

//
protected static uniqueId = 0;

Methods

public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );
Phalcon\Mvc\Router\Route constructor

public function beforeMatch( mixed $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;
Returns the hostname restriction if any

public function getHttpMethods(): array | string;
Returns the HTTP methods that constraint matching the route

public function getId()


public function getMatch(): callable;
Returns the 'match' callback if any

public function getName(): string;
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",
    ]
);

Interface Phalcon\Mvc\Router\RouteInterface

Source on GitHub

| Namespace | Phalcon\Mvc\Router |

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;
Returns the hostname restriction if any

public function getHttpMethods(): string | array;
Returns the HTTP methods that constraint matching the route

public function getName(): string;
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

Interface Phalcon\Mvc\RouterInterface

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Router\GroupInterface |

Interface for Phalcon\Mvc\Router

Methods

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;
Adds a route to the router on any HTTP method

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 (Squid and Varnish support)

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 attach( RouteInterface $route, mixed $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;
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

Class Phalcon\Mvc\View

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Events\ManagerInterface, Phalcon\Helper\Arr, Phalcon\Helper\Str, Phalcon\Mvc\View\Exception, Phalcon\Events\EventsAwareInterface, Phalcon\Mvc\View\Engine\Php | | Extends | Injectable | | Implements | ViewInterface, EventsAwareInterface |

Phalcon\Mvc\View

Phalcon\Mvc\View is a class for working with the "view" portion of the model-view-controller pattern. That is, it exists to help keep the view script separate from the model and controller scripts. It provides a system of helpers, output filters, and variable escaping.

use Phalcon\Mvc\View;

$view = new View();

// Setting views directory
$view->setViewsDir("app/views/");

$view->start();

// Shows recent posts view (app/views/posts/recent.phtml)
$view->render("posts", "recent");
$view->finish();

// Printing views output
echo $view->getContent();

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

//
protected actionName;

//
protected activeRenderPaths;

//
protected basePath = ;

//
protected content = ;

//
protected controllerName;

//
protected currentRenderLevel = 0;

//
protected disabled = false;

//
protected disabledLevels;

//
protected engines = false;

//
protected eventsManager;

//
protected layout;

//
protected layoutsDir = ;

//
protected mainView = index;

//
protected options;

//
protected params;

//
protected pickView;

//
protected partialsDir = ;

//
protected registeredEngines;

//
protected renderLevel = 5;

//
protected templatesAfter;

//
protected templatesBefore;

//
protected viewsDirs;

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

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


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


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


public function getVar( string $key );
Returns a parameter previously set in the view

public function getViewsDir(): string | array;
Gets views directory

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

Abstract Class Phalcon\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

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

Interface Phalcon\Mvc\View\Engine\EngineInterface

Source on GitHub

| Namespace | Phalcon\Mvc\View\Engine |

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

Class Phalcon\Mvc\View\Engine\Php

Source on GitHub

| Namespace | Phalcon\Mvc\View\Engine | | Extends | AbstractEngine |

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

Class Phalcon\Mvc\View\Engine\Volt

Source on GitHub

| Namespace | Phalcon\Mvc\View\Engine | | Uses | Phalcon\Di\DiInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, 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

//
protected compiler;

//
protected eventsManager;

//
protected macros;

//
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 render( string $templatePath, 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

Class Phalcon\Mvc\View\Engine\Volt\Compiler

Source on GitHub

| Namespace | Phalcon\Mvc\View\Engine\Volt | | Uses | Closure, Phalcon\Di\DiInterface, Phalcon\Mvc\ViewBaseInterface, Phalcon\Di\InjectionAwareInterface | | Implements | InjectionAwareInterface |

This class reads and compiles Volt templates into PHP plain code

$compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();

$compiler->compile("views/partials/header.volt");

require $compiler->getCompiledTemplatePath();

Properties

//
protected autoescape = false;

//
protected blockLevel = 0;

//
protected blocks;

//
protected container;

//
protected compiledTemplatePath;

//
protected currentBlock;

//
protected currentPath;

//
protected exprLevel = 0;

//
protected extended = false;

//
protected extensions;

//
protected extendedBlocks;

//
protected filters;

//
protected foreachLevel = 0;

//
protected forElsePointers;

//
protected functions;

//
protected level = 0;

//
protected loopPointers;

//
protected macros;

//
protected options;

//
protected prefix;

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

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 compileCache( array $statement, bool $extendsMode = bool ): string;
Compiles a "cache" statement returning PHP code

@deprecated Will be removed in 5.0 @todo Remove this in the next major version

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

public function compileSet( array $statement ): string;
Compiles a "set" statement returning PHP code

public function compileString( string $viewCode, bool $extendsMode = bool ): string;
Compiles a template into a string

echo $compiler->compileString({% 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 ): string;
Resolves an expression node in an AST volt tree

final public function fireExtensionEvent( string $name, mixed $arguments = null );
Fires an event to registered extensions

public function functionCall( array $expr ): 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 );
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 );
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

Class Phalcon\Mvc\View\Engine\Volt\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\View\Engine\Volt | | Uses | Phalcon\Mvc\View\Exception | | Extends | BaseException |

Class for exceptions thrown by Phalcon\Mvc\View

Properties

//
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).

Class Phalcon\Mvc\View\Exception

Source on GitHub

| Namespace | Phalcon\Mvc\View | | Extends | \Phalcon\Exception |

Phalcon\Mvc\View\Exception

Class for exceptions thrown by Phalcon\Mvc\View

Class Phalcon\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\Helper\Arr, Phalcon\Helper\Str, Phalcon\Mvc\ViewBaseInterface, Phalcon\Mvc\View\Engine\EngineInterface, Phalcon\Mvc\View\Engine\Php | | Extends | Injectable | | Implements | ViewBaseInterface, EventsAwareInterface |

Phalcon\Mvc\View\Simple

This component allows to render views without hierarchical levels

use Phalcon\Mvc\View\Simple as View;

$view = new View();

// Render a view
echo $view->render(
    "templates/my-view",
    [
        "some" => $param,
    ]
);

// Or with filename with extension
echo $view->render(
    "templates/my-view.volt",
    [
        "parameter" => $here,
    ]
);

Properties

//
protected activeRenderPath;

//
protected content;

/**
 * @var \Phalcon\Mvc\View\EngineInterface[]|false
 */
protected engines = false;

//
protected eventsManager;

//
protected options;

//
protected partialsDir;

/**
 * @var array|null
 */
protected registeredEngines;

//
protected viewsDir;

//
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 );
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|null


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 );
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 );
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 );
Sets views directory

final protected function internalRender( string $path, mixed $params );
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

Interface Phalcon\Mvc\ViewBaseInterface

Source on GitHub

| Namespace | Phalcon\Mvc | | Uses | Phalcon\Cache\Adapter\AdapterInterface |

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

Interface Phalcon\Mvc\ViewInterface

Source on GitHub

| Namespace | Phalcon\Mvc | | Extends | ViewBaseInterface |

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