Sections

Class Phalcon\Mvc\Application

Исходный код на 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

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

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

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

Методы

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

Handles a MVC request

public function sendCookiesOnHandleRequest( bool $sendCookies ): Application;

Enables or disables sending cookies by each request handling

public function sendHeadersOnHandleRequest( bool $sendHeaders ): Application;

Enables or disables sending headers by each request handling

public function useImplicitView( bool $implicitView ): Application;

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

Class Phalcon\Mvc\Application\Exception

Исходный код на 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

Исходный код на 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",
            ]
        );
    }
}

Методы

final public function __construct();

Phalcon\Mvc\Controller constructor

Interface Phalcon\Mvc\Controller\BindModelInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Controller

Phalcon\Mvc\Controller\BindModelInterface

Interface for Phalcon\Mvc\Controller

Методы

public static function getModelName(): string;

Return the model name associated with this controller

Interface Phalcon\Mvc\ControllerInterface

Исходный код на GitHub

Namespace Phalcon\Mvc

Phalcon\Mvc\ControllerInterface

Interface for controller handlers

Class Phalcon\Mvc\Dispatcher

Исходный код на 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\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;

Методы

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

Исходный код на 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

Исходный код на GitHub

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

Phalcon\Mvc\DispatcherInterface

Interface for Phalcon\Mvc\Dispatcher

Методы

public function getActiveController(): ControllerInterface;

Returns the active controller in the dispatcher

public function getControllerName(): string;

Gets last dispatched controller name

public function getLastController(): ControllerInterface;

Returns the latest dispatched controller

public function setControllerName( string $controllerName );

Sets the controller name to be dispatched

public function setControllerSuffix( string $controllerSuffix );

Sets the default controller suffix

public function setDefaultController( string $controllerName );

Sets the default controller name

Interface Phalcon\Mvc\EntityInterface

Исходный код на GitHub

Namespace Phalcon\Mvc

Phalcon\Mvc\EntityInterface

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

Методы

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

Reads an attribute value by its name

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

Writes an attribute value by its name

Class Phalcon\Mvc\Micro

Исходный код на 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Методы

public function __construct( DiInterface $container = null );

Phalcon\Mvc\Micro constructor

public function after( mixed $handler ): Micro;

Appends an ‘after’ middleware to be called after execute the route

public function afterBinding( mixed $handler ): Micro;

Appends a afterBinding middleware to be called after model binding

public function before( mixed $handler ): Micro;

Appends a before middleware to be called before execute the route

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

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

public function error( mixed $handler ): Micro;

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

public function finish( mixed $handler ): Micro;

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

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

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

public function getActiveHandler();

Return the handler that will be called for the matched route

public function getBoundModels(): array;

Returns bound models from binder instance

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getHandlers(): array;

Returns the internal handlers attached to the application

public function getModelBinder(): BinderInterface | null;

Gets model binder

public function getReturnedValue();

Returns the value returned by the executed handler

public function getRouter(): RouterInterface;

Returns the internal router used by the application

public function getService( string $serviceName );

Obtains a service from the DI

public function getSharedService( string $serviceName );

Obtains a shared service from the DI

public function handle( string $uri );

Handle the whole request

public function hasService( string $serviceName ): bool;

Checks if a service is registered in the DI

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

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

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

Maps a route to a handler without any HTTP method constraint

public function mount( CollectionInterface $collection ): Micro;

Mounts a collection of handlers

public function notFound( mixed $handler ): Micro;

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

public function offsetExists( mixed $offset ): bool;

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

public function offsetGet( mixed $offset ): mixed;

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

var_dump(
    $app["request"]
);
public function offsetSet( mixed $offset, mixed $value ): void;

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

   $app["request"] = new \Phalcon\Http\Request();
public function offsetUnset( mixed $offset ): void;

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

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

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

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

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

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

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

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

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

public function setActiveHandler( mixed $activeHandler );

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

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

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

Sets model binder

$micro = new Micro($di);

$micro->setModelBinder(
    new Binder(),
    'cache'
);
public function setResponseHandler( mixed $handler ): Micro;

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

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

Sets a service from the DI

public function stop();

Stops the middleware execution avoiding than other middlewares be executed

Class Phalcon\Mvc\Micro\Collection

Исходный код на 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

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

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

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

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

Методы

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

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

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

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

public function getHandler(): mixed;

Returns the main handler

public function getHandlers(): array;

Returns the registered handlers

public function getPrefix(): string;

Returns the collection prefix if any

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

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

public function isLazy(): bool;

Returns if the main handler must be lazy loaded

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

Maps a route to a handler.

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

Maps a route to a handler via methods.

$collection->mapVia(
    "/test",
    "indexAction",
    ["POST", "GET"],
    "test"
);
public function options( string $routePattern, callable $handler, string $name = null ): CollectionInterface;

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

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

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

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

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

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

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

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

Sets the main handler.

public function setLazy( bool $lazy ): CollectionInterface;

Sets if the main handler must be lazy loaded

public function setPrefix( string $prefix ): CollectionInterface;

Sets a prefix for all routes added to the collection

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

Internal function to add a handler to the group.

Interface Phalcon\Mvc\Micro\CollectionInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Micro

Phalcon\Mvc\Micro\CollectionInterface

Interface for Phalcon\Mvc\Micro\Collection

Методы

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

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

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

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

public function getHandler(): mixed;

Returns the main handler

public function getHandlers(): array;

Returns the registered handlers

public function getPrefix(): string;

Returns the collection prefix if any

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

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

public function isLazy(): bool;

Returns if the main handler must be lazy loaded

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

Maps a route to a handler

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

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

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

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

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

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

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

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

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

Sets the main handler

public function setLazy( bool $lazy ): CollectionInterface;

Sets if the main handler must be lazy loaded

public function setPrefix( string $prefix ): CollectionInterface;

Sets a prefix for all routes added to the collection

Class Phalcon\Mvc\Micro\Exception

Исходный код на GitHub

Namespace Phalcon\Mvc\Micro   Extends \Exception

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

Class Phalcon\Mvc\Micro\LazyLoader

Исходный код на 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

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

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

Методы

public function __construct( string $definition );

Phalcon\Mvc\Micro\LazyLoader constructor

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

Calling __call method

public function getDefinition(): string;
public function getHandler(): object | null;

Interface Phalcon\Mvc\Micro\MiddlewareInterface

Исходный код на GitHub

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

Allows to implement Phalcon\Mvc\Micro middleware in classes

Методы

public function call( Micro $application );

Calls the middleware

Abstract Class Phalcon\Mvc\Model

Исходный код на GitHub

Namespace Phalcon\Mvc   Uses JsonSerializable, Phalcon\Db\Adapter\AdapterInterface, Phalcon\Db\Column, Phalcon\Db\DialectInterface, Phalcon\Db\Enum, Phalcon\Db\RawValue, Phalcon\Di\AbstractInjectionAware, Phalcon\Di\Di, Phalcon\Di\DiInterface, Phalcon\Events\ManagerInterface, Phalcon\Messages\Message, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model\BehaviorInterface, Phalcon\Mvc\Model\Criteria, Phalcon\Mvc\Model\CriteriaInterface, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\ManagerInterface, Phalcon\Mvc\Model\MetaDataInterface, Phalcon\Mvc\Model\Query, Phalcon\Mvc\Model\Query\Builder, Phalcon\Mvc\Model\Query\BuilderInterface, Phalcon\Mvc\Model\QueryInterface, Phalcon\Mvc\Model\ResultInterface, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Relation, Phalcon\Mvc\Model\RelationInterface, Phalcon\Mvc\Model\TransactionInterface, Phalcon\Mvc\Model\ValidationFailed, Phalcon\Mvc\ModelInterface, Phalcon\Filter\Validation\ValidationInterface, Serializable   Extends AbstractInjectionAware   Implements EntityInterface, ModelInterface, ResultInterface, Serializable, JsonSerializable

Phalcon\Mvc\Model

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

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

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

$robot = new Robots();

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

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

    $messages = $robot->getMessages();

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

Константы

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

Properties

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @var array|null
 * TODO: Make it always array in code
 */
protected uniqueTypes;

Методы

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

Handles method calls when a method is not implemented

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

Handles method calls when a static method is not implemented

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

Phalcon\Mvc\Model constructor

public function __get( string $property );

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

public function __isset( string $property ): bool;

Magic method to check if a property is a valid relation

public function __serialize(): array;

Serializes a model

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

Magic method to assign values to the the model

public function __unserialize( array $data ): void;

Unserializes an array to the model

public function addBehavior( BehaviorInterface $behavior ): void;

Setups a behavior in a model

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

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

        $this->addBehavior(
            new Timestampable(
                [
                    "beforeUpdate" => [
                        "field"  => "updated_at",
                        "format" => "Y-m-d",
                    ],
                ]
            )
        );
    }
}
public function appendMessage( MessageInterface $message ): ModelInterface;

Appends a customized message on the validation process

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

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

            $this->appendMessage($message);
        }
    }
}
public function assign( array $data, mixed $whiteList = null, mixed $dataColumnMap = null ): ModelInterface;

Assigns values to a model from an array

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

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

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

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

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

$robot->assign(
    $_POST,
    [
        "name",
        "year",
    ]
);
public static function average( array $parameters = [] ): double | ResultsetInterface;

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

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

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

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

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

echo "The average price of mechanical robots is ", $average, "\n";
public static function cloneResult( ModelInterface $base, array $data, int $dirtyState = int ): ModelInterface;

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

$robot = Phalcon\Mvc\Model::cloneResult(
    new Robots(),
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);
public static function cloneResultMap( mixed $base, array $data, mixed $columnMap, int $dirtyState = int, bool $keepSnapshots = null ): ModelInterface;

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

$robot = \Phalcon\Mvc\Model::cloneResultMap(
    new Robots(),
    [
        "type" => "mechanical",
        "name" => "Astro Boy",
        "year" => 1952,
    ]
);
public static function cloneResultMapHydrate( array $data, mixed $columnMap, int $hydrationMode );

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

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

Counts how many records match the specified conditions.

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

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

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

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

echo "There are ", $number, " mechanical robots\n";
public function create(): bool;

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

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

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

$robot->create();

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

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

$robot->create();
public function delete(): bool;

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

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

$robot->delete();

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

foreach ($robots as $robot) {
    $robot->delete();
}
public function dump(): array;

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

var_dump(
    $robot->dump()
);
public static function find( mixed $parameters = null ): ResultsetInterface;

Query for a set of records that match the specified conditions

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

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

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

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

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

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

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

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

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

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

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

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

$newRobot->save();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$transaction1->rollback();
$transaction2->rollback();
public static function findFirst( mixed $parameters = null ): mixed | null;

Query the first record that matches the specified conditions

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

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

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

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

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

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

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

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

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

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

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

$transaction->commit();

$doesFindTheRobotNow = Robot::findFirst(
    [
        'name' => 'test',
    ]
);
public function fireEvent( string $eventName ): bool;

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

public function fireEventCancel( string $eventName ): bool;

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

public function getChangedFields(): array;

Returns a list of changed values.

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

$robots->deleted = 'Y';

$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]
public function getDirtyState(): int;

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

public function getEventsManager(): EventsManagerInterface | null;

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

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

Returns array of validation messages

$robot = new Robots();

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

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

    $messages = $robot->getMessages();

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

Returns the models manager related to the entity instance

public function getModelsMetaData(): MetaDataInterface;

{@inheritdoc}

public function getOldSnapshotData(): array;

Returns the internal old snapshot data

public function getOperationMade(): int;

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

final public function getReadConnection(): AdapterInterface;

Gets the connection used to read data for the model

final public function getReadConnectionService(): string;

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

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

Returns related records based on defined relations

final public function getSchema(): string | null;

Returns schema name where the mapped table is located

public function getSnapshotData(): array;

Returns the internal snapshot data

final public function getSource(): string;

Returns the table name mapped in the model

public function getTransaction(): TransactionInterface | null;
public function getUpdatedFields(): array;

Returns a list of updated values.

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

$robots->deleted = 'Y';

$robots->getChangedFields();
print_r($robots->getChangedFields()); // ["deleted"]
$robots->save();
print_r($robots->getChangedFields()); // []
print_r($robots->getUpdatedFields()); // ["deleted"]
final public function getWriteConnection(): AdapterInterface;

Gets the connection used to write data to the model

final public function getWriteConnectionService(): string;

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

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

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

$robot = new Robots();

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

$robot->create();

$robot->type = "hydraulic";

$hasChanged = $robot->hasChanged("type"); // returns true
$hasChanged = $robot->hasChanged(["type", "name"]); // returns true
$hasChanged = $robot->hasChanged(["type", "name"], true); // returns false
public function hasSnapshotData(): bool;

Checks if the object has internal snapshot data

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

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

public function isRelationshipLoaded( string $relationshipAlias ): bool;

Checks if saved related records have already been loaded.

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

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

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

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

$robot->robotsParts = [new RobotsParts()];
var_dump($robot->isRelationshipLoaded('robotsParts')); // false
public function jsonSerialize(): array;

Serializes the object for json_encode

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

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

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

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

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

echo "The maximum robot id of mechanical robots is ", $id, "\n";
public static function minimum( mixed $parameters = null ): mixed;

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

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

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

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

echo "The minimum robot id of mechanical robots is ", $id;
public static function query( DiInterface $container = null ): CriteriaInterface;

Create a criteria for a specific model

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

Reads an attribute value by its name

echo $robot->readAttribute("name");
public function refresh(): ModelInterface;

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

public function save(): bool;

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

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

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

$robot->save();

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

$robot->name = "Biomass";

$robot->save();
public function serialize(): string;

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

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

Sets the DependencyInjection connection service name

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

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

public function setEventsManager( EventsManagerInterface $eventsManager );

Sets a custom events manager

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

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

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

Sets the DependencyInjection connection service name used to read data

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

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

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Sets a transaction related to the Model instance

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

try {
    $txManager = new TxManager();

    $transaction = $txManager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

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

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

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

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

    $transaction->commit();
} catch (TxFailed $e) {
    echo "Failed, reason: ", $e->getMessage();
}
final public function setWriteConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service name used to write data

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

Enables/disables options in the ORM

public function skipOperation( bool $skip ): void;

Skips the current operation forcing a success state

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

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

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

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

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

echo "The total price of mechanical robots is  ", $sum, "\n";
public function toArray( mixed $columns = null ): array;

Returns the instance as an array representation

print_r(
    $robot->toArray()
);
public function unserialize( mixed $data );

Unserializes the object from a serialized string

public function update(): bool;

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

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

$robot->name = "Biomass";

$robot->update();
public function validationHasFailed(): bool;

Check whether validation process has generated any messages

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

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

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

        return $this->validate($validator);
    }
}
public function writeAttribute( string $attribute, mixed $value ): void;

Writes an attribute value by its name

$robot->writeAttribute("name", "Rosey");
protected function allowEmptyStringValues( array $attributes ): void;

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

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->allowEmptyStringValues(
            [
                "name",
            ]
        );
    }
}
protected function belongsTo( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

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

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

Cancel the current operation

final protected function checkForeignKeysRestrict(): bool;

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

final protected function checkForeignKeysReverseCascade(): bool;

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

final protected function checkForeignKeysReverseRestrict(): bool;

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

protected function collectRelatedToSave(): array;

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

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

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

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

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

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

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

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

Generate a PHQL SELECT statement for an aggregate

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

Checks whether the current record already exists

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

Setup a 1-n relation between two models

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->hasMany(
            "id",
            RobotsParts::class,
            "robots_id"
        );
    }
}
protected function hasManyToMany( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

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

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        // Setup a many-to-many relation to Parts through RobotsParts
        $this->hasManyToMany(
            "id",
            RobotsParts::class,
            "robots_id",
            "parts_id",
            Parts::class,
            "id",
        );
    }
}
protected function hasOne( mixed $fields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

Setup a 1-1 relation between two models

class Robots extends \Phalcon\Mvc\Model
{
    public function initialize()
    {
        $this->hasOne(
            "id",
            RobotsDescription::class,
            "robots_id"
        );
    }
}
protected function hasOneThrough( mixed $fields, string $intermediateModel, mixed $intermediateFields, mixed $intermediateReferencedFields, string $referenceModel, mixed $referencedFields, array $options = [] ): Relation;

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

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

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

use Phalcon\Mvc\Model;

class Robots extends Model
{
    public function initialize()
    {
        $this->keepSnapshots(true);
    }
}
final protected function possibleSetter( string $property, mixed $value ): bool;

Check for, and attempt to use, possible setter.

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

Executes internal events after save a record

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

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

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

Executes internal hooks before save a record

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

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

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

Sets schema name where the mapped table is located

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

Sets the table name to which model should be mapped

protected function skipAttributes( array $attributes ): void;

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

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

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

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

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

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

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

use Phalcon\Mvc\Model;

class Robots extends Model
{
    public function initialize()
    {
        $this->useDynamicUpdate(true);
    }
}
protected function validate( ValidationInterface $validator ): bool;

Executes validators on every validation call

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

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

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

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

Abstract Class Phalcon\Mvc\Model\Behavior

Исходный код на 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;

Методы

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

Исходный код на 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

Методы

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

Listens for notifications from the models manager

Class Phalcon\Mvc\Model\Behavior\Timestampable

Исходный код на 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

Методы

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

Listens for notifications from the models manager

Interface Phalcon\Mvc\Model\BehaviorInterface

Исходный код на GitHub

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

Phalcon\Mvc\Model\BehaviorInterface

Interface for Phalcon\Mvc\Model\Behavior

Методы

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

Calls a method when it’s missing in the model

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

This method receives the notifications from the EventsManager

Class Phalcon\Mvc\Model\Binder

Исходный код на 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
 *
 * @var AdapterInterface|null
 */
protected cache;

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

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

Методы

public function __construct( AdapterInterface $cache = null );

Phalcon\Mvc\Model\Binder constructor

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

Bind models into params in proper handler

public function getBoundModels(): array;

Return the active bound models

public function getCache(): AdapterInterface;

Sets cache instance

public function getOriginalValues(): array;

Return the array for original values

public function setCache( AdapterInterface $cache ): BinderInterface;

Gets cache instance

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

Find the model by param value.

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

Get params classes from cache by key

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

Get modified params for handler using reflection

Interface Phalcon\Mvc\Model\Binder\BindableInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Model\Binder

Phalcon\Mvc\Model\Binder\BindableInterface

Interface for bindable classes

Методы

public function getModelName(): string | array;

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

Interface Phalcon\Mvc\Model\BinderInterface

Исходный код на GitHub

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

Phalcon\Mvc\Model\BinderInterface

Interface for Phalcon\Mvc\Model\Binder

Методы

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

Bind models into params in proper handler

public function getBoundModels(): array;

Gets active bound models

public function getCache(): AdapterInterface;

Gets cache instance

public function setCache( AdapterInterface $cache ): BinderInterface;

Sets cache instance

Class Phalcon\Mvc\Model\Criteria

Исходный код на GitHub

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

Phalcon\Mvc\Model\Criteria

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

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

Properties

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

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

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

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

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

Методы

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

Appends a condition to the current conditions using an AND operator

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

Appends a BETWEEN condition to the current conditions

$criteria->betweenWhere("price", 100.25, 200.50);
public function bind( array $bindParams, bool $merge = bool ): CriteriaInterface;

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

public function bindTypes( array $bindTypes ): CriteriaInterface;

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

public function cache( array $cache ): CriteriaInterface;

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

public function columns( mixed $columns ): CriteriaInterface;

Sets the columns to be queried

$criteria->columns(
    [
        "id",
        "name",
    ]
);
public function conditions( string $conditions ): CriteriaInterface;

Adds the conditions parameter to the criteria

public function createBuilder(): BuilderInterface;

Creates a query builder from criteria.

$builder = Robots::query()
    ->where("type = :type:")
    ->bind(["type" => "mechanical"])
    ->createBuilder();
public function distinct( mixed $distinct ): CriteriaInterface;

Sets SELECT DISTINCT / SELECT ALL flag

public function execute(): ResultsetInterface;

Executes a find using the parameters built with the criteria

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

Adds the “for_update” parameter to the criteria

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

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

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

Returns the columns to be queried

public function getConditions(): string | null;

Returns the conditions parameter in the criteria

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getGroupBy();

Returns the group clause in the criteria

public function getHaving();

Returns the having clause in the criteria

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

Returns the limit parameter in the criteria, which will be

  • 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

Исходный код на GitHub

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

Phalcon\Mvc\Model\CriteriaInterface

Interface for Phalcon\Mvc\Model\Criteria

Методы

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

Appends a condition to the current conditions using an AND operator

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

Appends a BETWEEN condition to the current conditions

$criteria->betweenWhere("price", 100.25, 200.50);
public function bind( array $bindParams ): CriteriaInterface;

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

public function bindTypes( array $bindTypes ): CriteriaInterface;

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

public function cache( array $cache ): CriteriaInterface;

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

public function conditions( string $conditions ): CriteriaInterface;

Adds the conditions parameter to the criteria

public function distinct( mixed $distinct ): CriteriaInterface;

Sets SELECT DISTINCT / SELECT ALL flag

public function execute(): ResultsetInterface;

Executes a find using the parameters built with the criteria

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

Sets the “for_update” parameter to the criteria

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

Returns the columns to be queried

public function getConditions(): string | null;

Returns the conditions parameter in the criteria

public function getGroupBy();

Returns the group clause in the criteria

public function getHaving();

Returns the having clause in the criteria

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

Returns the limit parameter in the criteria, which will be

  • 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

Исходный код на GitHub

Namespace Phalcon\Mvc\Model   Extends \Exception

Phalcon\Mvc\Model\Exception

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

Class Phalcon\Mvc\Model\Manager

Исходный код на GitHub

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

Phalcon\Mvc\Model\Manager

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

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

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

$di = new Di();

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

$robot = new Robots($di);

Properties

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Методы

public function __destruct();

Destroys the current PHQL cache

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

Binds a behavior to a model

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

Setup a relation reverse many to one between two models

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

Setup a relation 1-n between two models

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

Setups a relation n-m between two models

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

Setup a 1-1 relation between two models

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

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

public function clearReusableObjects(): void;

Clears the internal reusable list

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

Creates a Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

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

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

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

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

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

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

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

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

// \Phalcon\Mvc\Model\Query\StatusInterface
$manager->executeQuery('DELETE FROM Robots WHERE id = :id:', ['id' => 1]);
public function existsBelongsTo( string $modelName, string $modelRelation ): bool;

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

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

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

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

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

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

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

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

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

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

Gets all the belongsTo relations defined in a model

$relations = $modelsManager->getBelongsTo(
    new Robots()
);
public function getBelongsToRecords( string $modelName, string $modelRelation, ModelInterface $record, mixed $parameters = null, string $method = null ): ResultsetInterface | bool;

Gets belongsTo related records from a model

public function getBuilder(): BuilderInterface | null;

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

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

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

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

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

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getEventsManager(): EventsManagerInterface | null;

Returns the internal event manager

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

Gets hasMany relations defined on a model

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

Gets hasMany related records from a model

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

Gets hasManyToMany relations defined on a model

public function getHasOne( ModelInterface $model ): array;

Gets hasOne relations defined on a model

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

Gets hasOne relations defined on a model

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

Gets belongsTo related records from a model

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

Gets hasOneThrough relations defined on a model

public function getLastInitialized(): ModelInterface;

Get last initialized model

public function getLastQuery(): QueryInterface;

Returns the last query created or executed in the models manager

public function getModelPrefix(): string;

Returns the prefix for all model sources.

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

Returns the mapped schema for a model

public function getModelSource( ModelInterface $model ): string;

Returns the mapped source for a model

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to read data related to a model

public function getReadConnectionService( ModelInterface $model ): string;

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

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

Returns a relation by its alias

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

Helper method to query records based on a relation definition

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

Query all the relationships defined on a model

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

Query the first relationship defined between two models

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

Returns a reusable object from the internal list

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to write data related to a model

public function getWriteConnectionService( ModelInterface $model ): string;

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

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

Checks whether a model has a belongsTo relation with another model

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

Checks whether a model has a hasMany relation with another model

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

Checks whether a model has a hasManyToMany relation with another model

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

Checks whether a model has a hasOne relation with another model

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

Checks whether a model has a hasOneThrough relation with another model

public function initialize( ModelInterface $model ): bool;

Initializes a model in the model manager

public function isInitialized( string $className ): bool;

Check whether a model is already initialized

public function isKeepingSnapshots( ModelInterface $model ): bool;

Checks if a model is keeping snapshots for the queried records

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

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

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

Check whether a model property is declared as public.

$isPublic = $manager->isVisibleModelProperty(
    new Robots(),
    "name"
);
public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;

Sets if a model must keep snapshots

public function load( string $modelName ): ModelInterface;

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

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

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

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

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

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

Sets both write and read connection service for a model

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

Sets a custom events manager for a specific model

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function setEventsManager( EventsManagerInterface $eventsManager ): void;

Sets a global events manager

public function setModelPrefix( string $prefix ): void;

Sets the prefix for all model sources.

use Phalcon\Mvc\Model\Manager;

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

        $modelsManager->setModelPrefix("wp_");

        return $modelsManager;
    }
);

$robots = new Robots();

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

$param string $prefix

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

Sets the mapped schema for a model

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

Sets the mapped source for a model

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

Sets read connection service for a model

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

Stores a reusable record in the internal list

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

Sets write connection service for a model

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

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

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

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

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

Merge two arrays of find parameters

Interface Phalcon\Mvc\Model\ManagerInterface

Исходный код на 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

Методы

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

Binds a behavior to a model

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

Setup a relation reverse 1-1 between two models

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

Setup a relation 1-n between two models

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

Setups a relation n-m between two models

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

Setup a 1-1 relation between two models

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

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

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

Creates a Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

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

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

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

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

Gets belongsTo relations defined on a model

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

Gets belongsTo related records from a model

public function getBuilder(): BuilderInterface | null;

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

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

Gets hasMany relations defined on a model

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

Gets hasMany related records from a model

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

Gets hasManyToMany relations defined on a model

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

Gets hasOne relations defined on a model

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

Gets hasOne relations defined on a model

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

Gets hasOne related records from a model

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

Gets hasOneThrough relations defined on a model

public function getLastInitialized(): ModelInterface;

Get last initialized model

public function getLastQuery(): QueryInterface;

Returns the last query created or executed in the models manager

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

Returns the mapped schema for a model

public function getModelSource( ModelInterface $model ): string;

Returns the mapped source for a model

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to read data related to a model

public function getReadConnectionService( ModelInterface $model ): string;

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

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

Returns a relation by its alias

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

Helper method to query records based on a relation definition

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

Query all the relationships defined on a model

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

Query the relations between two models

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Returns the connection to write data related to a model

public function getWriteConnectionService( ModelInterface $model ): string;

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

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

Checks whether a model has a belongsTo relation with another model

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

Checks whether a model has a hasMany relation with another model

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

Checks whether a model has a hasManyToMany relation with another model

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

Checks whether a model has a hasOne relation with another model

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

Checks whether a model has a hasOneThrough relation with another model

public function initialize( ModelInterface $model );

Initializes a model in the model manager

public function isInitialized( string $className ): bool;

Check of a model is already initialized

public function isKeepingSnapshots( ModelInterface $model ): bool;

Checks if a model is keeping snapshots for the queried records

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

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

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

Check whether a model property is declared as public.

$isPublic = $manager->isVisibleModelProperty(
    new Robots(),
    "name"
);
public function keepSnapshots( ModelInterface $model, bool $keepSnapshots ): void;

Sets if a model must keep snapshots

public function load( string $modelName ): ModelInterface;

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

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

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

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

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

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

Sets both write and read connection service for a model

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

Sets the mapped schema for a model

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

Sets the mapped source for a model

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

Sets read connection service for a model

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

Sets write connection service for a model

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

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

Abstract Class Phalcon\Mvc\Model\MetaData

Исходный код на 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);

Константы

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

Properties

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

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

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

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

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

Методы

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",
        ]
    )
);
protected function getArrVal( array $collection, mixed $index, mixed $defaultValue = null ): mixed;

@todo Remove this when we get traits

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

Initialize the metadata for certain table

Class Phalcon\Mvc\Model\MetaData\Apcu

Исходный код на GitHub

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

Phalcon\Mvc\Model\MetaData\Apcu

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

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

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

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

Методы

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

Phalcon\Mvc\Model\MetaData\Apcu constructor

Class Phalcon\Mvc\Model\MetaData\Libmemcached

Исходный код на GitHub

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

Phalcon\Mvc\Model\MetaData\Libmemcached

Stores model meta-data in the Memcache.

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

Методы

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

Phalcon\Mvc\Model\MetaData\Libmemcached constructor

public function reset(): void;

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

Class Phalcon\Mvc\Model\MetaData\Memory

Исходный код на 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

Методы

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

Исходный код на GitHub

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

Phalcon\Mvc\Model\MetaData\Redis

Stores model meta-data in the Redis.

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

use Phalcon\Mvc\Model\MetaData\Redis;

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

Методы

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

Phalcon\Mvc\Model\MetaData\Redis constructor

public function reset(): void;

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

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

Исходный код на 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 [email protected]

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

Методы

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

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

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

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

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

Исходный код на 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

Методы

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

Исходный код на 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 [email protected]

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

Методы

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

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

@todo Not implemented

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

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

Class Phalcon\Mvc\Model\MetaData\Stream

Исходный код на 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

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

Методы

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

Phalcon\Mvc\Model\MetaData\Files constructor

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

Reads meta-data from files

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

Writes the meta-data to files

Interface Phalcon\Mvc\Model\MetaDataInterface

Исходный код на 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

Методы

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

Исходный код на GitHub

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

Phalcon\Mvc\Model\Query

This class takes a PHQL intermediate representation and executes it.

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

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

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

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

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

$phql = 'SELECTFROM robot';

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

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

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

$resultWithEntries = $queryWithTransaction->execute();

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

Константы

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

Properties

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Методы

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

Phalcon\Mvc\Model\Query constructor

public function cache( array $cacheOptions ): QueryInterface;

Sets the cache parameters of the query

public static function clean(): void;

Destroys the internal PHQL cache

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

Executes a parsed PHQL statement

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getCache(): AdapterInterface;

Returns the current cache backend instance

public function getCacheOptions(): array;

Returns the current cache options

public function getDI(): DiInterface;

Returns the dependency injection container

public function getIntermediate(): array;

Returns the intermediate representation of the PHQL statement

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

Executes the query returning the first result

public function getSql(): array;

Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)

public function getTransaction(): TransactionInterface | null;
public function getType(): int;

Gets the type of PHQL statement executed

public function getUniqueRow(): bool;

Check if the query is programmed to get only the first row in the resultset

public function parse(): array;

Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query

public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setDI( DiInterface $container ): void;

Sets the dependency injection container

public function setIntermediate( array $intermediate ): QueryInterface;

Allows to set the IR to be executed

public function setSharedLock( bool $sharedLock = bool ): QueryInterface;

Set SHARED LOCK clause

public function setTransaction( TransactionInterface $transaction ): QueryInterface;

allows to wrap a transaction around all queries

public function setType( int $type ): QueryInterface;

Sets the type of PHQL statement to be executed

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Tells to the query if only the first row in the resultset must be returned

final protected function _prepareDelete(): array;

Analyzes a DELETE intermediate code and produces an array to be executed later

final protected function _prepareInsert(): array;

Analyzes an INSERT intermediate code and produces an array to be executed later

final protected function _prepareSelect( mixed $ast = null, bool $merge = bool ): array;

Analyzes a SELECT intermediate code and produces an array to be executed later

final protected function _prepareUpdate(): array;

Analyzes an UPDATE intermediate code and produces an array to be executed later

final protected function executeDelete( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function executeInsert( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function executeSelect( array $intermediate, array $bindParams, array $bindTypes, bool $simulate = bool ): ResultsetInterface | array;

Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset

final protected function executeUpdate( array $intermediate, array $bindParams, array $bindTypes ): StatusInterface;

Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status

final protected function getCallArgument( array $argument ): array;

Resolves an expression in a single call argument

final protected function getCaseExpression( array $expr ): array;

Resolves an expression in a single call argument

final protected function getExpression( array $expr, bool $quoting = bool ): array;

Resolves an expression from its intermediate code into an array

final protected function getFunctionCall( array $expr ): array;

Resolves an expression in a single call argument

final protected function getGroupClause( array $group ): array;

Returns a processed group clause for a SELECT statement

final protected function getJoin( ManagerInterface $manager, array $join ): array;

Resolves a JOIN clause checking if the associated models exist

final protected function getJoinType( array $join ): string;

Resolves a JOIN type

final protected function getJoins( array $select ): array;

Processes the JOINs in the query returning an internal representation for the database dialect

final protected function getLimitClause( array $limitClause ): array;

Returns a processed limit clause for a SELECT statement

final protected function getMultiJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;

Resolves joins involving many-to-many relations

final protected function getOrderClause( mixed $order ): array;

Returns a processed order clause for a SELECT statement

final protected function getQualified( array $expr ): array;

Replaces the model’s name to its source name in a qualified-name expression

protected function getReadConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;

Gets the read connection from the model if there is no transaction set inside the query object

final protected function getRelatedRecords( ModelInterface $model, array $intermediate, array $bindParams, array $bindTypes ): ResultsetInterface;

Query the records on which the UPDATE/DELETE operation will be done

final protected function getSelectColumn( array $column ): array;

Resolves a column from its intermediate representation into an array used to determine if the resultset produced is simple or complex

final protected function getSingleJoin( string $joinType, mixed $joinSource, string $modelAlias, string $joinAlias, RelationInterface $relation ): array;

Resolves joins involving has-one/belongs-to/has-many relations

final protected function getTable( ManagerInterface $manager, array $qualifiedName );

Resolves a table in a SELECT statement checking if the model exists

protected function getWriteConnection( ModelInterface $model, array $intermediate = null, array $bindParams = [], array $bindTypes = [] ): AdapterInterface;

Gets the write connection from the model if there is no transaction inside the query object

Class Phalcon\Mvc\Model\Query\Builder

Исходный код на GitHub

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

Phalcon\Mvc\Model\Query\Builder

Helps to create PHQL queries using an OO interface

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

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

Properties

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

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

/**
 * @var array|string|null
 */
protected columns;

/**
 * @var array|string|null
 */
protected conditions;

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

/**
 * @var mixed
 */
protected distinct;

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

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

/**
 * @var string|null
 */
protected having;

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

/**
 * @var array
 */
protected joins;

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

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

/**
 * @var int
 */
protected offset = 0;

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

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

Методы

public function __construct( mixed $params = null, DiInterface $container = null );

Phalcon\Mvc\Model\Query\Builder constructor

public function addFrom( string $model, string $alias = null ): BuilderInterface;

Add a model to take part of the query

// Load data from models Robots
$builder->addFrom(
    Robots::class
);

// Load data from model 'Robots' using 'r' as alias in PHQL
$builder->addFrom(
    Robots::class,
    "r"
);
public function andHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current HAVING conditions clause using a AND operator

$builder->andHaving("SUM(Robots.price) > 0");

$builder->andHaving(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);
public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current WHERE conditions using a AND operator

$builder->andWhere("name = 'Peter'");

$builder->andWhere(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);
final public function autoescape( string $identifier ): string;

Automatically escapes identifiers but only if they need to be escaped.

public function betweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current HAVING conditions clause

$builder->betweenHaving("SUM(Robots.price)", 100.25, 200.50);
public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current WHERE conditions

$builder->betweenWhere("price", 100.25, 200.50);
public function columns( mixed $columns ): BuilderInterface;

Sets the columns to be queried

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

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

$builder->columns(
    [
        "name",
        "number" => "COUNT(*)",
    ]
);
public function distinct( mixed $distinct ): BuilderInterface;

Sets SELECT DISTINCT / SELECT ALL flag

$builder->distinct("status");
$builder->distinct(null);
public function forUpdate( bool $forUpdate ): BuilderInterface;

Sets a FOR UPDATE clause

$builder->forUpdate(true);
public function from( mixed $models ): BuilderInterface;

Sets the models who makes part of the query

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

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

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

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getColumns();

Return the columns to be queried

public function getDI(): DiInterface;

Returns the DependencyInjector container

public function getDistinct(): bool;

Returns SELECT DISTINCT / SELECT ALL flag

public function getFrom();

Return the models who makes part of the query

public function getGroupBy(): array;

Returns the GROUP BY clause

public function getHaving(): string;

Return the current having clause

public function getJoins(): array;

Return join parts of the query

public function getLimit();

Returns the current LIMIT clause

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

Returns the models involved in the query

public function getOffset(): int;

Returns the current OFFSET clause

public function getOrderBy();

Returns the set ORDER BY clause

final public function getPhql(): string;

Returns a PHQL statement built based on the builder parameters

public function getQuery(): QueryInterface;

Returns the query built

public function getWhere();

Return the conditions for the query

public function groupBy( mixed $group ): BuilderInterface;

Sets a GROUP BY clause

$builder->groupBy(
    [
        "Robots.name",
    ]
);
public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets the HAVING condition clause

$builder->having("SUM(Robots.price) > 0");

$builder->having(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);
public function inHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current HAVING conditions clause

$builder->inHaving("SUM(Robots.price)", [100, 200]);
public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current WHERE conditions

$builder->inWhere(
    "id",
    [1, 2, 3]
);
public function innerJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds an INNER join to the query

// Inner Join model 'Robots' with automatic conditions and alias
$builder->innerJoin(
    Robots::class
);

// Inner Join model 'Robots' specifying conditions
$builder->innerJoin(
    Robots::class,
    "Robots.id = RobotsParts.robots_id"
);

// Inner Join model 'Robots' specifying conditions and alias
$builder->innerJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function join( string $model, string $conditions = null, string $alias = null, string $type = null ): BuilderInterface;

Adds an :type: join (by default type - INNER) to the query

// Inner Join model 'Robots' with automatic conditions and alias
$builder->join(
    Robots::class
);

// Inner Join model 'Robots' specifying conditions
$builder->join(
    Robots::class,
    "Robots.id = RobotsParts.robots_id"
);

// Inner Join model 'Robots' specifying conditions and alias
$builder->join(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);

// Left Join model 'Robots' specifying conditions, alias and type of join
$builder->join(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r",
    "LEFT"
);
public function leftJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a LEFT join to the query

$builder->leftJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function limit( int $limit, mixed $offset = null ): BuilderInterface;

Sets a LIMIT clause, optionally an offset clause

$builder->limit(100);
$builder->limit(100, 20);
$builder->limit("100", "20");
public function notBetweenHaving( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current HAVING conditions clause

$builder->notBetweenHaving("SUM(Robots.price)", 100.25, 200.50);
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current WHERE conditions

$builder->notBetweenWhere("price", 100.25, 200.50);
public function notInHaving( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current HAVING conditions clause

$builder->notInHaving("SUM(Robots.price)", [100, 200]);
public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current WHERE conditions

$builder->notInWhere("id", [1, 2, 3]);
public function offset( int $offset ): BuilderInterface;

Sets an OFFSET clause

$builder->offset(30);
public function orHaving( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current HAVING conditions clause using an OR operator

$builder->orHaving("SUM(Robots.price) > 0");

$builder->orHaving(
    "SUM(Robots.price) > :sum:",
    [
        "sum" => 100,
    ]
);
public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using an OR operator

$builder->orWhere("name = 'Peter'");

$builder->orWhere(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);
public function orderBy( mixed $orderBy ): BuilderInterface;

Sets an ORDER BY condition clause

$builder->orderBy("Robots.name");
$builder->orderBy(["1", "Robots.name"]);
$builder->orderBy(["Robots.name DESC"]);
public function rightJoin( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds a RIGHT join to the query

$builder->rightJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;

Set default bind types

public function setDI( DiInterface $container ): void;

Sets the DependencyInjector container

public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets the query WHERE conditions

$builder->where(100);

$builder->where("name = 'Peter'");

$builder->where(
    "name = :name: AND id > :id:",
    [
        "name" => "Peter",
        "id"   => 100,
    ]
);
protected function conditionBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;

Appends a BETWEEN condition

protected function conditionIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;

Appends an IN condition

protected function conditionNotBetween( string $clause, string $operator, string $expr, mixed $minimum, mixed $maximum ): BuilderInterface;

Appends a NOT BETWEEN condition

protected function conditionNotIn( string $clause, string $operator, string $expr, array $values ): BuilderInterface;

Appends a NOT IN condition

Interface Phalcon\Mvc\Model\Query\BuilderInterface

Исходный код на GitHub

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

Phalcon\Mvc\Model\Query\BuilderInterface

Interface for Phalcon\Mvc\Model\Query\Builder

Константы

const OPERATOR_AND = and;
const OPERATOR_OR = or;

Методы

public function addFrom( string $model, string $alias = null ): BuilderInterface;

Add a model to take part of the query

public function andWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using a AND operator

public function betweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a BETWEEN condition to the current conditions

public function columns( mixed $columns ): BuilderInterface;

Sets the columns to be queried

public function distinct( mixed $distinct ): BuilderInterface;

Sets SELECT DISTINCT / SELECT ALL flag

$builder->distinct("status");
$builder->distinct(null);
public function forUpdate( bool $forUpdate ): BuilderInterface;

Sets a FOR UPDATE clause

$builder->forUpdate(true);
public function from( mixed $models ): BuilderInterface;

Sets the models who makes part of the query

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getColumns();

Return the columns to be queried

public function getDistinct(): bool;

Returns SELECT DISTINCT / SELECT ALL flag

public function getFrom();

Return the models who makes part of the query

public function getGroupBy(): array;

Returns the GROUP BY clause

public function getHaving(): string;

Returns the HAVING condition clause

public function getJoins(): array;

Return join parts of the query

public function getLimit();

Returns the current LIMIT clause

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

Returns the models involved in the query

public function getOffset(): int;

Returns the current OFFSET clause

public function getOrderBy();

Return the set ORDER BY clause

public function getPhql(): string;

Returns a PHQL statement built based on the builder parameters

public function getQuery(): QueryInterface;

Returns the query built

public function getWhere();

Return the conditions for the query

public function groupBy( mixed $group ): BuilderInterface;

Sets a GROUP BY clause

public function having( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets a HAVING condition clause

public function inWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends an IN condition to the current conditions

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

Adds an INNER join to the query

public function join( string $model, string $conditions = null, string $alias = null ): BuilderInterface;

Adds an :type: join (by default type - INNER) to the query

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

Adds a LEFT join to the query

public function limit( int $limit, mixed $offset = null ): BuilderInterface;

Sets a LIMIT clause

public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT BETWEEN condition to the current conditions

public function notInWhere( string $expr, array $values, string $operator = static-constant-access ): BuilderInterface;

Appends a NOT IN condition to the current conditions

public function offset( int $offset ): BuilderInterface;

Sets an OFFSET clause

public function orWhere( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Appends a condition to the current conditions using an OR operator

public function orderBy( mixed $orderBy ): BuilderInterface;

Sets an ORDER BY condition clause

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

Adds a RIGHT join to the query

public function setBindParams( array $bindParams, bool $merge = bool ): BuilderInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): BuilderInterface;

Set default bind types

public function where( string $conditions, array $bindParams = [], array $bindTypes = [] ): BuilderInterface;

Sets conditions for the query

Abstract Class Phalcon\Mvc\Model\Query\Lang

Исходный код на 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"
);

Методы

public static function parsePHQL( string $phql ): array;

Parses a PHQL statement returning an intermediate representation (IR)

Class Phalcon\Mvc\Model\Query\Status

Исходный код на 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

/**
 * @var ModelInterface|null
 */
protected model;

/**
 * @var bool
 */
protected success;

Методы

public function __construct( bool $success, ModelInterface $model = null );

Phalcon\Mvc\Model\Query\Status

public function getMessages(): MessageInterface[];

Returns the messages produced because of a failed operation

public function getModel(): ModelInterface;

Returns the model that executed the action

public function success(): bool;

Allows to check if the executed operation was successful

Interface Phalcon\Mvc\Model\Query\StatusInterface

Исходный код на 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

Методы

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

Исходный код на GitHub

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

Phalcon\Mvc\Model\QueryInterface

Interface for Phalcon\Mvc\Model\Query

Методы

public function cache( array $cacheOptions ): QueryInterface;

Sets the cache parameters of the query

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

Executes a parsed PHQL statement

public function getBindParams(): array;

Returns default bind params

public function getBindTypes(): array;

Returns default bind types

public function getCacheOptions(): array;

Returns the current cache options

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

Executes the query returning the first result

public function getSql(): array;

Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)

public function getUniqueRow(): bool;

Check if the query is programmed to get only the first row in the resultset

public function parse(): array;

Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another intermediate representation that could be executed by Phalcon\Mvc\Model\Query

public function setBindParams( array $bindParams, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setBindTypes( array $bindTypes, bool $merge = bool ): QueryInterface;

Set default bind parameters

public function setSharedLock( bool $sharedLock = bool ): QueryInterface;

Set SHARED LOCK clause

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Tells to the query if only the first row in the resultset must be returned

Class Phalcon\Mvc\Model\Relation

Исходный код на GitHub

Namespace Phalcon\Mvc\Model   Implements RelationInterface

Phalcon\Mvc\Model\Relation

This class represents a relationship between two models

Константы

const ACTION_CASCADE = 2;
const ACTION_RESTRICT = 1;
const BELONGS_TO = 0;
const HAS_MANY = 2;
const HAS_MANY_THROUGH = 4;
const HAS_ONE = 1;
const HAS_ONE_THROUGH = 3;
const NO_ACTION = 0;

Properties

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

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

/**
 * @var string|null
 */
protected intermediateModel;

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

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

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

/**
 * @var string
 */
protected referencedModel;

/**
 * @var int
 */
protected type;

Методы

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

Исходный код на GitHub

Namespace Phalcon\Mvc\Model

Phalcon\Mvc\Model\RelationInterface

Interface for Phalcon\Mvc\Model\Relation

Методы

public function getFields();

Returns the fields

public function getForeignKey();

Returns the foreign key configuration

public function getIntermediateFields();

Gets the intermediate fields for has-*-through relations

public function getIntermediateModel(): string;

Gets the intermediate model for has-*-through relations

public function getIntermediateReferencedFields();

Gets the intermediate referenced fields for has-*-through relations

public function getOption( string $name );

Returns an option by the specified name If the option doesn’t exist null is returned

public function getOptions(): array;

Returns the options

public function getParams();

Returns parameters that must be always used when the related records are obtained

public function getReferencedFields();

Returns the referenced fields

public function getReferencedModel(): string;

Returns the referenced model

public function getType(): int;

Returns the relations type

public function isForeignKey(): bool;

Check whether the relation act as a foreign key

public function isReusable(): bool;

Check if records returned by getting belongs-to/has-many are implicitly cached during the current request

public function isThrough(): bool;

Check whether the relation is a ‘many-to-many’ relation or not

public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );

Sets the intermediate model data for has-*-through relations

Interface Phalcon\Mvc\Model\ResultInterface

Исходный код на 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

Методы

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

Sets the object’s state

Abstract Class Phalcon\Mvc\Model\Resultset

Исходный код на GitHub

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

Phalcon\Mvc\Model\Resultset

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


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

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

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

$robots->rewind();

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

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

    $robots->next();
}

Константы

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

Properties

/**
 * @var mixed|null
 */
protected activeRow;

/**
 * @var CacheInterface|null
 */
protected cache;

/**
 * @var int
 */
protected count = 0;

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

/**
 * @var int
 */
protected hydrateMode = 0;

/**
 * @var bool
 */
protected isFresh = true;

/**
 * @var int
 */
protected pointer = 0;

/**
 * @var mixed|null
 */
protected row;

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

/**
 * Phalcon\Db\ResultInterface or false for empty resultset
 *
 * @var ResultInterface|bool
 */
protected result;

Методы

public function __construct( mixed $result, mixed $cache = null );

Phalcon\Mvc\Model\Resultset constructor

final public function count(): int;

Counts how many rows are in the resultset

public function delete( Closure $conditionCallback = null ): bool;

Deletes every record in the resultset

public function filter( callable $filter ): ModelInterface[];

Filters a resultset returning only those the developer requires

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);
public function getCache(): CacheInterface | null;

Returns the associated cache for the resultset

public function getFirst(): mixed | null;

Get first row in the resultset

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

// \Robots
$manager->createQuery('SELECTFROM Robots')
        ->execute()
        ->getFirst();

// \Phalcon\Mvc\Model\Row
$manager->createQuery('SELECT r.id FROM Robots AS r')
        ->execute()
        ->getFirst();

// NULL
$manager->createQuery('SELECT r.id FROM Robots AS r WHERE r.name = "NON-EXISTENT"')
        ->execute()
        ->getFirst();
public function getHydrateMode(): int;

Returns the current hydration mode

public function getLast(): ModelInterface | null;

Get last row in the resultset

public function getMessages(): MessageInterface[];

Returns the error messages produced by a batch operation

public function getType(): int;

Returns the internal type of data retrieval that the resultset is using

public function isFresh(): bool;

Tell if the resultset if fresh or an old one cached

public function jsonSerialize(): array;

Returns serialised model objects as array for json_encode. Calls jsonSerialize on each object if present

$robots = Robots::find();

echo json_encode($robots);
public function key(): int | null;

Gets pointer number of active row in the resultset

public function next(): void;

Moves cursor to next row in the resultset

public function offsetExists( mixed $index ): bool;

Checks whether offset exists in the resultset

public function offsetGet( mixed $index ): mixed;

Gets row in a specific position of the resultset

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

Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;

Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

final public function rewind(): void;

Rewinds resultset to its beginning

final public function seek( mixed $position ): void;

Changes the internal pointer to a specific position in the resultset. Set the new position if required, and then set this->row

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Sets the hydration mode in the resultset

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Set if the resultset is fresh or an old one cached

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Updates every record in the resultset

public function valid(): bool;

Check whether internal resource has rows to fetch

Class Phalcon\Mvc\Model\Resultset\Complex

Исходный код на GitHub

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

Phalcon\Mvc\Model\Resultset\Complex

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

Properties

/**
 * @var array
 */
protected columnTypes;

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

Методы

public function __construct( mixed $columnTypes, ResultInterface $result = null, mixed $cache = null );

Phalcon\Mvc\Model\Resultset\Complex constructor

public function __serialize(): array;
public function __unserialize( array $data ): void;
final public function current(): mixed;

Returns current row in the resultset

public function serialize(): string;

Serializing a resultset will dump all related rows into a big array

public function toArray(): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.

public function unserialize( mixed $data ): void;

Unserializing a resultset will allow to only works on the rows present in the saved state

Class Phalcon\Mvc\Model\Resultset\Simple

Исходный код на GitHub

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

Phalcon\Mvc\Model\Resultset\Simple

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

Properties

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

/**
 * @var ModelInterface|Row
 */
protected model;

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

Методы

public function __construct( mixed $columnMap, mixed $model, mixed $result, mixed $cache = null, bool $keepSnapshots = bool );

Phalcon\Mvc\Model\Resultset\Simple constructor

public function __serialize(): array;
public function __unserialize( array $data ): void;
final public function current(): ModelInterface | null;

Returns current row in the resultset

public function serialize(): string;

Serializing a resultset will dump all related rows into a big array

public function toArray( bool $renameColumns = bool ): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does. Export the resultset to an array couldn’t be faster with a large number of records

public function unserialize( mixed $data ): void;

Unserializing a resultset will allow to only works on the rows present in the saved state

Interface Phalcon\Mvc\Model\ResultsetInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Model   Uses Closure, Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface

Phalcon\Mvc\Model\ResultsetInterface

Interface for Phalcon\Mvc\Model\Resultset

Методы

public function delete( Closure $conditionCallback = null ): bool;

Deletes every record in the resultset

public function filter( callable $filter ): ModelInterface[];

Filters a resultset returning only those the developer requires

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);
public function getCache(): mixed | null;

Returns the associated cache for the resultset

public function getFirst(): mixed | null;

Get first row in the resultset

public function getHydrateMode(): int;

Returns the current hydration mode

public function getLast(): ModelInterface | null;

Get last row in the resultset

public function getMessages(): MessageInterface[];

Returns the error messages produced by a batch operation

public function getType(): int;

Returns the internal type of data retrieval that the resultset is using

public function isFresh(): bool;

Tell if the resultset if fresh or an old one cached

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Sets the hydration mode in the resultset

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Set if the resultset is fresh or an old one cached

public function toArray(): array;

Returns a complete resultset as an array, if the resultset has a big number of rows it could consume more memory than currently it does.

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Updates every record in the resultset

Class Phalcon\Mvc\Model\Row

Исходный код на GitHub

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

This component allows Phalcon\Mvc\Model to return rows without an associated entity. This objects implements the ArrayAccess interface to allow access the object as object->x or array[x].

Методы

public function jsonSerialize(): array;

Serializes the object for json_encode

public function offsetExists( mixed $index ): bool;

Checks whether offset exists in the row

public function offsetGet( mixed $index ): mixed;

Gets a record in a specific position of the row

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

Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function offsetUnset( mixed $offset ): void;

Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface

public function readAttribute( string $attribute );

Reads an attribute value by its name

echo $robot->readAttribute("name");
public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Set the current object’s state

public function toArray(): array;

Returns the instance as an array representation

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

Writes an attribute value by its name

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

Class Phalcon\Mvc\Model\Transaction

Исходный код на GitHub

Namespace Phalcon\Mvc\Model   Uses Phalcon\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\Failed, Phalcon\Mvc\Model\Transaction\ManagerInterface, Phalcon\Mvc\Model\TransactionInterface   Implements TransactionInterface

Phalcon\Mvc\Model\Transaction

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

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

try {
    $manager = new Manager();

    $transaction = $manager->get();

    $robot = new Robots();

    $robot->setTransaction($transaction);

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

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

    $robotPart = new RobotParts();

    $robotPart->setTransaction($transaction);

    $robotPart->type = "head";

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

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

Properties

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

/**
 * @var AdapterInterface
 */
protected connection;

/**
 * @var bool
 */
protected isNewTransaction = true;

/**
 * @var ManagerInterface|null
 */
protected manager;

/**
 * @var array
 */
protected messages;

/**
 * @var ModelInterface|null
 */
protected rollbackRecord;

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

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

Методы

public function __construct( DiInterface $container, bool $autoBegin = bool, string $service = string );

Phalcon\Mvc\Model\Transaction constructor

public function begin(): bool;

Starts the transaction

public function commit(): bool;

Commits the transaction

public function getConnection(): AdapterInterface;

Returns the connection related to transaction

public function getMessages(): array;

Returns validations messages from last save try

public function isManaged(): bool;

Checks whether transaction is managed by a transaction manager

public function isValid(): bool;

Checks whether internal connection is under an active transaction

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Rollbacks the transaction

public function setIsNewTransaction( bool $isNew ): void;

Sets if is a reused transaction or new once

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Sets flag to rollback on abort the HTTP connection

public function setRollbackedRecord( ModelInterface $record ): void;

Sets object which generates rollback action

public function setTransactionManager( ManagerInterface $manager ): void;

Sets transaction manager related to the transaction

public function throwRollbackException( bool $status ): TransactionInterface;

Enables throwing exception

Class Phalcon\Mvc\Model\Transaction\Exception

Исходный код на 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

Исходный код на 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

/**
 * @var ModelInterface|null
 */
protected record;

Методы

public function __construct( string $message, ModelInterface $record = null );

Phalcon\Mvc\Model\Transaction\Failed constructor

public function getRecord(): ModelInterface;

Returns validation record messages which stop the transaction

public function getRecordMessages(): MessageInterface[];

Returns validation record messages which stop the transaction

Class Phalcon\Mvc\Model\Transaction\Manager

Исходный код на GitHub

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

Phalcon\Mvc\Model\Transaction\Manager

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

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

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

try {
   $transactionManager = new Manager();

   $transaction = $transactionManager->get();

   $robot = new Robots();

   $robot->setTransaction($transaction);

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

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

   $robotPart = new RobotParts();

   $robotPart->setTransaction($transaction);

   $robotPart->type = "head";

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

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

Properties

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

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

/**
 * @var int
 */
protected number = 0;

/**
 * @var bool
 */
protected rollbackPendent = true;

/**
 * @var string
 */
protected service = db;

/**
 * @var array
 */
protected transactions;

Методы

public function __construct( DiInterface $container = null );

Phalcon\Mvc\Model\Transaction\Manager constructor

public function collectTransactions(): void;

Remove all the transactions from the manager

public function commit();

Commits active transactions within the manager

public function get( bool $autoBegin = bool ): TransactionInterface;

Returns a new \Phalcon\Mvc\Model\Transaction or an already created once This method registers a shutdown function to rollback active connections

public function getDI(): DiInterface;

Returns the dependency injection container

public function getDbService(): string;

Returns the database service used to isolate the transaction

public function getOrCreateTransaction( bool $autoBegin = bool ): TransactionInterface;

Create/Returns a new transaction or an existing one

public function getRollbackPendent(): bool;

Check if the transaction manager is registering a shutdown function to clean up pendent transactions

public function has(): bool;

Checks whether the manager has an active transaction

public function notifyCommit( TransactionInterface $transaction ): void;

Notifies the manager about a committed transaction

public function notifyRollback( TransactionInterface $transaction ): void;

Notifies the manager about a rollbacked transaction

public function rollback( bool $collect = bool ): void;

Rollbacks active transactions within the manager Collect will remove the transaction from the manager

public function rollbackPendent(): void;

Rollbacks active transactions within the manager

public function setDI( DiInterface $container ): void;

Sets the dependency injection container

public function setDbService( string $service ): ManagerInterface;

Sets the database service used to run the isolated transactions

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Set if the transaction manager must register a shutdown function to clean up pendent transactions

protected function collectTransaction( TransactionInterface $transaction ): void;

Removes transactions from the TransactionManager

Interface Phalcon\Mvc\Model\Transaction\ManagerInterface

Исходный код на GitHub

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

Phalcon\Mvc\Model\Transaction\ManagerInterface

Interface for Phalcon\Mvc\Model\Transaction\Manager

Методы

public function collectTransactions(): void;

Remove all the transactions from the manager

public function commit();

Commits active transactions within the manager

public function get( bool $autoBegin = bool ): TransactionInterface;

Returns a new \Phalcon\Mvc\Model\Transaction or an already created once

public function getDbService(): string;

Returns the database service used to isolate the transaction

public function getRollbackPendent(): bool;

Check if the transaction manager is registering a shutdown function to clean up pendent transactions

public function has(): bool;

Checks whether manager has an active transaction

public function notifyCommit( TransactionInterface $transaction ): void;

Notifies the manager about a committed transaction

public function notifyRollback( TransactionInterface $transaction ): void;

Notifies the manager about a rollbacked transaction

public function rollback( bool $collect = bool ): void;

Rollbacks active transactions within the manager Collect will remove transaction from the manager

public function rollbackPendent(): void;

Rollbacks active transactions within the manager

public function setDbService( string $service ): ManagerInterface;

Sets the database service used to run the isolated transactions

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Set if the transaction manager must register a shutdown function to clean up pendent transactions

Interface Phalcon\Mvc\Model\TransactionInterface

Исходный код на GitHub

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

Phalcon\Mvc\Model\TransactionInterface

Interface for Phalcon\Mvc\Model\Transaction

Методы

public function begin(): bool;

Starts the transaction

public function commit(): bool;

Commits the transaction

public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;

Returns connection related to transaction

public function getMessages(): array;

Returns validations messages from last save try

public function isManaged(): bool;

Checks whether transaction is managed by a transaction manager

public function isValid(): bool;

Checks whether internal connection is under an active transaction

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Rollbacks the transaction

public function setIsNewTransaction( bool $isNew ): void;

Sets if is a reused transaction or new once

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Sets flag to rollback on abort the HTTP connection

public function setRollbackedRecord( ModelInterface $record ): void;

Sets object which generates rollback action

public function setTransactionManager( ManagerInterface $manager ): void;

Sets transaction manager related to the transaction

public function throwRollbackException( bool $status ): TransactionInterface;

Enables throwing exception

Class Phalcon\Mvc\Model\ValidationFailed

Исходный код на GitHub

Namespace Phalcon\Mvc\Model   Uses Phalcon\Messages\Message, Phalcon\Mvc\ModelInterface   Extends Exception

Phalcon\Mvc\Model\ValidationFailed

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

Properties

/**
 * @var array
 */
protected messages;

/**
 * @var ModelInterface
 */
protected model;

Методы

public function __construct( ModelInterface $model, array $validationMessages );

Phalcon\Mvc\Model\ValidationFailed constructor

public function getMessages(): Message[];

Returns the complete group of messages produced in the validation

public function getModel(): ModelInterface;

Returns the model that generated the messages

Interface Phalcon\Mvc\ModelInterface

Исходный код на 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

Методы

public function appendMessage( MessageInterface $message ): ModelInterface;

Appends a customized message on the validation process

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

Assigns values to a model from an array

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

Allows to calculate the average value on a column matching the specified conditions

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

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

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

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

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

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

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

Allows to count how many records match the specified conditions

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

public function create(): bool;

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

public function delete(): bool;

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

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

Allows to query a set of records that match the specified conditions

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

Allows to query the first record that match the specified conditions

public function fireEvent( string $eventName ): bool;

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

public function fireEventCancel( string $eventName ): bool;

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

public function getDirtyState(): int;

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

public function getMessages(): MessageInterface[];

Returns array of validation messages

public function getModelsMetaData(): MetaDataInterface;

Returns the models meta-data service related to the entity instance.

public function getOperationMade(): int;

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

public function getReadConnection(): AdapterInterface;

Gets internal database connection

public function getReadConnectionService(): string;

Returns DependencyInjection connection service used to read data

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

Returns related records based on defined relations

public function getSchema(): string | null;

Returns schema name where table mapped is located

public function getSource(): string;

Returns table name mapped in the model

public function getWriteConnection(): AdapterInterface;

Gets internal database connection

public function getWriteConnectionService(): string;

Returns DependencyInjection connection service used to write data

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

Allows to get the maximum value of a column that match the specified conditions

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

Allows to get the minimum value of a column that match the specified conditions

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

Create a criteria for a specific model

public function refresh(): ModelInterface;

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

public function save(): bool;

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

public function setConnectionService( string $connectionService ): void;

Sets both read/write connection services

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

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

public function setReadConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service used to read data

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

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

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Sets a transaction related to the Model instance

public function setWriteConnectionService( string $connectionService ): void;

Sets the DependencyInjection connection service used to write data

public function skipOperation( bool $skip ): void;

Skips the current operation forcing a success state

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

Allows to calculate a sum on a column that match the specified conditions

public function update(): bool;

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

public function validationHasFailed(): bool;

Check whether validation process has generated any messages

Interface Phalcon\Mvc\ModuleDefinitionInterface

Исходный код на GitHub

Namespace Phalcon\Mvc   Uses Phalcon\Di\DiInterface

Phalcon\Mvc\ModuleDefinitionInterface

This interface must be implemented by class module definitions

Методы

public function registerAutoloaders( DiInterface $container = null );

Registers an autoloader related to the module

public function registerServices( DiInterface $container );

Registers services related to the module

Class Phalcon\Mvc\Router

Исходный код на 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();

Константы

const POSITION_FIRST = 0;
const POSITION_LAST = 1;

Properties

/**
 * @var string
 */
protected action = "";

/**
 * @var string
 */
protected controller = "";

/**
 * @var string
 */
protected defaultAction = "";

/**
 * @var string
 */
protected defaultController = "";

/**
 * @var string
 */
protected defaultModule = "";

/**
 * @var string
 */
protected defaultNamespace = "";

/**
 * @var array
 */
protected defaultParams;

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

/**
 * @var array
 */
protected keyRouteNames;

/**
 * @var array
 */
protected keyRouteIds;

/**
 * @var RouteInterface|null
 */
protected matchedRoute;

/**
 * @var array
 */
protected matches;

/**
 * @var string
 */
protected module = "";

/**
 * @var string
 */
protected namespaceName = "";

/**
 * @var array|string|null
 */
protected notFoundPaths;

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

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

/**
 * @var array
 */
protected routes;

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

Методы

public function __construct( bool $defaultRoutes = bool );

Phalcon\Mvc\Router constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router without any HTTP constraint

use Phalcon\Mvc\Router;

$router->add("/about", "About::index");

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"]
);

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"],
    Router::POSITION_FIRST
);
public function addConnect( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, int $position = static-constant-access ): RouterInterface;

Attach Route object to the routes stack.

use Phalcon\Mvc\Router;
use Phalcon\Mvc\Router\Route;

class CustomRoute extends Route {
     // ...
}

$router = new Router();

$router->attach(
    new CustomRoute("/about", "About::index", ["GET", "HEAD"]),
    Router::POSITION_FIRST
);
public function clear(): void;

Removes all the pre-defined routes

public function getActionName(): string;

Returns the processed action name

public function getControllerName(): string;

Returns the processed controller name

public function getDefaults(): array;

Returns an array of default parameters

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getKeyRouteIds(): array;
public function getKeyRouteNames(): array;
public function getMatchedRoute(): RouteInterface | null;

Returns the route that matches the handled URI

public function getMatches(): array;

Returns the sub expressions in the regular expression matched

public function getModuleName(): string;

Returns the processed module name

public function getNamespaceName(): string;

Returns the processed namespace name

public function getParams(): array;

Returns the processed parameters

public function getRouteById( mixed $id ): RouteInterface | bool;

Returns a route object by its id

public function getRouteByName( string $name ): RouteInterface | bool;

Returns a route object by its name

public function getRoutes(): RouteInterface[];

Returns all the routes defined in the router

public function handle( string $uri ): void;

Handles routing information received from the rewrite engine

// Passing a URL
$router->handle("/posts/edit/1");
public function isExactControllerName(): bool;

Returns whether controller name should not be mangled

public function mount( GroupInterface $group ): RouterInterface;

Mounts a group of routes in the router

public function notFound( mixed $paths ): RouterInterface;

Set a group of paths to be returned when none of the defined routes are matched

public function removeExtraSlashes( bool $remove ): RouterInterface;

Set whether router must remove the extra slashes in the handled routes

public function setDefaultAction( string $actionName ): RouterInterface;

Sets the default action name

public function setDefaultController( string $controllerName ): RouterInterface;

Sets the default controller name

public function setDefaultModule( string $moduleName ): RouterInterface;

Sets the name of the default module

public function setDefaultNamespace( string $namespaceName ): RouterInterface;

Sets the name of the default namespace

@parma string namespaceName

public function setDefaults( array $defaults ): RouterInterface;

Sets an array of default paths. If a route is missing a path the router will use the defined here. This method must not be used to set a 404 route

$router->setDefaults(
    [
        "module" => "common",
        "action" => "index",
    ]
);
public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setKeyRouteIds( array $routeIds ): Router;
public function setKeyRouteNames( array $routeNames ): Router;
public function wasMatched(): bool;

Checks if the router matches any of the defined routes

Class Phalcon\Mvc\Router\Annotations

Исходный код на 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

/**
 * @var string
 */
protected actionSuffix = Action;

/**
 * @var callable|string|null
 */
protected actionPreformatCallback;

/**
 * @var string
 */
protected controllerSuffix = Controller;

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

/**
 * @var string
 */
protected routePrefix = ;

Методы

public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations The class is located in a module

public function addResource( string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations

public function getActionPreformatCallback();
public function getResources(): array;

Return the registered resources

public function handle( string $uri ): void;

Produce the routing parameters from the rewrite information

public function processActionAnnotation( string $module, string $namespaceName, string $controller, string $action, Annotation $annotation ): void;

Checks for annotations in the public methods of the controller

public function processControllerAnnotation( string $handler, Annotation $annotation );

Checks for annotations in the controller docblock

public function setActionPreformatCallback( mixed $callback = null );

Sets the action preformat callback $action here already without suffix ‘Action’

// Array as callback
$annotationRouter->setActionPreformatCallback(
     [
         new Uncamelize(),
         '__invoke'
     ]
 );

// Function as callback
$annotationRouter->setActionPreformatCallback(
    function ($action) {
        return $action;
    }
);

// String as callback
$annotationRouter->setActionPreformatCallback('strtolower');

// If empty method constructor called [null], sets uncamelize with - delimiter
$annotationRouter->setActionPreformatCallback();
public function setActionSuffix( string $actionSuffix );

Changes the action method suffix

public function setControllerSuffix( string $controllerSuffix );

Changes the controller class suffix

Class Phalcon\Mvc\Router\Exception

Исходный код на GitHub

Namespace Phalcon\Mvc\Router   Extends \Exception

Phalcon\Mvc\Router\Exception

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

Class Phalcon\Mvc\Router\Group

Исходный код на 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

/**
 * @var callable|null
 */
protected beforeMatch;

/**
 * @var string|null
 */
protected hostname;

/**
 * @var array|string|null
 */
protected paths;

/**
 * @var string|null
 */
protected prefix;

/**
 * @var array
 */
protected routes;

Методы

public function __construct( mixed $paths = null );

Phalcon\Mvc\Router\Group constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Adds a route to the router on any HTTP method

$router->add("/about", "About::index");
public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function beforeMatch( callable $beforeMatch ): GroupInterface;

Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched

public function clear(): void;

Removes all the pre-defined routes

public function getBeforeMatch(): callable;

Returns the ‘before match’ callback if any

public function getHostname(): string;

Returns the hostname restriction

public function getPaths(): array | string;

Returns the common paths defined for this group

public function getPrefix(): string;

Returns the common prefix for all the routes

public function getRoutes(): RouteInterface[];

Returns the routes added to the group

public function setHostname( string $hostname ): GroupInterface;

Set a hostname restriction for all the routes in the group

public function setPaths( mixed $paths ): GroupInterface;

Set common paths for all the routes in the group

public function setPrefix( string $prefix ): GroupInterface;

Set a common uri prefix for all the routes in this group

protected function addRoute( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Adds a route applying the common attributes

Interface Phalcon\Mvc\Router\GroupInterface

Исходный код на 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);

Методы

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

Исходный код на GitHub

Namespace Phalcon\Mvc\Router   Implements RouteInterface

Phalcon\Mvc\Router\Route

This class represents every route added to the router

Properties

/**
 * @var callable|null
 */
protected beforeMatch;

/**
 * @var string|null
 */
protected compiledPattern;

/**
 * @var array
 */
protected converters;

/**
 * @var GroupInterface|null
 */
protected group;

/**
 * @var string|null
 */
protected hostname;

/**
 * @var string|null
 */
protected id;

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

/**
 * @var callable|null
 */
protected match;

/**
 * @var string|null
 */
protected name;

/**
 * @var array
 */
protected paths;

/**
 * @var string
 */
protected pattern;

/**
 * @var int
 */
protected static uniqueId = 0;

Методы

public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );

Phalcon\Mvc\Router\Route constructor

public function beforeMatch( callable $callback ): RouteInterface;

Sets a callback that is called if the route is matched. The developer can implement any arbitrary conditions here If the callback returns false the route is treated as not matched

$router->add(
    "/login",
    [
        "module"     => "admin",
        "controller" => "session",
    ]
)->beforeMatch(
    function ($uri, $route) {
        // Check if the request was made with Ajax
        if ($_SERVER["HTTP_X_REQUESTED_WITH"] === "xmlhttprequest") {
            return false;
        }

        return true;
    }
);
public function compilePattern( string $pattern ): string;

Replaces placeholders from pattern returning a valid PCRE regular expression

public function convert( string $name, mixed $converter ): RouteInterface;

{@inheritdoc}

public function extractNamedParams( string $pattern ): array | bool;

Extracts parameters from a string

public function getBeforeMatch(): callable;

Returns the ‘before match’ callback if any

public function getCompiledPattern(): string;

Returns the route’s compiled pattern

public function getConverters(): array;

Returns the router converter

public function getGroup(): GroupInterface | null;

Returns the group associated with the route

public function getHostname(): string | null;

Returns the hostname restriction if any

public function getHttpMethods(): array | string;

Returns the HTTP methods that constraint matching the route

public function getId(): string | null;
public function getMatch(): callable;

Returns the ‘match’ callback if any

public function getName(): string | null;

Returns the route’s name

public function getPaths(): array;

Returns the paths

public function getPattern(): string;

Returns the route’s pattern

public function getReversedPaths(): array;

Returns the paths using positions as keys and names as values

public function getRouteId(): string;

Returns the route’s id

public static function getRoutePaths( mixed $paths = null ): array;

Returns routePaths

public function match( mixed $callback ): RouteInterface;

Allows to set a callback to handle the request directly in the route

$router->add(
    "/help",
    []
)->match(
    function () {
        return $this->getResponse()->redirect("https://support.google.com/", true);
    }
);
public function reConfigure( string $pattern, mixed $paths = null ): void;

Reconfigure the route adding a new pattern and a set of paths

public static function reset(): void;

Resets the internal route id generator

public function setGroup( GroupInterface $group ): RouteInterface;

Sets the group associated with the route

public function setHostname( string $hostname ): RouteInterface;

Sets a hostname restriction to the route

$route->setHostname("localhost");
public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Sets a set of HTTP methods that constraint the matching of the route (alias of via)

$route->setHttpMethods("GET");

$route->setHttpMethods(
    [
        "GET",
        "POST",
    ]
);
public function setName( string $name ): RouteInterface;

Sets the route’s name

$router->add(
    "/about",
    [
        "controller" => "about",
    ]
)->setName("about");
public function via( mixed $httpMethods ): RouteInterface;

Set one or more HTTP methods that constraint the matching of the route

$route->via("GET");

$route->via(
    [
        "GET",
        "POST",
    ]
);

Interface Phalcon\Mvc\Router\RouteInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Router

Phalcon\Mvc\Router\RouteInterface

Interface for Phalcon\Mvc\Router\Route

Методы

public function compilePattern( string $pattern ): string;

Replaces placeholders from pattern returning a valid PCRE regular expression

public function convert( string $name, mixed $converter ): RouteInterface;

Adds a converter to perform an additional transformation for certain parameter.

public function getCompiledPattern(): string;

Returns the route’s pattern

public function getHostname(): string | null;

Returns the hostname restriction if any

public function getHttpMethods(): string | array;

Returns the HTTP methods that constraint matching the route

public function getName(): string | null;

Returns the route’s name

public function getPaths(): array;

Returns the paths

public function getPattern(): string;

Returns the route’s pattern

public function getReversedPaths(): array;

Returns the paths using positions as keys and names as values

public function getRouteId(): string;

Returns the route’s id

public function reConfigure( string $pattern, mixed $paths = null ): void;

Reconfigure the route adding a new pattern and a set of paths

public static function reset(): void;

Resets the internal route id generator

public function setHostname( string $hostname ): RouteInterface;

Sets a hostname restriction to the route

public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Sets a set of HTTP methods that constraint the matching of the route

public function setName( string $name ): RouteInterface;

Sets the route’s name

public function via( mixed $httpMethods ): RouteInterface;

Set one or more HTTP methods that constraint the matching of the route

Interface Phalcon\Mvc\RouterInterface

Исходный код на GitHub

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

Interface for Phalcon\Mvc\Router

Методы

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router on any HTTP method

public function addConnect( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, int $position = Router::POSITION_LAST ): RouterInterface;

Attach Route object to the routes stack.

public function clear(): void;

Removes all the defined routes

public function getActionName(): string;

Returns processed action name

public function getControllerName(): string;

Returns processed controller name

public function getMatchedRoute(): RouteInterface | null;

Returns the route that matches the handled URI

public function getMatches(): array;

Return the sub expressions in the regular expression matched

public function getModuleName(): string;

Returns processed module name

public function getNamespaceName(): string;

Returns processed namespace name

public function getParams(): array;

Returns processed extra params

public function getRouteById( mixed $id ): RouteInterface | bool;

Returns a route object by its id

public function getRouteByName( string $name ): RouteInterface | bool;

Returns a route object by its name

public function getRoutes(): RouteInterface[];

Return all the routes defined in the router

public function handle( string $uri ): void;

Handles routing information received from the rewrite engine

public function mount( GroupInterface $group ): RouterInterface;

Mounts a group of routes in the router

public function setDefaultAction( string $actionName ): RouterInterface;

Sets the default action name

public function setDefaultController( string $controllerName ): RouterInterface;

Sets the default controller name

public function setDefaultModule( string $moduleName ): RouterInterface;

Sets the name of the default module

public function setDefaults( array $defaults ): RouterInterface;

Sets an array of default paths

public function wasMatched(): bool;

Check if the router matches any of the defined routes

Class Phalcon\Mvc\Url

Исходный код на GitHub

Namespace Phalcon\Mvc   Uses Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Mvc\RouterInterface, Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Url\Exception, Phalcon\Mvc\Url\UrlInterface   Extends AbstractInjectionAware   Implements UrlInterface

This components helps in the generation of: URIs, URLs and Paths

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2012",
    ]
);

Properties

/**
 * @var null | string
 */
protected baseUri;

/**
 * @var null | string
 */
protected basePath;

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

/**
 * @var null | string
 */
protected staticBaseUri;

Методы

public function __construct( RouterInterface $router = null );
public function get( mixed $uri = null, mixed $args = null, bool $local = null, mixed $baseUri = null ): string;

Generates a URL

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2015",
    ]
);

// Generate a URL with GET arguments (/show/products?id=1&name=Carrots)
echo $url->get(
    "show/products",
    [
        "id"   => 1,
        "name" => "Carrots",
    ]
);

// Generate an absolute URL by setting the third parameter as false.
echo $url->get(
    "https://phalcon.io/",
    null,
    false
);
public function getBasePath(): string;

Returns the base path

public function getBaseUri(): string;

Returns the prefix for all the generated urls. By default /

public function getStatic( mixed $uri = null ): string;

Generates a URL for a static resource

// Generate a URL for a static resource
echo $url->getStatic("img/logo.png");

// Generate a URL for a static predefined route
echo $url->getStatic(
    [
        "for" => "logo-cdn",
    ]
);
public function getStaticBaseUri(): string;

Returns the prefix for all the generated static urls. By default /

public function path( string $path = null ): string;

Generates a local path

public function setBasePath( string $basePath ): UrlInterface;

Sets a base path for all the generated paths

$url->setBasePath("/var/www/htdocs/");
public function setBaseUri( string $baseUri ): UrlInterface;

Sets a prefix for all the URIs to be generated

$url->setBaseUri("/invo/");

$url->setBaseUri("/invo/index.php/");
public function setStaticBaseUri( string $staticBaseUri ): UrlInterface;

Sets a prefix for all static URLs generated

$url->setStaticBaseUri("/invo/");

Class Phalcon\Mvc\Url\Exception

Исходный код на GitHub

Namespace Phalcon\Mvc\Url   Extends \Exception

Phalcon\Mvc\Url\Exception

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

Interface Phalcon\Mvc\Url\UrlInterface

Исходный код на GitHub

Namespace Phalcon\Mvc\Url

Interface for Phalcon\Mvc\Url\UrlInterface

Методы

public function get( mixed $uri = null, mixed $args = null, bool $local = null ): string;

Generates a URL

public function getBasePath(): string;

Returns a base path

public function getBaseUri(): string;

Returns the prefix for all the generated urls. By default /

public function path( string $path = null ): string;

Generates a local path

public function setBasePath( string $basePath ): UrlInterface;

Sets a base paths for all the generated paths

public function setBaseUri( string $baseUri ): UrlInterface;

Sets a prefix to all the urls generated

Class Phalcon\Mvc\View

Исходный код на GitHub

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

Phalcon\Mvc\View

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

use Phalcon\Mvc\View;

$view = new View();

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

$view->start();

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

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

Константы

const LEVEL_ACTION_VIEW = 1;
const LEVEL_AFTER_TEMPLATE = 4;
const LEVEL_BEFORE_TEMPLATE = 2;
const LEVEL_LAYOUT = 3;
const LEVEL_MAIN_LAYOUT = 5;
const LEVEL_NO_RENDER = 0;

Properties

/**
 * @var string
 */
protected actionName;

/**
 * @var array
 */
protected activeRenderPaths;

/**
 * @var string
 */
protected basePath = ;

/**
 * @var string
 */
protected content = ;

/**
 * @var string
 */
protected controllerName;

/**
 * @var int
 */
protected currentRenderLevel = 0;

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

/**
 * @var array
 */
protected disabledLevels;

/**
 * @var array|bool
 */
protected engines = false;

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

/**
 * @var string|null
 */
protected layout;

/**
 * @var string
 */
protected layoutsDir = ;

/**
 * @var string
 */
protected mainView = index;

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

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

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

/**
 * @var string
 */
protected partialsDir = ;

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

/**
 * @var int
 */
protected renderLevel = 5;

/**
 * @var array
 */
protected templatesAfter;

/**
 * @var array
 */
protected templatesBefore;

/**
 * @var array
 */
protected viewsDirs;

/**
 * @var array
 */
protected viewParams;

Методы

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

Phalcon\Mvc\View constructor

public function __get( string $key ): mixed | null;

Magic method to retrieve a variable passed to the view

echo $this->view->products;
public function __isset( string $key ): bool;

Magic method to retrieve if a variable is set in the view

echo isset($this->view->products);
public function __set( string $key, mixed $value );

Magic method to pass variables to the views

$this->view->products = $products;
public function cleanTemplateAfter(): View;

Resets any template before layouts

public function cleanTemplateBefore(): View;

Resets any “template before” layouts

public function disable(): View;

Disables the auto-rendering process

public function disableLevel( mixed $level ): ViewInterface;

Disables a specific level of rendering

// Render all levels except ACTION level
$this->view->disableLevel(
    View::LEVEL_ACTION_VIEW
);
public function enable(): View;

Enables the auto-rendering process

public function exists( string $view ): bool;

Checks whether view exists @deprecated

public function finish(): View;

Finishes the render process by stopping the output buffering

public function getActionName(): string;

Gets the name of the action rendered

public function getActiveRenderPath(): string | array;

Returns the path (or paths) of the views that are currently rendered

public function getBasePath(): string;

Gets base path

public function getContent(): string;

Returns output from another view stage

public function getControllerName(): string;

Gets the name of the controller rendered

public function getCurrentRenderLevel(): int;
public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getLayout(): string;

Returns the name of the main view

public function getLayoutsDir(): string;

Gets the current layouts sub-directory

public function getMainView(): string;

Returns the name of the main view

public function getParamsToView(): array;

Returns parameters to views

public function getPartial( string $partialPath, mixed $params = null ): string;

Renders a partial view

// Retrieve the contents of a partial
echo $this->getPartial("shared/footer");
// Retrieve the contents of a partial with arguments
echo $this->getPartial(
    "shared/footer",
    [
        "content" => $html,
    ]
);
public function getPartialsDir(): string;

Gets the current partials sub-directory

public function getRegisteredEngines(): array;
public function getRender( string $controllerName, string $actionName, array $params = [], mixed $configCallback = null ): string;

Perform the automatic rendering returning the output as a string

$template = $this->view->getRender(
    "products",
    "show",
    [
        "products" => $products,
    ]
);
public function getRenderLevel(): int;
public function getVar( string $key );

Returns a parameter previously set in the view

public function getViewsDir(): string | array;

Gets views directory

public function has( string $view ): bool;

Checks whether view exists

public function isDisabled(): bool;

Whether automatic rendering is enabled

public function partial( string $partialPath, mixed $params = null );

Renders a partial view

// Show a partial inside another view
$this->partial("shared/footer");
// Show a partial inside another view with parameters
$this->partial(
    "shared/footer",
    [
        "content" => $html,
    ]
);
public function pick( mixed $renderView ): View;

Choose a different view to render instead of last-controller/last-action

use Phalcon\Mvc\Controller;

class ProductsController extends Controller
{
    public function saveAction()
    {
        // Do some save stuff...

        // Then show the list view
        $this->view->pick("products/list");
    }
}
public function processRender( string $controllerName, string $actionName, array $params = [], bool $fireEvents = bool ): bool;

Processes the view and templates; Fires events if needed

public function registerEngines( array $engines ): View;

Register templating engines

$this->view->registerEngines(
    [
        ".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
        ".volt"  => \Phalcon\Mvc\View\Engine\Volt::class,
        ".mhtml" => \MyCustomEngine::class,
    ]
);
public function render( string $controllerName, string $actionName, array $params = [] ): View | bool;

Executes render process from dispatching data

// Shows recent posts view (app/views/posts/recent.phtml)
$view->start()->render("posts", "recent")->finish();
public function reset(): View;

Resets the view component to its factory default values

public function setBasePath( string $basePath ): View;

Sets base path. Depending of your platform, always add a trailing slash or backslash

$view->setBasePath(__DIR__ . "/");
public function setContent( string $content ): View;

Externally sets the view content

$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setLayout( string $layout ): View;

Change the layout to be used instead of using the name of the latest controller name

$this->view->setLayout("main");
public function setLayoutsDir( string $layoutsDir ): View;

Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

$view->setLayoutsDir("../common/layouts/");
public function setMainView( string $viewPath ): View;

Sets default view name. Must be a file without extension in the views directory

// Renders as main view views-dir/base.phtml
$this->view->setMainView("base");
public function setParamToView( string $key, mixed $value ): View;

Adds parameters to views (alias of setVar)

$this->view->setParamToView("products", $products);
public function setPartialsDir( string $partialsDir ): View;

Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

$view->setPartialsDir("../common/partials/");
public function setRenderLevel( int $level ): ViewInterface;

Sets the render level for the view

// Render the view related to the controller only
$this->view->setRenderLevel(
    View::LEVEL_LAYOUT
);
public function setTemplateAfter( mixed $templateAfter ): View;

Sets a “template after” controller layout

public function setTemplateBefore( mixed $templateBefore ): View;

Sets a template before the controller layout

public function setVar( string $key, mixed $value ): View;

Set a single view parameter

$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): View;

Set all the render params

$this->view->setVars(
    [
        "products" => $products,
    ]
);
public function setViewsDir( mixed $viewsDir ): View;

Sets the views directory. Depending of your platform, always add a trailing slash or backslash

public function start(): View;

Starts rendering process enabling the output buffering

public function toString( string $controllerName, string $actionName, array $params = [] ): string;

Renders the view and returns it as a string

protected function engineRender( array $engines, string $viewPath, bool $silence, bool $mustClean = bool );

Checks whether view exists on registered extensions and render it

protected function getViewsDirs(): array;

Gets views directories

final protected function isAbsolutePath( string $path );

Checks if a path is absolute or not

protected function loadTemplateEngines(): array;

Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php

Abstract Class Phalcon\Mvc\View\Engine\AbstractEngine

Исходный код на GitHub

Namespace Phalcon\Mvc\View\Engine   Uses Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Mvc\ViewBaseInterface   Extends Injectable   Implements EngineInterface

All the template engine adapters must inherit this class. This provides basic interfacing between the engine and the Phalcon\Mvc\View component.

Properties

/**
 * @var ViewBaseInterface
 */
protected view;

Методы

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

Исходный код на GitHub

Namespace Phalcon\Mvc\View\Engine

Interface for Phalcon\Mvc\View engine adapters

Методы

public function getContent(): string;

Returns cached output on another view stage

public function partial( string $partialPath, mixed $params = null ): void;

Renders a partial inside another view

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

TODO: Change params to array type

Class Phalcon\Mvc\View\Engine\Php

Исходный код на GitHub

Namespace Phalcon\Mvc\View\Engine   Extends AbstractEngine

Adapter to use PHP itself as templating engine

Методы

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

Class Phalcon\Mvc\View\Engine\Volt

Исходный код на GitHub

Namespace Phalcon\Mvc\View\Engine   Uses Phalcon\Di\DiInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Html\Link\Link, Phalcon\Html\Link\Serializer\Header, Phalcon\Mvc\View\Engine\Volt\Compiler, Phalcon\Mvc\View\Exception   Extends AbstractEngine   Implements EventsAwareInterface

Designer friendly and fast template engine for PHP written in Zephir/C

Properties

/**
 * @var Compiler
 */
protected compiler;

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

/**
 * @var array
 */
protected macros;

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

Методы

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;

Возвращает опции Volt

public function isIncluded( mixed $needle, mixed $haystack ): bool;

Checks if the needle is included in the haystack

public function length( mixed $item ): int;

Фильтр длины. If an array/object is passed a count is performed otherwise a strlen/mb_strlen

public function preload( mixed $parameters ): string;

Parses the preload element passed and sets the necessary link headers @todo find a better way to handle this

public function render( string $path, mixed $params, bool $mustClean = bool );

Renders a view using the template engine

public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setOptions( array $options );

Set Volt’s options

public function slice( mixed $value, int $start = int, mixed $end = null );

Extracts a slice from a string/array/traversable object value

public function sort( array $value ): array;

Сортирует массив

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

Исходный код на 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

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

/**
 * @var int
 */
protected blockLevel = 0;

/**
 * @var array|null
 *
 * TODO: Make array only?
 */
protected blocks;

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

/**
 * @var string|null
 */
protected compiledTemplatePath;

/**
 * @var string|null
 */
protected currentBlock;

/**
 * @var string|null
 */
protected currentPath;

/**
 * @var int
 */
protected exprLevel = 0;

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

/**
 * @var array
 */
protected extensions;

/**
 * @var array|bool
 *
 * TODO: Make it always array
 */
protected extendedBlocks;

/**
 * @var array
 */
protected filters;

/**
 * @var int
 */
protected foreachLevel = 0;

/**
 * @var array
 */
protected forElsePointers;

/**
 * @var array
 */
protected functions;

/**
 * @var int
 */
protected level = 0;

/**
 * @var array
 */
protected loopPointers;

/**
 * @var array
 */
protected macros;

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

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

/**
 * @var ViewBaseInterface|null
 */
protected view;

Методы

public function __construct( ViewBaseInterface $view = null );

Phalcon\Mvc\View\Engine\Volt\Compiler

public function addExtension( mixed $extension ): Compiler;

Registers a Volt’s extension

@var mixed extension

public function addFilter( string $name, mixed $definition ): Compiler;

Register a new filter in the compiler

public function addFunction( string $name, mixed $definition ): Compiler;

Register a new function in the compiler

public function attributeReader( array $expr ): string;

Resolves attribute reading

public function compile( string $templatePath, bool $extendsMode = bool );

Compiles a template into a file applying the compiler options This method does not return the compiled path if the template was not compiled

$compiler->compile("views/layouts/main.volt");

require $compiler->getCompiledTemplatePath();
public function compileAutoEscape( array $statement, bool $extendsMode ): string;

Compiles a “autoescape” statement returning PHP code

public function compileCall( array $statement, bool $extendsMode );

Compiles calls to macros

public function compileCase( array $statement, bool $caseClause = bool ): string;

Compiles a “case”/”default” clause returning PHP code

public function compileDo( array $statement ): string;

Compiles a “do” statement returning PHP code

public function compileEcho( array $statement ): string;

Compiles a {{ }} statement returning PHP code

public function compileElseIf( array $statement ): string;

Compiles a “elseif” statement returning PHP code

public function compileFile( string $path, string $compiledPath, bool $extendsMode = bool );

Compiles a template into a file forcing the destination path

$compiler->compileFile(
    "views/layouts/main.volt",
    "views/layouts/main.volt.php"
);
public function compileForElse(): string;

Generates a ‘forelse’ PHP code

public function compileForeach( array $statement, bool $extendsMode = bool ): string;

Compiles a “foreach” intermediate code representation into plain PHP code

public function compileIf( array $statement, bool $extendsMode = bool ): string;

Compiles a ‘if’ statement returning PHP code

public function compileInclude( array $statement ): string;

Compiles a ‘include’ statement returning PHP code

public function compileMacro( array $statement, bool $extendsMode ): string;

Compiles macros

public function compileReturn( array $statement ): string;

Compiles a “return” statement returning PHP code

@throws \Phalcon\Mvc\View\Engine\Volt\Exception

public function compileSet( array $statement ): string;

Compiles a “set” statement returning PHP code

public function compileString( string $viewCode, bool $extendsMode = bool ): string;

Compiles a template into a string

echo $compiler->compileString('{{ "hello world" }}');
public function compileSwitch( array $statement, bool $extendsMode = bool ): string;

Compiles a ‘switch’ statement returning PHP code

final public function expression( array $expr, bool $doubleQuotes = bool ): string;

Resolves an expression node in an AST volt tree

final public function fireExtensionEvent( string $name, array $arguments = [] );

Fires an event to registered extensions

public function functionCall( array $expr, bool $doubleQuotes = bool ): string;

Resolves function intermediate code into PHP function calls

public function getCompiledTemplatePath(): string;

Returns the path to the last compiled template

public function getDI(): DiInterface;

Returns the internal dependency injector

public function getExtensions(): array;

Returns the list of extensions registered in Volt

public function getFilters(): array;

Register the user registered filters

public function getFunctions(): array;

Register the user registered functions

public function getOption( string $option ): string | null;

Returns a compiler’s option

public function getOptions(): array;

Returns the compiler options

public function getTemplatePath(): string;

Returns the path that is currently being compiled

public function getUniquePrefix(): string;

Return a unique prefix to be used as prefix for compiled variables and contexts

public function parse( string $viewCode ): array;

Parses a Volt template returning its intermediate representation

print_r(
    $compiler->parse("{{ 3 + 2 }}")
);
public function resolveTest( array $test, string $left ): string;

Resolves filter intermediate code into a valid PHP expression

public function setDI( DiInterface $container ): void;

Sets the dependency injector

public function setOption( string $option, mixed $value );

Sets a single compiler option

public function setOptions( array $options );

Sets the compiler options

public function setUniquePrefix( string $prefix ): Compiler;

Set a unique prefix to be used as prefix for compiled variables

protected function compileSource( string $viewCode, bool $extendsMode = bool ): string;

Compiles a Volt source code returning a PHP plain version

protected function getFinalPath( string $path );

Gets the final path with VIEW

final protected function resolveFilter( array $filter, string $left ): string;

Resolves filter intermediate code into PHP function calls

final protected function statementList( array $statements, bool $extendsMode = bool ): string;

Traverses a statement list compiling each of its nodes

final protected function statementListOrExtends( mixed $statements );

Compiles a block of statements

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

Исходный код на GitHub

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

Class for exceptions thrown by Phalcon\Mvc\View

Properties

/**
 * @var array
 */
protected statement;

Методы

public function __construct( string $message = string, array $statement = [], int $code = int, \Exception $previous = null );
public function getStatement(): array;

Gets currently parsed statement (if any).

Class Phalcon\Mvc\View\Exception

Исходный код на GitHub

Namespace Phalcon\Mvc\View   Extends \Exception

Phalcon\Mvc\View\Exception

Class for exceptions thrown by Phalcon\Mvc\View

Class Phalcon\Mvc\View\Simple

Исходный код на GitHub

Namespace Phalcon\Mvc\View   Uses Closure, Phalcon\Di\DiInterface, Phalcon\Di\Injectable, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\ViewBaseInterface, Phalcon\Mvc\View\Engine\EngineInterface, Phalcon\Mvc\View\Engine\Php   Extends Injectable   Implements 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

/**
 * @var string
 */
protected activeRenderPath;

/**
 * @var string
 */
protected content;

/**
 * @var EngineInterface[]|false
 */
protected engines = false;

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

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

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

/**
 * @var string
 */
protected viewsDir;

/**
 * @var array
 */
protected viewParams;

Методы

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

Phalcon\Mvc\View\Simple constructor

public function __get( string $key ): mixed | null;

Magic method to retrieve a variable passed to the view

echo $this->view->products;
public function __set( string $key, mixed $value ): void;

Magic method to pass variables to the views

$this->view->products = $products;
public function getActiveRenderPath(): string;

Returns the path of the view that is currently rendered

public function getContent(): string;

Returns output from another view stage

public function getEventsManager(): ManagerInterface | null;

Returns the internal event manager

public function getParamsToView(): array;

Returns parameters to views

public function getRegisteredEngines(): array;
public function getVar( string $key ): mixed | null;

Returns a parameter previously set in the view

public function getViewsDir(): string;

Gets views directory

public function partial( string $partialPath, mixed $params = null ): void;

Renders a partial view

// Show a partial inside another view
$this->partial("shared/footer");
// Show a partial inside another view with parameters
$this->partial(
    "shared/footer",
    [
        "content" => $html,
    ]
);
public function registerEngines( array $engines ): void;

Register templating engines

$this->view->registerEngines(
    [
        ".phtml" => \Phalcon\Mvc\View\Engine\Php::class,
        ".volt"  => \Phalcon\Mvc\View\Engine\Volt::class,
        ".mhtml" => \MyCustomEngine::class,
    ]
);
public function render( string $path, array $params = [] ): string;

Renders a view

public function setContent( string $content ): Simple;

Externally sets the view content

$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;

Sets the events manager

public function setParamToView( string $key, mixed $value ): Simple;

Adds parameters to views (alias of setVar)

$this->view->setParamToView("products", $products);
public function setVar( string $key, mixed $value ): Simple;

Set a single view parameter

$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): Simple;

Set all the render params

$this->view->setVars(
    [
        "products" => $products,
    ]
);
public function setViewsDir( string $viewsDir ): void;

Sets views directory

final protected function internalRender( string $path, mixed $params ): void;

Tries to render the view with every engine registered in the component

protected function loadTemplateEngines(): array;

Loads registered template engines, if none are registered it will use Phalcon\Mvc\View\Engine\Php

Interface Phalcon\Mvc\ViewBaseInterface

Исходный код на GitHub

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

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple

Методы

public function getContent(): string;

Returns cached output from another view stage

public function getParamsToView(): array;

Returns parameters to views

public function getViewsDir(): string | array;

Gets views directory

public function partial( string $partialPath, mixed $params = null );

Renders a partial view

public function setContent( string $content );

Externally sets the view content

public function setParamToView( string $key, mixed $value );

Adds parameters to views (alias of setVar)

public function setVar( string $key, mixed $value );

Adds parameters to views

public function setViewsDir( string $viewsDir );

Sets views directory. Depending of your platform, always add a trailing slash or backslash

Interface Phalcon\Mvc\ViewInterface

Исходный код на GitHub

Namespace Phalcon\Mvc   Extends ViewBaseInterface

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View

Методы

public function cleanTemplateAfter();

Resets any template before layouts

public function cleanTemplateBefore();

Resets any template before layouts

public function disable();

Disables the auto-rendering process

public function enable();

Enables the auto-rendering process

public function finish();

Finishes the render process by stopping the output buffering

public function getActionName(): string;

Gets the name of the action rendered

public function getActiveRenderPath(): string | array;

Returns the path of the view that is currently rendered

public function getBasePath(): string;

Gets base path

public function getControllerName(): string;

Gets the name of the controller rendered

public function getLayout(): string;

Returns the name of the main view

public function getLayoutsDir(): string;

Gets the current layouts sub-directory

public function getMainView(): string;

Returns the name of the main view

public function getPartialsDir(): string;

Gets the current partials sub-directory

public function isDisabled(): bool;

Whether the automatic rendering is disabled

public function pick( string $renderView );

Choose a view different to render than last-controller/last-action

public function registerEngines( array $engines );

Register templating engines

public function render( string $controllerName, string $actionName, array $params = [] ): ViewInterface | bool;

Executes render process from dispatching data

public function reset();

Resets the view component to its factory default values

public function setBasePath( string $basePath );

Sets base path. Depending of your platform, always add a trailing slash or backslash

public function setLayout( string $layout );

Change the layout to be used instead of using the name of the latest controller name

public function setLayoutsDir( string $layoutsDir );

Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

public function setMainView( string $viewPath );

Sets default view name. Must be a file without extension in the views directory

public function setPartialsDir( string $partialsDir );

Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash

public function setRenderLevel( int $level ): ViewInterface;

Sets the render level for the view

public function setTemplateAfter( mixed $templateAfter );

Appends template after controller layout

public function setTemplateBefore( mixed $templateBefore );

Appends template before controller layout

public function start();

Starts rendering process enabling the output buffering