Secciones

Class Phalcon\Mvc\Application

Código fuente en 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

Este componente encapsula todas las operaciones complejas tras instanciar cada componente necesario e integrarlo con el resto para permitir al patrón MVC operar de la manera deseada.

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

Propiedades

//
protected implicitView = true;

//
protected sendCookies = true;

//
protected sendHeaders = true;

Métodos

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

Maneja una petición MVC

public function sendCookiesOnHandleRequest( bool $sendCookies ): Application;

Habilita o deshabilita el envío de cookies para cada gestión de petición

public function sendHeadersOnHandleRequest( bool $sendHeaders ): Application;

Habilita o deshabilita el envío de cabeceras para cada gestión de petición

public function useImplicitView( bool $implicitView ): Application;

Por defecto. La vista almacena implícitamente todas las salidas. Puede deshabilitar por completo el componente de vista utilizando este método

Class Phalcon\Mvc\Application\Exception

Código fuente en GitHub

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

Phalcon\Mvc\Application\Exception

Las excepciones lanzadas en la clase Phalcon\Mvc\Application usarán esta clase

Abstract Class Phalcon\Mvc\Controller

Código fuente en GitHub

Namespace Phalcon\Mvc   Uses Phalcon\Di\Injectable   Extends Injectable   Implements ControllerInterface

Phalcon\Mvc\Controller

Cada controlador de aplicación debería extender esta clase que encapsula toda la funcionalidad del controlador

El controlador proporciona el “flujo” entre modelos y vistas. Los controladores son responsables de procesar las peticiones entrantes desde el navegador web, solicitando los datos a los modelos, y pasando esos datos a las vistas para su presentación.

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

Métodos

final public function __construct();

Constructor Phalcon\Mvc\Controller

Interface Phalcon\Mvc\Controller\BindModelInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\Controller

Phalcon\Mvc\Controller\BindModelInterface

Interfaz para Phalcon\Mvc\Controller

Métodos

public static function getModelName(): string;

Devuelve el nombre del modelo asociado con este controlador

Interface Phalcon\Mvc\ControllerInterface

Código fuente en GitHub

Namespace Phalcon\Mvc

Phalcon\Mvc\ControllerInterface

Interfaz para manejadores de controlador

Class Phalcon\Mvc\Dispatcher

Código fuente en GitHub

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

Despachar es el proceso de tomar el objeto de solicitud, extraer el nombre del módulo, el nombre de controlador, el nombre de la acción, y los parámetros opcionales que contenga, y luego instanciar un controlador y llamar una acción de ese controlador.

$di = new \Phalcon\Di();

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

$dispatcher->setDI($di);

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

$controller = $dispatcher->dispatch();

Propiedades

//
protected defaultAction = index;

//
protected defaultHandler = index;

//
protected handlerSuffix = Controller;

Métodos

public function forward( array $forward ): void;

Reenvía el flujo de ejecución a otro controlador/acción.

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;

Devuelve el controlador activo en el despachador

public function getControllerClass(): string;

Posible nombre de la clase del controlador que será localizada para despachar la petición

public function getControllerName(): string;

Obtiene el nombre del último controlador despachado

public function getLastController(): ControllerInterface;

Devuelve el último controlador despachado

public function getPreviousActionName(): string;

Obtiene el nombre de la acción despachada anterior

public function getPreviousControllerName(): string;

Obtiene el nombre del controlador despachado anterior

public function getPreviousNamespaceName(): string;

Obtiene el espacio de nombres despachado anterior

public function setControllerName( string $controllerName );

Establece el nombre del controlador a despachar

public function setControllerSuffix( string $controllerSuffix );

Establece el sufijo de controlador por defecto

public function setDefaultController( string $controllerName );

Establece el nombre predeterminado del controlador

protected function handleException( \Exception $exception );

Gestiona una excepción de usuario

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

Lanza una excepción interna

Class Phalcon\Mvc\Dispatcher\Exception

Código fuente en GitHub

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

Phalcon\Mvc\Dispatcher\Exception

Las excepciones lanzadas en Phalcon\Mvc\Dispatcher usarán esta clase

Interface Phalcon\Mvc\DispatcherInterface

Código fuente en GitHub

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

Phalcon\Mvc\DispatcherInterface

Interfaz para Phalcon\Mvc\Dispatcher

Métodos

public function getActiveController(): ControllerInterface;

Devuelve el controlador activo en el despachador

public function getControllerName(): string;

Obtiene el nombre del último controlador despachado

public function getLastController(): ControllerInterface;

Devuelve el último controlador despachado

public function setControllerName( string $controllerName );

Establece el nombre del controlador a despachar

public function setControllerSuffix( string $controllerSuffix );

Establece el sufijo de controlador por defecto

public function setDefaultController( string $controllerName );

Establece el nombre predeterminado del controlador

Interface Phalcon\Mvc\EntityInterface

Código fuente en GitHub

Namespace Phalcon\Mvc

Phalcon\Mvc\EntityInterface

Interfaz para Phalcon\Mvc\Collection y Phalcon\Mvc\Model

Métodos

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

Lee un valor de atributo por su nombre

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

Escribe un valor de atributo por su nombre

Class Phalcon\Mvc\Micro

Código fuente en 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

Con Phalcon se pueden crear aplicaciones “Micro-Framework like”. Al hacer esto, solo se necesita escribir una cantidad mínima de código para crear una aplicación PHP. Las aplicaciones Micro son adecuadas de una manera práctica para aplicaciones pequeñas, APIs y prototipos.

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

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

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

Propiedades

//
protected activeHandler;

//
protected afterBindingHandlers;

//
protected afterHandlers;

//
protected beforeHandlers;

//
protected container;

//
protected errorHandler;

//
protected eventsManager;

//
protected finishHandlers;

//
protected handlers;

//
protected modelBinder;

//
protected notFoundHandler;

//
protected responseHandler;

//
protected returnedValue;

//
protected router;

//
protected stopped;

Métodos

public function __construct( DiInterface $container = null );

Constructor Phalcon\Mvc\Micro

public function after( mixed $handler ): Micro;

Añade un software intermedio “after” para ser llamado después de ejecutar la ruta

public function afterBinding( mixed $handler ): Micro;

Añade un software intermedio afterBinding para ser llamado después del enlace del modelo

public function before( mixed $handler ): Micro;

Anexa un software intermedio before para ser llamado antes de ejecutar la ruta

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

Asigna una ruta a un manejador que sólo coincide si el método HTTP es DELETE

public function error( mixed $handler ): Micro;

Configura un controlador que será llamado cuando se lance una excepción al gestionar la ruta

public function finish( mixed $handler ): Micro;

Añade un software intermedio “finish” para ser llamado cuando finalice la solicitud

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es GET

public function getActiveHandler();

Devuelve el controlador que será llamado para la ruta coincidente

public function getBoundModels(): array;

Devuelve los modelos enlazados de la instancia del enlazador

public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getHandlers(): array;

Devuelve los gestores internos adjuntos a la aplicación

public function getModelBinder(): BinderInterface | null;

Obtiene el enlazador del modelo

public function getReturnedValue();

Devuelve el valor devuelto por el gestor ejecutado

public function getRouter(): RouterInterface;

Devuelve el enrutador interno utilizado por la aplicación

public function getService( string $serviceName );

Obtiene un servicio del DI

public function getSharedService( string $serviceName );

Obtiene un servicio compartido del DI

public function handle( string $uri );

Maneja toda la solicitud

public function hasService( string $serviceName ): bool;

Comprueba si un servicio está registrado en el DI

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

Asigna una ruta a un controlador que solo coincide si el método HTTP es HEAD

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

Asigna una ruta a un controlador sin ninguna restricción de método HTTP

public function mount( CollectionInterface $collection ): Micro;

Monta una colección de gestores

public function notFound( mixed $handler ): Micro;

Configura un controlador que será llamado cuando la ruta no coincida con ninguna de las rutas definidas

public function offsetExists( mixed $alias ): bool;

Comprueba si un servicio está registrado en el contenedor de servicios interno utilizando la sintaxis de vector

public function offsetGet( mixed $alias ): mixed;

Permite obtener un servicio compartido en el contenedor de servicios interno utilizando la sintaxis de vector

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

Permite registrar un servicio compartido en el contenedor de servicios interno utilizando la sintaxis de vector

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

Elimina un servicio del contenedor de servicios interno utilizando la sintaxis de vector

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

Asigna una ruta a un controlador que solo coincide si el método HTTP es OPTIONS

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

Asigna una ruta a un controlador que solo coincide si el método HTTP es PATCH

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

Asigna una ruta a un controlador que solo coincide si el método HTTP es POST

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

Asigna una ruta a un controlador que solo coincide si el método HTTP es PUT

public function setActiveHandler( mixed $activeHandler );

Configura externamente el gestor que debe ser llamado por la ruta coincidente

public function setDI( DiInterface $container ): void;

Configura el contenedor DependencyInjector

public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el administrador de eventos

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

Configura el enlazador de modelo

$micro = new Micro($di);

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

Añade un gestor ‘response’ personalizado a ser llamado en lugar del predeterminado

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

Configura un servicio desde el DI

public function stop();

Detiene la ejecución del software intermedio evitando que se ejecuten otros softwares intermedios

Class Phalcon\Mvc\Micro\Collection

Código fuente en GitHub

Namespace Phalcon\Mvc\Micro   Implements CollectionInterface

Phalcon\Mvc\Micro\Collection

Agrupa controladores Micro-Mvc como controladores

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

$collection = new Collection();

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

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

$app->mount($collection);

Propiedades

//
protected handler;

//
protected handlers;

//
protected lazy;

//
protected prefix;

Métodos

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es DELETE.

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es GET.

public function getHandler(): mixed;

Devuelve el gestor principal

public function getHandlers(): array;

Devuelve los gestores registrados

public function getPrefix(): string;

Devuelve el prefijo de la colección (si hay alguno)

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es HEAD.

public function isLazy(): bool;

Devuelve si el gestor principal debe ser cargado de forma diferida

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

Asigna una ruta a un gestor.

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

Asigna una ruta a un gestor a través de métodos.

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es OPTIONS.

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es PATCH.

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es POST.

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es PUT.

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

Configura el gestor principal.

public function setLazy( bool $lazy ): CollectionInterface;

Establece si el gestor principal debe ser cargado de forma diferida

public function setPrefix( string $prefix ): CollectionInterface;

Configura un prefijo para todas las rutas agregadas a la colección

protected function addMap( mixed $method, string $routePattern, mixed $handler, string $name );

Una función interna para añadir un controlador al grupo.

Interface Phalcon\Mvc\Micro\CollectionInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\Micro

Phalcon\Mvc\Micro\CollectionInterface

Interfaz para Phalcon\Mvc\Micro\Collection

Métodos

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

Asigna una ruta a un manejador que sólo coincide si el método HTTP es DELETE

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es GET

public function getHandler(): mixed;

Devuelve el gestor principal

public function getHandlers(): array;

Devuelve los gestores registrados

public function getPrefix(): string;

Devuelve el prefijo de la colección (si hay alguno)

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es HEAD

public function isLazy(): bool;

Devuelve si el gestor principal debe ser cargado de forma diferida

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

Asigna una ruta a un manejador

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es OPTIONS

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es PATCH

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es POST

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

Asigna una ruta a un manejador que solo coincide si el método HTTP es PUT

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

Configura el manejador principal

public function setLazy( bool $lazy ): CollectionInterface;

Establece si el gestor principal debe ser cargado de forma diferida

public function setPrefix( string $prefix ): CollectionInterface;

Configura un prefijo para todas las rutas agregadas a la colección

Class Phalcon\Mvc\Micro\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\Micro   Extends \Phalcon\Exception

Las excepciones lanzadas en Phalcon\Mvc\Micro usarán esta clase

Class Phalcon\Mvc\Micro\LazyLoader

Código fuente en GitHub

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

Phalcon\Mvc\Micro\LazyLoader

Carga perezosa de manejadores para Mvc\Micro utilizando la autocarga

Propiedades

//
protected handler;

//
protected definition;

Métodos

public function __construct( string $definition );

Constructor Phalcon\Mvc\Micro\LazyLoader

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

Método de llamada __call

public function getDefinition()
public function getHandler()

Interface Phalcon\Mvc\Micro\MiddlewareInterface

Código fuente en GitHub

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

Permite implementar el software intermedio Phalcon\Mvc\Micro en clases

Métodos

public function call( Micro $application );

Llama al software intermedio

Abstract Class Phalcon\Mvc\Model

Código fuente en GitHub

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

Phalcon\Mvc\Model

Phalcon\Mvc\Model conecta objetos de negocio y tablas de base de datos para crear un modelo de dominio persistente donde la lógica y los datos se presentan en una envoltura. Es una implementación del mapeo objeto-relacional (ORM).

Un modelo representa la información (datos) de la aplicación y las reglas para manipular estos datos. Los modelos se utilizan principalmente para gestionar las reglas de interacción con una correspondiente tabla de base de datos. En la mayoría de los casos, cada tabla de la base de datos corresponderá a un modelo en su aplicación. La mayor parte de la lógica de negocio de su aplicación se concentrará en los modelos.

Phalcon\Mvc\Model es el primer ORM escrito en los lenguajes Zephir/C para PHP, lo que ofrece a los desarrolladores un alto rendimiento cuando se interactúa con bases de datos y que también es fácil de utilizar.

$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!";
}

Constantes

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;

Propiedades

//
protected dirtyState = 1;

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

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

//
protected modelsManager;

//
protected modelsMetaData;

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

//
protected operationMade = 0;

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

//
protected skipped;

//
protected snapshot;

//
protected transaction;

//
protected uniqueKey;

//
protected uniqueParams;

//
protected uniqueTypes;

Métodos

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

Gestiona las llamadas a métodos cuando un método no se ha implementado

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

Gestiona las llamadas a métodos cuando un método estático no se ha implementado

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

Constructor Phalcon\Mvc\Model

public function __get( string $property );

Método mágico para obtener registros relacionados usando el alias de la relación como una propiedad

public function __isset( string $property ): bool;

Método mágico que comprueba si una propiedad es una relación válida

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

Método mágico para asignar valores a el modelo

public function addBehavior( BehaviorInterface $behavior ): void;

Configura un comportamiento en un modelo

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;

Añade un mensaje personalizado a un proceso de validación

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;

Asigna valores a un modelo desde un vector

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

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

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

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

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

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

Devuelve el valor medio en una columna para un conjunto de resultados de filas que coinciden con las condiciones especificadas.

El valor devuelto será un float para consultas simples o una instancia de ResultsetInterface para cuando se utilice la condición GROUP. Los resultados contendrán la media de cada grupo.

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

Asigna valores a un modelo desde un vector devolviendo un nuevo modelo

$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;

Asigna valores a un modelo desde un vector, devolviendo un nuevo modelo.

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

Devuelve un resultado hidratado basado en los datos y el mapa de columnas

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

Cuenta cuantos registros coinciden con las condiciones especificadas.

Devuelve un entero para consultas simples o una instancia de ResultsetInterface para cuando se utiliza la condición GROUP. Los resultados contendrán el contador de cada grupo.

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

Inserta una instancia de modelo. Si la instancia ya existe en la persistencia producirá una excepción. Devuelve true si tiene éxito, de lo contrario devuelve false.

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

Borra una instancia del modelo. Devuelve true en caso de éxito o false en caso contrario.

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

$robot->delete();

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

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

Devuelve una representación simple del objeto que se puede usar con var_dump()

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

Consulta un conjunto de registros que coinciden con las condiciones especificadas

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

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

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

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

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

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

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

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

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

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

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

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

$newRobot->save();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Consulta el primer registro que coincide con las condiciones especificadas

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

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

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

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

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

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

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

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

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

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

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

$transaction->commit();

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

Dispara un evento, llama implícitamente a comportamientos y se notifica a los oyentes del gestor de eventos

public function fireEventCancel( string $eventName ): bool;

Dispara un evento, implícitamente se notifica a los comportamientos y oyentes de las llamadas en el gestor de eventos. Este método se detiene si una de las funciones de retorno/oyentes devuelve el valor booleano false

public function getChangedFields(): array;

Devuelve una lista de valores cambiados.

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

$robots->deleted = 'Y';

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

Devuelve una de las constantes DIRTY_STATE_* que indica si el registro existe en la base de datos o no

public function getEventsManager(): EventsManagerInterface | null;

Devuelve el gestor de eventos personalizado o nulo si no hay ningún gestor de eventos personalizado

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

Devuelve un vector de mensajes de validación

$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;

Devuelve el gestor de modelos relacionado con la instancia de la entidad

public function getModelsMetaData(): MetaDataInterface;

{@inheritdoc}

public function getOldSnapshotData(): array;

Devuelve los datos de instantánea internos antiguos

public function getOperationMade(): int;

Devuelve el tipo de la operación realizada por el ORM más reciente. Devuelve una de las constantes de clase OP_*

final public function getReadConnection(): AdapterInterface;

Obtiene la conexión usada para leer datos del modelo

final public function getReadConnectionService(): string;

Devuelve el nombre del servicio de conexión de DependencyInjection usado para leer datos relacionados del modelo

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

Devuelve registros relacionados basados en relaciones definidas

final public function getSchema(): string;

Devuelve el nombre del esquema donde se encuentra la tabla mapeada

public function getSnapshotData(): array;

Devuelve los datos de instantánea internos

final public function getSource(): string;

Devuelve el nombre de tabla mapeada en el modelo

public function getTransaction()
public function getUpdatedFields(): array;

Devuelve una lista de valores actualizados.

$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;

Obtiene la conexión usada para escribir datos al modelo

final public function getWriteConnectionService(): string;

Devuelve el nombre del servicio de conexión de DependencyInjection usado para escribir datos relacionados al modelo

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

Comprueba si un atributo específico ha cambiado. Esto solo funciona si el modelo mantiene instantáneas de los datos

$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;

Comprueba si el objeto tiene datos de instantánea internos

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

Comprueba si un atributo específico fue actualizado. Esto solo funciona si el modelo mantiene instantáneas de los datos

public function isRelationshipLoaded( string $relationshipAlias ): bool;

Comprueba si los registros relacionados guardados ya se han cargado.

Sólo devuelve true si los registros se obtuvieron previamente a través del modelo sin ningún parámetro adicional.

$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;

Serializa el objeto por json_encode

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

Devuelve el valor máximo de una columna para un conjunto de resultados de filas que coinciden con las condiciones especificadas

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

Devuelve el valor mínimo de una columna para un conjunto de resultados de filas que coinciden con las condiciones especificadas

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

Crea un criterio para un modelo específico

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

Lee un valor de atributo por su nombre

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

Refresca los atributos del modelo consultando otra vez el registro desde la base de datos

public function save(): bool;

Inserta o actualiza una instancia de modelo. Devuelve true en caso de éxito o false en caso contrario.

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

Serializa el objeto ignorando conexiones, servicios, objetos relacionados o propiedades estáticas

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

Establece el nombre del servicio de conexión DependencyInjection

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

Establece el estado de suciedad del objeto usando una de las constantes DIRTY_STATE_*

public function setEventsManager( EventsManagerInterface $eventsManager );

Establece un gestor de eventos personalizado

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

Establece los datos viejos de instantánea del registro. Este método se usa internamente para establecer datos de instantánea viejos cuando el modelo haya sido configurado para mantener datos de instantánea

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

Establece el nombre de servicio de conexión DependencyInjection usado para leer datos

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

Establece los datos de instantánea del registro. Este método se usa internamente para establecer los datos de instantánea cuando el modelo haya sido configurado para mantener datos de instantánea

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Establece una transacción relacionada con la instancia del modelo

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;

Establece el nombre de servicio de conexión DependencyInjection usado para escribir datos

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

Habilita/deshabilita las opciones en el ORM

public function skipOperation( bool $skip ): void;

Omite la operación actual forzando un estado de éxito

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

Calcula la suma de una columna para un conjunto de resultados de filas que coinciden con las condiciones especificadas

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

Devuelve la instancia como una representación de vector

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

Deserializa el objeto desde una cadena serializada

public function update(): bool;

Actualiza una instancia de modelo. Si la instancia no existe en la persistencia lanzará una excepción. Devuelve true en caso de éxito o false en caso contrario.

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

$robot->name = "Biomass";

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

Comprueba si el proceso de validación ha generado algún mensaje

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

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

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

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

Escribe un valor de atributo por su nombre

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

Cancela la operación actual

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

final protected function _checkForeignKeysRestrict(): bool;

Lee relaciones “belongs to” y comprueba las claves virtuales externas cuando se insertan o actualizan registros para verificar que los valores insertados o actualizados estén presentes en la entidad relacionada

final protected function _checkForeignKeysReverseCascade(): bool;

Lee las relaciones “hasMany” y “hasOne” y comprueba las claves virtuales externas (cascada) cuando se eliminan registros

final protected function _checkForeignKeysReverseRestrict(): bool;

Lee las relaciones “hasMany” y “hasOne” y comprueba las claves virtuales externas (restringida) cuando se eliminan registros

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

Envía una sentencia SQL INSERT preconstruida al sistema de base de datos relacional

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

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

Envía una sentencia SQL UPDATE preconstruida al sistema de base de datos relacional

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

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

Comprueba si el registro actual ya existe

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

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

Devuelve las relaciones definidas de los registros relacionados dependiendo del nombre del método. Devuelve falso si la relación no existe.

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

protected static function _groupResult( string $functionName, string $alias, mixed $parameters ): ResultsetInterface;

Genera una sentencia PHQL SELECT para un agregado

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

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

Comprueba, e intenta usar, un posible setter.

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

Ejecuta eventos internos después de guardar un registro

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

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

Guarda los archivos relacionados asignados en las relaciones tiene-uno/tiene-muchos

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

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

Ejecuta enlaces internos antes de guardar un registro

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

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

Guarda los registros relacionados que deben almacenarse antes de guardar el registro maestro

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

protected function allowEmptyStringValues( array $attributes ): void;

Establece una lista de atributos que se deben omitir de la sentencia UPDATE generada

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

Configura una relación 1-1 inversa o n-1 entre dos modelos

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

Cancela la operación actual

protected function collectRelatedToSave(): array;

Recoge registros relacionados previamente consultados (belongs-to, has-one y has-one-through) junto con uno recién añadido

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

Envía una sentencia SQL INSERT preconstruida al sistema de base de datos relacional

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

Envía una sentencia SQL UPDATE preconstruida al sistema de base de datos relacional

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

Comprueba si el registro actual ya existe

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

Devuelve las relaciones definidas de los registros relacionados dependiendo del nombre del método. Devuelve falso si la relación no existe.

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

Genera una sentencia PHQL SELECT para un agregado

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

Configura una relación 1-n entre dos modelos

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

Configura una relación n-n entre dos modelos, a través de una relación intermedia

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

Configura una relación 1-1 entre dos modelos

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

Configura una relación 1-1 entre dos modelos, a través de una relación intermedia

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;

Configura si el modelo debe mantener la instantánea del registro original en memoria

use Phalcon\Mvc\Model;

class Robots extends Model
{
    public function initialize()
    {
        $this->keepSnapshots(true);
    }
}
protected function postSave( bool $success, bool $exists ): bool;

Ejecuta eventos internos después de guardar un registro

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

Guarda los archivos relacionados asignados en las relaciones tiene-uno/tiene-muchos

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

Ejecuta enlaces internos antes de guardar un registro

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

Guarda los registros relacionados que deben almacenarse antes de guardar el registro maestro

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

Establece el nombre del esquema donde se ubica la tabla mapeada

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

Establece el nombre de tabla al que se debe mapear el modelo

protected function skipAttributes( array $attributes );

Configura una lista de atributos que se deben omitir de la sentencia INSERT/UPDATE generada

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

Configura una lista de atributos que se deben omitir de la declaración INSERT generada

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

Establece una lista de atributos que se deben omitir de la sentencia UPDATE generada

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

Establece si el modelo debe usar actualización dinámica en vez de actualizar todos los campos

use Phalcon\Mvc\Model;

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

Ejecuta los validadores en cada llamada de validación

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

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

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

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

Abstract Class Phalcon\Mvc\Model\Behavior

Código fuente en GitHub

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

Phalcon\Mvc\Model\Behavior

Este es una clase base opcional para comportamientos ORM

Propiedades

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

Métodos

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

Phalcon\Mvc\Model\Behavior

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

Actúa como respaldo cuando se llama un método inexistente en el modelo

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

Este método recibe las notificaciones del EventsManager

protected function getOptions( string $eventName = null );

Devuelve las opciones de comportamiento relacionadas a un evento

protected function mustTakeAction( string $eventName ): bool;

Comprueba si el comportamiento debe actuar en ciertos eventos

Class Phalcon\Mvc\Model\Behavior\SoftDelete

Código fuente en 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

En lugar de borrar permanentemente un registro, marca el registro como borrado cambiando el valor de una columna bandera

Métodos

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

Escucha las notificaciones del gestor de modelos

Class Phalcon\Mvc\Model\Behavior\Timestampable

Código fuente en 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

Permite actualizar automáticamente el atributo del modelo guardando la fecha y hora cuando se creó o actualizó el registro

Métodos

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

Escucha las notificaciones del gestor de modelos

Interface Phalcon\Mvc\Model\BehaviorInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\BehaviorInterface

Interfaz para Phalcon\Mvc\Model\Behavior

Métodos

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

Llama a un método cuando falta en el modelo

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

Este método recibe las notificaciones del EventsManager

Class Phalcon\Mvc\Model\Binder

Código fuente en 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

Esta es una clase para vincular modelos en parámetros para el manejador

Propiedades

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

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

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

/**
 * Array for original values
 */
protected originalValues;

Métodos

public function __construct( AdapterInterface $cache = null );

Constructor Phalcon\Mvc\Model\Binder

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

Vincular modelos en parámetros en el manejador apropiado

public function getBoundModels(): array
public function getCache(): AdapterInterface;

Establece la instancia de caché

public function getOriginalValues()
public function setCache( AdapterInterface $cache ): BinderInterface;

Obtiene instancia de caché

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

Encuentra el modelo por valor de parámetro.

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

Obtener parámetros de clases del caché por clave

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

Obtener parámetros modificados para el manejador usando la reflexión

Interface Phalcon\Mvc\Model\Binder\BindableInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\Model\Binder

Phalcon\Mvc\Model\Binder\BindableInterface

Interfaz para clases vinculables

Métodos

public function getModelName(): string | array;

Devuelve el nombre del modelo o los nombres de los modelos y las claves de parámetros asociadas con esta clase

Interface Phalcon\Mvc\Model\BinderInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\BinderInterface

Interfaz para Phalcon\Mvc\Model\Binder

Métodos

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

Vincular modelos en parámetros en el manejador apropiado

public function getBoundModels(): array;

Obtiene modelos enlazados activos

public function getCache(): AdapterInterface;

Obtiene instancia de caché

public function setCache( AdapterInterface $cache ): BinderInterface;

Establece la instancia de caché

Class Phalcon\Mvc\Model\Criteria

Código fuente en GitHub

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

Phalcon\Mvc\Model\Criteria

Esta clase se usa para construir el parámetro de vector requerido por Phalcon\Mvc\Model::find() y Phalcon\Mvc\Model::findFirst() usando una interfaz orientada a objetos.

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

Propiedades

//
protected bindParams;

//
protected bindTypes;

//
protected hiddenParamNumber = 0;

//
protected model;

//
protected params;

Métodos

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

Añade una condición a las condiciones actuales usando un operador AND

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

Añade una condición BETWEEN a las condiciones actuales

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

Establece los parámetros enlazados en los criterios Este método reemplaza todos los parámetros vinculados establecidos previamente

public function bindTypes( array $bindTypes ): CriteriaInterface;

Establece los tipos de enlace en los criterios Este método reemplaza todos los parámetros vinculados establecidos previamente

public function cache( array $cache ): CriteriaInterface;

Establece las opciones de cache en los criterios Este método reemplaza todas las opciones de cache establecidas previamente

public function columns( mixed $columns ): CriteriaInterface;

Establece las columnas a consultar

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

Añade el parámetro de condiciones a los criterios

public function createBuilder(): BuilderInterface;

Crea un constructor de consultas a partir de criterios.

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

Establece la bandera SELECT DISTINCT / SELECT ALL

public function execute(): ResultsetInterface;

Ejecuta una búsqueda usando los parámetros construidos con los criterios

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

Añade el parámetro “for_update” al criterio

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

Construye un Phalcon\Mvc\Model\Criteria basado en un vector de entrada como $_POST

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

Devuelve las columnas a ser consultadas

public function getConditions(): string | null;

Devuelve el parámetro de condiciones en los criterios

public function getDI(): DiInterface;

Devuelve el contenedor DependencyInjector

public function getGroupBy();

Devuelve la cláusula de grupo en los criterios

public function getHaving();

Devuelve la cláusula having en los criterios

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

Devuelve el parámetro de límite en los criterios, que será

  • Un entero si ‘limit’ se configuró sin un ‘offset’
  • Una vector con las claves ‘number’ y ‘offset’ si se configuró un desplazamiento con el límite
  • NULL si no se ha establecido el límite
public function getModelName(): string;

Devuelve un nombre de modelo interno al que se le aplicarán los criterios

public function getOrderBy(): string | null;

Devuelve la cláusula de orden en los criterios

public function getParams(): array;

Devuelve todos los parámetros definidos en los criterios

public function getWhere(): string | null;

Devuelve el parámetro de condiciones en los criterios

public function groupBy( mixed $group ): CriteriaInterface;

Añade la cláusula group-by a los criterios

public function having( mixed $having ): CriteriaInterface;

Añade la cláusula having a los criterios

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

Añade una condición IN a las condiciones actuales

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

Añade un INNER join a la consulta

$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;

Añade un INNER join a la consulta

$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;

Añade un LEFT join a la consulta

$criteria->leftJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function limit( int $limit, int $offset = int ): CriteriaInterface;

Añade el parámetro límite a los criterios.

$criteria->limit(100);
$criteria->limit(100, 200);
$criteria->limit("100", "200");
public function notBetweenWhere( string $expr, mixed $minimum, mixed $maximum ): CriteriaInterface;

Añade una condición NOT BETWEEN a las condiciones actuales

$criteria->notBetweenWhere("price", 100.25, 200.50);
public function notInWhere( string $expr, array $values ): CriteriaInterface;

Añade una condición NOT IN a las condiciones actuales

$criteria->notInWhere("id", [1, 2, 3]);
public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Añade una condición a las condiciones actuales usando un operador OR

public function orderBy( string $orderColumns ): CriteriaInterface;

Añade la cláusula order-by a los criterios

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

Añade un RIGHT join a la consulta

$criteria->rightJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function setDI( DiInterface $container ): void;

Configura el contenedor DependencyInjector

public function setModelName( string $modelName ): CriteriaInterface;

Establece un modelo en el que se ejecutará la consulta

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

Añade el parámetro “shared_lock” al criterio

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

Establece el parámetro de condiciones en los criterios

Interface Phalcon\Mvc\Model\CriteriaInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\CriteriaInterface

Interfaz para Phalcon\Mvc\Model\Criteria

Métodos

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

Añade una condición a las condiciones actuales usando un operador AND

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

Añade una condición BETWEEN a las condiciones actuales

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

Establece los parámetros enlazados en los criterios Este método reemplaza todos los parámetros vinculados establecidos previamente

public function bindTypes( array $bindTypes ): CriteriaInterface;

Establece los tipos de enlace en los criterios Este método reemplaza todos los parámetros vinculados establecidos previamente

public function cache( array $cache ): CriteriaInterface;

Establece las opciones de cache en los criterios Este método reemplaza todas las opciones de cache establecidas previamente

public function conditions( string $conditions ): CriteriaInterface;

Añade el parámetro de condiciones a los criterios

public function distinct( mixed $distinct ): CriteriaInterface;

Establece la bandera SELECT DISTINCT / SELECT ALL

public function execute(): ResultsetInterface;

Ejecuta una búsqueda usando los parámetros construidos con los criterios

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

Establece el parámetro “for_update” al criterio

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

Devuelve las columnas a ser consultadas

public function getConditions(): string | null;

Devuelve el parámetro de condiciones en los criterios

public function getGroupBy();

Devuelve la cláusula de grupo en los criterios

public function getHaving();

Devuelve la cláusula having en los criterios

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

Devuelve el parámetro de límite en los criterios, que será

  • Un entero si ‘limit’ se configuró sin un ‘offset’
  • Una vector con las claves ‘number’ y ‘offset’ si se configuró un desplazamiento con el límite
  • NULL si no se ha establecido el límite
public function getModelName(): string;

Devuelve un nombre de modelo interno al que se le aplicarán los criterios

public function getOrderBy(): string | null;

Devuelve el parámetro orden en los criterios

public function getParams(): array;

Devuelve todos los parámetros definidos en los criterios

public function getWhere(): string | null;

Devuelve el parámetro de condiciones en los criterios

public function groupBy( mixed $group ): CriteriaInterface;

Añade la cláusula group-by a los criterios

public function having( mixed $having ): CriteriaInterface;

Añade la cláusula having a los criterios

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

Añade una condición IN a las condiciones actuales

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

Añade un INNER join a la consulta

$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;

Añade un LEFT join a la consulta

$criteria->leftJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function limit( int $limit, int $offset = int ): CriteriaInterface;

Establece el parámetro límite a los criterios

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

Añade una condición NOT BETWEEN a las condiciones actuales

$criteria->notBetweenWhere("price", 100.25, 200.50);
public function notInWhere( string $expr, array $values ): CriteriaInterface;

Añade una condición NOT IN a las condiciones actuales

$criteria->notInWhere("id", [1, 2, 3]);
public function orWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;

Añade una condición a las condiciones actuales usando un operador OR

public function orderBy( string $orderColumns ): CriteriaInterface;

Añade el parámetro order-by a los criterios

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

Añade un RIGHT join a la consulta

$criteria->rightJoin(
    Robots::class,
    "r.id = RobotsParts.robots_id",
    "r"
);
public function setModelName( string $modelName ): CriteriaInterface;

Establece un modelo en el que se ejecutará la consulta

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

Establece el parámetro “shared_lock” al criterio

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

Establece el parámetro de condiciones en los criterios

Class Phalcon\Mvc\Model\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\Model   Extends \Phalcon\Exception

Phalcon\Mvc\Model\Exception

Las excepciones lanzadas en clases Phalcon\Mvc\Model* usarán esta clase

Class Phalcon\Mvc\Model\Manager

Código fuente en GitHub

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

Phalcon\Mvc\Model\Manager

Este componente controla la inicialización de modelos, manteniendo el registro de relaciones entre los diferentes modelos de la aplicación.

Se inyecta un ModelsManager a un modelo a través de un Inyector de Dependencias/Contenedor de Servicios como Phalcon\Di.

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

$di = new Di();

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

$robot = new Robots($di);

Propiedades

//
protected aliases;

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

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

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

//
protected container;

//
protected customEventsManager;

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

//
protected eventsManager;

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

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

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

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

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

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

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

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

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

//
protected keepSnapshots;

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

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

//
protected modelVisibility;

//
protected prefix = ;

//
protected readConnectionServices;

//
protected sources;

//
protected schemas;

//
protected writeConnectionServices;

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

Métodos

public function __destruct();

Destruye la caché PHQL actual

public function _getConnectionService( ModelInterface $model, mixed $connectionServices ): string;

Devuelve el nombre del servicio de conexión usado para leer o escribir datos relacionados con un modelo dependiendo de los servicios de conexión

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

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

Enlaza un comportamiento a un modelo

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

Configura una relación inversa muchos a uno entre dos modelos

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

Configura una relación 1-n entre dos modelos

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

Configura una relación n-m entre dos modelos

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

Configura una relación 1-1 entre dos modelos

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

Configura una relación 1-1 entre dos modelos utilizando un modelo intermedio

public function clearReusableObjects(): void;

Limpia la lista reutilizable interna

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

Crea un Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

Crea un Phalcon\Mvc\Model\Query sin ejecutarlo

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

Crea un Phalcon\Mvc\Model\Query y lo ejecuta

$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;

Comprueba si un modelo tiene una relación belongsTo con otro modelo

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

Comprueba si un modelo tiene una relación hasMany con otro modelo

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

Comprueba si un modelo tiene una relación hasManyToMany con otro modelo

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

Comprueba si un modelo tiene una relación hasOne con otro modelo

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

Comprueba si un modelo tiene una relación hasOneThrough con otro modelo

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

Obtiene todas las relaciones belongsTo definidas en un modelo

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

Obtiene los registros belongsTo relacionados desde un modelo

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

Devuelve el nombre del servicio de conexión usado para leer o escribir datos relacionados con un modelo dependiendo de los servicios de conexión

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

Devuelve un gestor de eventos personalizado relacionado con un modelo o nulo si no hay gestor de eventos relacionado

public function getDI(): DiInterface;

Devuelve el contenedor DependencyInjector

public function getEventsManager(): EventsManagerInterface;

Devuelve el administrador de eventos interno

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

Obtiene las relaciones hasMany definidas en un modelo

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

Obtiene los registros hasMany relacionados desde un modelo

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

Obtiene las relaciones hasManyToMany definidas en un modelo

public function getHasOne( ModelInterface $model ): array;

Obtiene las relaciones hasOne definidas en un modelo

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

Obtiene las relaciones hasOne definidas en un modelo

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

Obtiene los registros belongsTo relacionados desde un modelo

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

Obtiene las relaciones hasOneThrough definidas en un modelo

public function getLastInitialized(): ModelInterface;

Obtiene el último modelo inicializado

public function getLastQuery(): QueryInterface;

Devuelve la última consulta creada o ejecutada en el gestor de modelos

public function getModelPrefix(): string;

Devuelve el prefijo para todas las fuentes del modelo.

public function getModelSchema( ModelInterface $model ): string;

Devuelve el esquema mapeado para un modelo

public function getModelSource( ModelInterface $model ): string;

Devuelve la fuente mapeada para un modelo

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Devuelve la conexión para leer datos relacionada con un modelo

public function getReadConnectionService( ModelInterface $model ): string;

Devuelve el nombre del servicio de conexión usado para leer datos relacionado con un modelo

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

Devuelve una relación por su alias

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

Método auxiliar para consultar registros basado en una definición de relación

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

Consulta todas las relaciones definidas en un modelo

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

Consulta la primera relación definida entre dos modelos

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

Devuelve un objeto reutilizable de la lista interna

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Devuelve la conexión para escribir datos relacionada con un modelo

public function getWriteConnectionService( ModelInterface $model ): string;

Devuelve el nombre del servicio de conexión usado para escribir datos relacionado con un modelo

public function initialize( ModelInterface $model ): bool;

Inicializa un modelo en el gestor de modelos

public function isInitialized( string $className ): bool;

Comprueba si un modelo está ya inicializado

public function isKeepingSnapshots( ModelInterface $model ): bool;

Comprueba si un modelo mantiene instantáneas para los registros consultados

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

Comprueba si un modelo está usando una actualización dinámica en lugar de una actualización de todos los campos

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

Compruebe si una propiedad de modelo está declarada como pública.

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

Establece si un modelo debe mantener instantáneas

public function load( string $modelName ): ModelInterface;

Carga un modelo lanzando una excepción si no existe

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

Envía un evento a los oyentes y a los comportamientos. Este método espera que los oyentes/comportamientos del punto de conexión devuelvan true, lo que significa que al menos uno fue implementado

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

Recibe eventos generados en los modelos y los envía a un gestor de eventos si está disponible. Notifica los comportamientos que están escuchando en el modelo

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

Establece el servicio de conexión de escritura y lectura para un modelo

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

Establece un gestor de eventos personalizado para un modelo específico

public function setDI( DiInterface $container ): void;

Configura el contenedor DependencyInjector

public function setEventsManager( EventsManagerInterface $eventsManager ): void;

Establece un gestor de eventos global

public function setModelPrefix( string $prefix ): void;

Establece el prefijo para todas las fuentes de modelo.

use Phalcon\Mvc\Model\Manager;

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

        $modelsManager->setModelPrefix("wp_");

        return $modelsManager;
    }
);

$robots = new Robots();

echo $robots->getSource(); // wp_robots
public function setModelSchema( ModelInterface $model, string $schema ): void;

Establece el esquema mapeado para un modelo

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

Establece la fuente mapeada para un modelo

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

Establece el servicio de conexión de lectura para un modelo

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

Almacena un registro reutilizable en la lista interna

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

Establece el servicio de conexión de escritura para un modelo

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

Establece si el modelo debe usar actualización dinámica en vez de actualizar todos los campos

protected function _getConnection( ModelInterface $model, mixed $connectionServices ): AdapterInterface;

Devuelve la conexión para leer o escribir datos relacionados con un modelo dependiendo de los servicios de conexión.

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

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

Une dos vectores de parámetros de búsqueda

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

Devuelve la conexión para leer o escribir datos relacionados con un modelo dependiendo de los servicios de conexión.

Interface Phalcon\Mvc\Model\ManagerInterface

Código fuente en 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

Interfaz para Phalcon\Mvc\Model\Manager

Métodos

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

Enlaza un comportamiento a un modelo

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

Configura una relación 1-1 entre dos modelos

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

Configura una relación 1-n entre dos modelos

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

Configura una relación n-m entre dos modelos

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

Configura una relación 1-1 entre dos modelos

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

Configura una relación 1-1 entre dos modelos utilizando una tabla intermedia

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

Crea un Phalcon\Mvc\Model\Query\Builder

public function createQuery( string $phql ): QueryInterface;

Crea un Phalcon\Mvc\Model\Query sin ejecutarlo

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

Crea un Phalcon\Mvc\Model\Query y lo ejecuta

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

Comprueba si un modelo tiene una relación belongsTo con otro modelo

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

Comprueba si un modelo tiene una relación hasMany con otro modelo

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

Comprueba si un modelo tiene una relación hasManyToMany con otro modelo

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

Comprueba si un modelo tiene una relación hasOne con otro modelo

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

Comprueba si un modelo tiene una relación hasOneThrough con otro modelo

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

Obtiene las relaciones belongsTo definidas en un modelo

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

Obtiene los registros belongsTo relacionados desde un modelo

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

Obtiene las relaciones hasMany definidas en un modelo

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

Obtiene los registros hasMany relacionados desde un modelo

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

Obtiene las relaciones hasManyToMany definidas en un modelo

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

Obtiene las relaciones hasOne definidas en un modelo

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

Obtiene las relaciones hasOne definidas en un modelo

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

Obtiene los registros hasOne relacionados desde un modelo

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

Obtiene las relaciones hasOneThrough definidas en un modelo

public function getLastInitialized(): ModelInterface;

Obtiene el último modelo inicializado

public function getLastQuery(): QueryInterface;

Devuelve la última consulta creada o ejecutada en el gestor de modelos

public function getModelSchema( ModelInterface $model ): string;

Devuelve el esquema mapeado para un modelo

public function getModelSource( ModelInterface $model ): string;

Devuelve la fuente mapeada para un modelo

public function getReadConnection( ModelInterface $model ): AdapterInterface;

Devuelve la conexión para leer datos relacionada con un modelo

public function getReadConnectionService( ModelInterface $model ): string;

Devuelve el nombre del servicio de conexión usado para leer datos relacionado con un modelo

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

Devuelve una relación por su alias

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

Método auxiliar para consultar registros basado en una definición de relación

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

Consulta todas las relaciones definidas en un modelo

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

Consulta las relaciones entre dos modelos

public function getWriteConnection( ModelInterface $model ): AdapterInterface;

Devuelve la conexión para escribir datos relacionada con un modelo

public function getWriteConnectionService( ModelInterface $model ): string;

Devuelve el nombre del servicio de conexión usado para escribir datos relacionado con un modelo

public function initialize( ModelInterface $model );

Inicializa un modelo en el gestor de modelos

public function isInitialized( string $className ): bool;

Comprueba si un modelo está ya inicializado

public function isKeepingSnapshots( ModelInterface $model ): bool;

Comprueba si un modelo mantiene instantáneas para los registros consultados

public function isUsingDynamicUpdate( ModelInterface $model ): bool;

Comprueba si un modelo está usando una actualización dinámica en lugar de una actualización de todos los campos

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

Compruebe si una propiedad de modelo está declarada como pública.

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

Establece si un modelo debe mantener instantáneas

public function load( string $modelName ): ModelInterface;

Carga un modelo lanzando una excepción si no existe

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

Envía un evento a los oyentes y a los comportamientos. Este método espera que los oyentes/comportamientos del punto de conexión devuelvan true, lo que significa que al menos uno fue implementado

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

Recibe los eventos generados en los modelos y los envía al gestor de eventos si está disponible. Notifica los comportamientos que están escuchando en el modelo

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

Establece el servicio de conexión de escritura y lectura para un modelo

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

Establece el esquema mapeado para un modelo

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

Establece la fuente mapeada para un modelo

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

Establece el servicio de conexión de lectura para un modelo

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

Establece el servicio de conexión de escritura para un modelo

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

Establece si el modelo debe usar actualización dinámica en vez de actualizar todos los campos

Abstract Class Phalcon\Mvc\Model\MetaData

Código fuente en 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

Porque Phalcon\Mvc\Model requiere meta-datos como nombres de campos, tipos de datos, claves primarias, etc. Este componente los recoge y almacena para consultas posteriores de Phalcon\Mvc\Model. Phalcon\Mvc\Model\MetaData también puede utilizar adaptadores para almacenar temporal o permanentemente los meta-datos.

Se puede usar un Phalcon\Mvc\Model\MetaData estándar para consultar los atributos del modelo:

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

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

print_r($attributes);

Constantes

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;

Propiedades

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

//
protected columnMap;

//
protected container;

//
protected metaData;

//
protected strategy;

Métodos

public function getAttributes( ModelInterface $model ): array;

Devuelve los nombres de los atributos de la tabla (campos)

print_r(
    $metaData->getAttributes(
        new Robots()
    )
);
public function getAutomaticCreateAttributes( ModelInterface $model ): array;

Devuelve los atributos que se deben ignorar en la generación del SQL INSERT

print_r(
    $metaData->getAutomaticCreateAttributes(
        new Robots()
    )
);
public function getAutomaticUpdateAttributes( ModelInterface $model ): array;

Devuelve los atributos que se deben ignorar de la generación del SQL UPDATE

print_r(
    $metaData->getAutomaticUpdateAttributes(
        new Robots()
    )
);
public function getBindTypes( ModelInterface $model ): array;

Devuelve los atributos y sus tipos de datos de enlace

print_r(
    $metaData->getBindTypes(
        new Robots()
    )
);
public function getColumnMap( ModelInterface $model ): array | null;

Devuelve el mapa de columnas si lo hay

print_r(
    $metaData->getColumnMap(
        new Robots()
    )
);
public function getDI(): DiInterface;

Devuelve el contenedor DependencyInjector

public function getDataTypes( ModelInterface $model ): array;

Devuelve los atributos y sus tipos de datos

print_r(
    $metaData->getDataTypes(
        new Robots()
    )
);
public function getDataTypesNumeric( ModelInterface $model ): array;

Devuelve los atributos con tipos numéricos

print_r(
    $metaData->getDataTypesNumeric(
        new Robots()
    )
);
public function getDefaultValues( ModelInterface $model ): array;

Devuelve los atributos (que tienen valores por defecto) y sus valores por defecto

print_r(
    $metaData->getDefaultValues(
        new Robots()
    )
);
public function getEmptyStringAttributes( ModelInterface $model ): array;

Devuelve atributos que permiten cadenas vacías

print_r(
    $metaData->getEmptyStringAttributes(
        new Robots()
    )
);
public function getIdentityField( ModelInterface $model ): string | null;

Devuelve el nombre del campo identidad (si hay uno presente)

print_r(
    $metaData->getIdentityField(
        new Robots()
    )
);
public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;

Devuelve un vector de campos que no forman parte de la clave primaria

print_r(
    $metaData->getNonPrimaryKeyAttributes(
        new Robots()
    )
);
public function getNotNullAttributes( ModelInterface $model ): array;

Devuelve un vector de atributos no nulos

print_r(
    $metaData->getNotNullAttributes(
        new Robots()
    )
);
public function getPrimaryKeyAttributes( ModelInterface $model ): array;

Devuelve un vector de campos que forman parte de la clave primaria

print_r(
    $metaData->getPrimaryKeyAttributes(
        new Robots()
    )
);
public function getReverseColumnMap( ModelInterface $model ): array | null;

Devuelve el mapa de columnas inverso si existe

print_r(
    $metaData->getReverseColumnMap(
        new Robots()
    )
);
public function getStrategy(): StrategyInterface;

Devuelve la estrategia para obtener los metadatos

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

Comprueba si un modelo tiene cierto atributo

var_dump(
    $metaData->hasAttribute(
        new Robots(),
        "name"
    )
);
public function isEmpty(): bool;

Comprueba si el contenedor de metadatos interno está vacío

var_dump(
    $metaData->isEmpty()
);
public function read( string $key ): array | null;

Lee los metadatos del adaptador

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

Lee el mapa de columnas ordenado/inverso para cierto modelo

print_r(
    $metaData->readColumnMap(
        new Robots()
    )
);
final public function readColumnMapIndex( ModelInterface $model, int $index );

Lee información del mapa de columnas para cierto modelo usando una constante MODEL_*

print_r(
    $metaData->readColumnMapIndex(
        new Robots(),
        MetaData::MODELS_REVERSE_COLUMN_MAP
    )
);
final public function readMetaData( ModelInterface $model ): array;

Lee los metadatos completos para cierto modelo

print_r(
    $metaData->readMetaData(
        new Robots()
    )
);
final public function readMetaDataIndex( ModelInterface $model, int $index );

Lee los metadatos para cierto modelo

print_r(
    $metaData->readMetaDataIndex(
        new Robots(),
        0
    )
);
public function reset(): void;

Resetea los metadatos internos para regenerarlos

$metaData->reset();
public function setAutomaticCreateAttributes( ModelInterface $model, array $attributes ): void;

Establece los atributos que se deben ignorar en la generación SQL del INSERT

$metaData->setAutomaticCreateAttributes(
    new Robots(),
    [
        "created_at" => true,
    ]
);
public function setAutomaticUpdateAttributes( ModelInterface $model, array $attributes ): void;

Establece los atributos que se deben ignorar en la generación SQL del UPDATE

$metaData->setAutomaticUpdateAttributes(
    new Robots(),
    [
        "modified_at" => true,
    ]
);
public function setDI( DiInterface $container ): void;

Configura el contenedor DependencyInjector

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

Establece los atributos que permiten valores de cadena vacía

$metaData->setEmptyStringAttributes(
    new Robots(),
    [
        "name" => true,
    ]
);
public function setStrategy( StrategyInterface $strategy ): void;

Establece la estrategia de extracción de metadatos

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

Escribe los metadatos al adaptador

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

Escribe metadatos para cierto modelo usando una constante MODEL_*

print_r(
    $metaData->writeColumnMapIndex(
        new Robots(),
        MetaData::MODELS_REVERSE_COLUMN_MAP,
        [
            "leName" => "name",
        ]
    )
);
final protected function initialize( ModelInterface $model, mixed $key, mixed $table, mixed $schema );

Inicializa los metadatos para cierta tabla

Class Phalcon\Mvc\Model\MetaData\Apcu

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Apcu

Almacena los meta-datos del modelo en la caché APCu. Los datos serán borrados si se reinicia el servidor web

Por defecto los meta-datos se almacenan durante 48 horas (172800 segundos)

Puede consultar los meta-datos imprimiendo apcu_fetch(‘$PMM$’) o apcu_fetch(‘$PMM$my-app-id’)

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

Métodos

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

Constructor Phalcon\Mvc\Model\MetaData\Apcu

Class Phalcon\Mvc\Model\MetaData\Libmemcached

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Libmemcached

Almacena los meta-datos del modelo en la Memcache.

Por defecto los meta-datos se almacenan durante 48 horas (172800 segundos)

Métodos

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

Constructor Phalcon\Mvc\Model\MetaData\Libmemcached

public function reset(): void;

Vacía los datos de Memcache y reinicia los meta-datos internos para regenerarlos

Class Phalcon\Mvc\Model\MetaData\Memory

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Memory

Almacena los meta-datos del modelo en memoria. Los datos serán borrados cuando la petición finalice

Métodos

public function __construct( mixed $options = null );

Constructor Phalcon\Mvc\Model\MetaData\Memory

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

Lee los meta-datos de la memoria temporal

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

Escribe los meta-datos en la memoria temporal

Class Phalcon\Mvc\Model\MetaData\Redis

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Redis

Almacena los meta-datos del modelo en el Redis.

Por defecto los meta-datos se almacenan durante 48 horas (172800 segundos)

use Phalcon\Mvc\Model\MetaData\Redis;

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

Métodos

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

Constructor Phalcon\Mvc\Model\MetaData\Redis

public function reset(): void;

Vacía los datos Redis y reinicia los meta-datos internos para regenerarlos

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

Código fuente en 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

Este fichero es parte del Framework Phalcon.

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

Métodos

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

Lee el mapa de columnas del modelo, esto no se puede inferir

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

Los meta-datos se obtienen leyendo las descripciones de columna del esquema de información de la base de datos

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

Código fuente en 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

Consulta los meta-datos de la tabla para realizar una introspección de los metadatos del modelo

Métodos

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

Lee el mapa de columnas del modelo, esto no se puede inferir

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

Los meta-datos se obtienen leyendo las descripciones de columna del esquema de información de la base de datos

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

Código fuente en GitHub

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

Este fichero es parte del Framework Phalcon.

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

Métodos

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

Lee el mapa de columnas del modelo, esto no se puede inferir

@todo Not implemented

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

Los meta-datos se obtienen leyendo las descripciones de columna del esquema de información de la base de datos

Class Phalcon\Mvc\Model\MetaData\Stream

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Stream

Almacena los meta-datos del modelo en archivos PHP.

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

Propiedades

//
protected metaDataDir = ./;

Métodos

public function __construct( mixed $options = null );

Constructor Phalcon\Mvc\Model\MetaData\Files

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

Lee meta-datos de archivos

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

Escribe los meta-datos en archivos

Interface Phalcon\Mvc\Model\MetaDataInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaDataInterface

Interfaz para Phalcon\Mvc\Model\MetaData

Métodos

public function getAttributes( ModelInterface $model ): array;

Devuelve los nombres de los atributos de la tabla (campos)

public function getAutomaticCreateAttributes( ModelInterface $model ): array;

Devuelve los atributos que se deben ignorar en la generación del SQL INSERT

public function getAutomaticUpdateAttributes( ModelInterface $model ): array;

Devuelve los atributos que se deben ignorar de la generación del SQL UPDATE

public function getBindTypes( ModelInterface $model ): array;

Devuelve los atributos y sus tipos de datos de enlace

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

Devuelve el mapa de columnas si lo hay

public function getDataTypes( ModelInterface $model ): array;

Devuelve los atributos y sus tipos de datos

public function getDataTypesNumeric( ModelInterface $model ): array;

Devuelve los atributos con tipos numéricos

public function getDefaultValues( ModelInterface $model ): array;

Devuelve los atributos (que tienen valores por defecto) y sus valores por defecto

public function getEmptyStringAttributes( ModelInterface $model ): array;

Devuelve atributos que permiten cadenas vacías

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

Devuelve el nombre del campo identidad (si hay uno presente)

public function getNonPrimaryKeyAttributes( ModelInterface $model ): array;

Devuelve un vector de campos que no forman parte de la clave primaria

public function getNotNullAttributes( ModelInterface $model ): array;

Devuelve un vector de atributos no nulos

public function getPrimaryKeyAttributes( ModelInterface $model ): array;

Devuelve un vector de campos que forman parte de la clave primaria

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

Devuelve el mapa de columnas inverso si existe

public function getStrategy(): StrategyInterface;

Devuelve la estrategia para obtener los metadatos

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

Comprueba si un modelo tiene cierto atributo

public function isEmpty(): bool;

Comprueba si el contenedor de metadatos interno está vacío

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

Lee meta-datos del adaptador

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

Lee el mapa de columnas ordenado/inverso para cierto modelo

public function readColumnMapIndex( ModelInterface $model, int $index );

Lee información del mapa de columnas para cierto modelo usando una constante MODEL_*

public function readMetaData( ModelInterface $model ): array;

Lee los metadatos para cierto modelo

public function readMetaDataIndex( ModelInterface $model, int $index ): mixed;

Lee meta-datos para ciertos modelos usando una constante MODEL_*

public function reset();

Resetea los metadatos internos para regenerarlos

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

Establece los atributos que se deben ignorar en la generación SQL del INSERT

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

Establece los atributos que se deben ignorar en la generación SQL del UPDATE

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

Establece los atributos que permiten valores de cadena vacía

public function setStrategy( StrategyInterface $strategy );

Establece la estrategia de extracción de metadatos

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

Escribe meta-datos en el adaptador

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

Escribe metadatos para cierto modelo usando una constante MODEL_*

Class Phalcon\Mvc\Model\Query

Código fuente en GitHub

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

Phalcon\Mvc\Model\Query

Esta clase coge una representación intermedia PHQL y la ejecuta.

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

Constantes

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

Propiedades

//
protected ast;

//
protected bindParams;

//
protected bindTypes;

//
protected cache;

//
protected cacheOptions;

//
protected container;

//
protected enableImplicitJoins;

//
protected intermediate;

//
protected manager;

//
protected metaData;

//
protected models;

//
protected modelsInstances;

//
protected nestingLevel = -1;

//
protected phql;

//
protected sharedLock;

//
protected sqlAliases;

//
protected sqlAliasesModels;

//
protected sqlAliasesModelsInstances;

//
protected sqlColumnAliases;

//
protected sqlModelsAliases;

//
protected type;

//
protected uniqueRow;

//
static protected _irPhqlCache;

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

Métodos

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

Constructor Phalcon\Mvc\Model\Query

public function cache( array $cacheOptions ): QueryInterface;

Establece los parámetros del caché de la consulta

public static function clean(): void;

Destruye el caché PHQL interno

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

Ejecuta una sentencia PHQL analizada

public function getBindParams(): array;

Devuelve parámetros de enlace por defecto

public function getBindTypes(): array;

Devuelve tipos de enlace por defecto

public function getCache(): AdapterInterface;

Devuelve la instancia de backend de caché actual

public function getCacheOptions(): array;

Devuelve las opciones actuales de caché

public function getDI(): DiInterface;

Devuelve el contenedor de inyección de dependencias

public function getIntermediate(): array;

Devuelve la representación intermedia de la sentencia PHQL

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

Ejecuta la consulta devolviendo el primer resultado

public function getSql(): array;

Devuelve el SQL a ser generado por el PHQL interno (solo funciona en sentencias SELECT)

public function getType(): int;

Obtiene el tipo de sentencia PHQL ejecutada

public function getUniqueRow(): bool;

Comprueba si la consulta está programada para obtener solo la primera fila en el conjunto de resultados

public function get_transaction()
public function parse(): array;

Analiza el código intermedio producido por Phalcon\Mvc\Model\Query\Lang generando otra representación intermedia que podría ser ejecutada por Phalcon\Mvc\Model\Query

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

Establece parámetros de enlace por defecto

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

Establece parámetros de enlace por defecto

public function setDI( DiInterface $container ): void;

Establece el contenedor de inyección de dependencias

public function setIntermediate( array $intermediate ): QueryInterface;

Permite establecer la IR a ser ejecutada

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

Establece cláusula SHARED LOCK

public function setTransaction( TransactionInterface $transaction ): QueryInterface;

permite envolver una transacción alrededor de todas las consultas

public function setType( int $type ): QueryInterface;

Establece el tipo de sentencia PHQL a ser ejecutada

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Indica a la consulta si se debe devolver sólo el primer registro del conjunto de resultados

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

Ejecuta la representación intermedia DELETE produciendo un Phalcon\Mvc\Model\Query\Status

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

Ejecuta la representación intermedia INSERT produciendo un Phalcon\Mvc\Model\Query\Status

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

Ejecuta la representación intermedia SELECT produciendo un Phalcon\Mvc\Model\Resultset

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

Ejecuta la representación intermedia UPDATE produciendo un Phalcon\Mvc\Model\Query\Status

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

Resuelve una expresión en un único argumento de llamada

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

Resuelve una expresión en un único argumento de llamada

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

Resuelve una expresión de su código intermedio a una cadena

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

Resuelve una expresión en un único argumento de llamada

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

Devuelve una cláusula de grupo procesado para una sentencia SELECT

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

Resuelve una cláusula JOIN comprobando si los modelos asociados existen

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

Resuelve un tipo de JOIN

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

Procesa los JOINs en la consulta que devuelve una representación interna para el dialecto de la base de datos

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

Devuelve una cláusula de límite procesada para una sentencia SELECT

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

Resuelve joins que involucran relaciones muchos-a-muchos

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

Devuelve una cláusula de orden procesada para una sentencia SELECT

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

Reemplaza el nombre del modelo por su nombre de origen en una expresión de nombre calificado

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

Consulta los registros en los que se realizará la operación UPDATE/DELETE

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

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

Resuelve una columna de su representación intermedia en un vector usado para determinar si el conjunto de resultados producido es simple o complejo

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

Resuelve joins que involucran relaciones tiene-uno/pertenece-a/tiene-muchos

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

Resuelve una tabla en una sentencia SELECT comprobando si el modelo existe

final protected function _prepareDelete(): array;

Analiza un código intermedio DELETE y produce un vector para ser ejecutado más tarde

final protected function _prepareInsert(): array;

Analiza un código intermedio INSERT y produce un vector para ser ejecutado más tarde

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

Analiza un código intermedio SELECT y produce un vector para ser ejecutado más tarde

final protected function _prepareUpdate(): array;

Analiza un código intermedio UPDATE y produce un vector para ser ejecutado más tarde

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

Obtiene la conexión de lectura del modelo si no hay ninguna transacción establecida dentro del objeto de consulta

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

Consulta los registros en los que se realizará la operación UPDATE/DELETE

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

Obtiene la conexión de escritura del modelo si no hay ninguna transacción dentro del objeto consulta

Class Phalcon\Mvc\Model\Query\Builder

Código fuente en GitHub

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

Phalcon\Mvc\Model\Query\Builder

Ayuda a crear consultas PHQL usando una interfaz OO

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

Propiedades

//
protected bindParams;

//
protected bindTypes;

//
protected columns;

//
protected conditions;

//
protected container;

//
protected distinct;

//
protected forUpdate;

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

//
protected having;

//
protected hiddenParamNumber = 0;

//
protected joins;

//
protected limit;

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

//
protected offset;

//
protected order;

//
protected sharedLock;

Métodos

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

Constructor Phalcon\Mvc\Model\Query\Builder

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

Añade un modelo para que tome parte en la consulta

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

Añade una condición a la cláusula de condiciones HAVING actual usando un operador AND

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

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

Añade una condición a las condiciones WHERE actuales usando un operador AND

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

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

Escapa automáticamente los identificadores, pero sólo si necesitan ser escapados.

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

Añade una condición BETWEEN a la cláusula actual de condiciones HAVING

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

Añade una condición BETWEEN a las condiciones WHERE actuales

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

Establece las columnas a consultar

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

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

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

Establece la bandera SELECT DISTINCT / SELECT ALL

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

Establece una cláusula FOR UPDATE

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

Establece los modelos que forman parte de la consulta

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

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

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

Devuelve parámetros de enlace por defecto

public function getBindTypes(): array;

Devuelve tipos de enlace por defecto

public function getColumns();

Devuelve las columnas a ser consultadas

public function getDI(): DiInterface;

Devuelve el contenedor DependencyInjector

public function getDistinct(): bool;

Devuelve la bandera SELECT DISTINCT / SELECT ALL

public function getFrom();

Devuelve los modelos que forman parte de la consulta

public function getGroupBy(): array;

Devuelve la cláusula GROUP BY

public function getHaving(): string;

Devuelve la cláusula having actual

public function getJoins(): array;

Devuelve las partes join de la consulta

public function getLimit();

Devuelve la cláusula LIMIT actual

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

Devuelve los modelos involucrados en la consulta

public function getOffset(): int;

Devuelve la cláusula OFFSET actual

public function getOrderBy();

Devuelve la cláusula ORDER BY establecida

final public function getPhql(): string;

Devuelve una sentencia PHQL construida basada en los parámetros del constructor

public function getQuery(): QueryInterface;

Devuelve la consulta construida

public function getWhere();

Devolver las condiciones de la consulta

public function groupBy( mixed $group ): BuilderInterface;

Establece una cláusula GROUP BY

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

Establece la cláusula de condición HAVING

$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;

Añade una condición IN a la cláusula actual HAVING

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

Añade una condición IN a las condiciones WHERE actuales

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

Añade un INNER join a la consulta

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

Añade un :type: join (por defecto - INNER) a la consulta

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

Añade un LEFT join a la consulta

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

Establece una cláusula LIMIT, opcionalmente una cláusula de desplazamiento

$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;

Añade una condición NOT BETWEEN a la cláusula actual de condiciones HAVING

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

Añade una condición BETWEEN a las condiciones WHERE actuales

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

Añade una condición NOT IN a la cláusula actual de condiciones HAVING

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

Añade una condición NOT IN a las condiciones WHERE actuales

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

Establece una cláusula OFFSET

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

Añade una condición a la cláusula actual de condiciones HAVING usando un operador OR

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

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

Añade una condición a las condiciones actuales usando un operador OR

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

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

Establece una cláusula de condición ORDER BY

$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;

Añade un RIGHT join a la consulta

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

Establece parámetros de enlace por defecto

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

Establece los tipos de enlace predeterminados

public function setDI( DiInterface $container ): void;

Configura el contenedor DependencyInjector

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

Establece las condiciones WHERE de la consulta

$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;

Añade una condición BETWEEN

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

Añade una condición IN

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

Añade una condición NOT BETWEEN

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

Añade una condición NOT IN

Interface Phalcon\Mvc\Model\Query\BuilderInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\Query\BuilderInterface

Interfaz para Phalcon\Mvc\Model\Query\Builder

Constantes

const OPERATOR_AND = and;
const OPERATOR_OR = or;

Métodos

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

Añade un modelo para que tome parte en la consulta

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

Añade una condición a las condiciones actuales usando un operador AND

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

Añade una condición BETWEEN a las condiciones actuales

public function columns( mixed $columns ): BuilderInterface;

Establece las columnas a consultar

public function distinct( mixed $distinct ): BuilderInterface;

Establece la bandera SELECT DISTINCT / SELECT ALL

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

Establece una cláusula FOR UPDATE

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

Establece los modelos que forman parte de la consulta

public function getBindParams(): array;

Devuelve parámetros de enlace por defecto

public function getBindTypes(): array;

Devuelve tipos de enlace por defecto

public function getColumns();

Devuelve las columnas a ser consultadas

public function getDistinct(): bool;

Devuelve la bandera SELECT DISTINCT / SELECT ALL

public function getFrom();

Devuelve los modelos que forman parte de la consulta

public function getGroupBy(): array;

Devuelve la cláusula GROUP BY

public function getHaving(): string;

Devuelve la cláusula de condición HAVING

public function getJoins(): array;

Devuelve las partes join de la consulta

public function getLimit();

Devuelve la cláusula LIMIT actual

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

Devuelve los modelos involucrados en la consulta

public function getOffset(): int;

Devuelve la cláusula OFFSET actual

public function getOrderBy();

Devuelve la cláusula ORDER BY establecida

public function getPhql(): string;

Devuelve una sentencia PHQL construida basada en los parámetros del constructor

public function getQuery(): QueryInterface;

Devuelve la consulta construida

public function getWhere();

Devolver las condiciones de la consulta

public function groupBy( mixed $group ): BuilderInterface;

Establece una cláusula GROUP BY

public function having( string $having ): BuilderInterface;

Establece la cláusula de condición HAVING

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

Añade una condición IN a las condiciones actuales

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

Añade un INNER join a la consulta

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

Añade un :type: join (por defecto - INNER) a la consulta

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

Añade un LEFT join a la consulta

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

Establece una cláusula LIMIT

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

Añade una condición NOT BETWEEN a las condiciones actuales

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

Añade una condición NOT IN a las condiciones actuales

public function offset( int $offset ): BuilderInterface;

Establece una cláusula OFFSET

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

Añade una condición a las condiciones actuales usando un operador OR

public function orderBy( string $orderBy ): BuilderInterface;

Establece una cláusula de condición ORDER BY

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

Añade un RIGHT join a la consulta

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

Establece parámetros de enlace por defecto

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

Establece los tipos de enlace predeterminados

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

Establece las condiciones para la consulta

Abstract Class Phalcon\Mvc\Model\Query\Lang

Código fuente en GitHub

Namespace Phalcon\Mvc\Model\Query

Phalcon\Mvc\Model\Query\Lang

PHQL está implementado como un analizador (escrito en C) que traduce la sintaxis en la del RDBMS destino. Permite a Phalcon ofrecer un lenguaje SQL unificado al desarrollador, mientras internamente está haciendo todo el trabajo de traducir las instrucciones de PHQL a las instrucciones SQL más óptimas dependiendo del tipo RDBMS asociado con un modelo.

Para lograr el mayor rendimiento posible, escribimos un analizador que utiliza la misma tecnología que SQLite. Esta tecnología proporciona un analizador pequeño en memoria con una huella en memoria muy baja que también es segura en hilos.

use Phalcon\Mvc\Model\Query\Lang;

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

Métodos

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

Analiza una sentencia PHQL devolviendo una representación intermedia (IR)

Class Phalcon\Mvc\Model\Query\Status

Código fuente en GitHub

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

Phalcon\Mvc\Model\Query\Status

Esta clase representa el estado devuelto por una sentencia PHQL como INSERT, UPDATE o DELETE. Ofrece información del contexto y los mensajes relacionados producidos por el modelo que finalmente ejecuta las operaciones cuando falla

$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";
}

Propiedades

//
protected model;

//
protected success;

Métodos

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

Phalcon\Mvc\Model\Query\Status

public function getMessages(): MessageInterface[];

Devuelve los mensajes producidos debido a una operación fallida

public function getModel(): ModelInterface;

Devuelve el modelo que ejecutó la acción

public function success(): bool;

Permite comprobar si la operación ejecutada fue exitosa

Interface Phalcon\Mvc\Model\Query\StatusInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\Query\StatusInterface

Interfaz para Phalcon\Mvc\Model\Query\Status

Métodos

public function getMessages(): MessageInterface[];

Devuelve los mensajes producidos por una operación fallida

public function getModel(): ModelInterface;

Devuelve el modelo que ejecutó la acción

public function success(): bool;

Permite comprobar si la operación ejecutada fue exitosa

Interface Phalcon\Mvc\Model\QueryInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\QueryInterface

Interfaz para Phalcon\Mvc\Model\Query

Métodos

public function cache( array $cacheOptions ): QueryInterface;

Establece los parámetros del caché de la consulta

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

Ejecuta una sentencia PHQL analizada

public function getBindParams(): array;

Devuelve parámetros de enlace por defecto

public function getBindTypes(): array;

Devuelve tipos de enlace por defecto

public function getCacheOptions(): array;

Devuelve las opciones actuales de caché

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

Ejecuta la consulta devolviendo el primer resultado

public function getSql(): array;

Devuelve el SQL a ser generado por el PHQL interno (solo funciona en sentencias SELECT)

public function getUniqueRow(): bool;

Comprueba si la consulta está programada para obtener solo la primera fila en el conjunto de resultados

public function parse(): array;

Analiza el código intermedio producido por Phalcon\Mvc\Model\Query\Lang generando otra representación intermedia que podría ser ejecutada por Phalcon\Mvc\Model\Query

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

Establece parámetros de enlace por defecto

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

Establece parámetros de enlace por defecto

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

Establece cláusula SHARED LOCK

public function setUniqueRow( bool $uniqueRow ): QueryInterface;

Indica a la consulta si se debe devolver sólo el primer registro del conjunto de resultados

Class Phalcon\Mvc\Model\Relation

Código fuente en GitHub

Namespace Phalcon\Mvc\Model   Implements RelationInterface

Phalcon\Mvc\Model\Relation

Esta clase representa una relación entre dos modelos

Constantes

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;

Propiedades

//
protected fields;

//
protected intermediateFields;

//
protected intermediateModel;

//
protected intermediateReferencedFields;

//
protected options;

//
protected referencedFields;

//
protected referencedModel;

//
protected type;

Métodos

public function __construct( int $type, string $referencedModel, mixed $fields, mixed $referencedFields, array $options = [] );

Constructor Phalcon\Mvc\Model\Relation

public function getFields();

Devuelve los campos

public function getForeignKey();

Devuelve la configuración de clave ajena

public function getIntermediateFields();

Obtiene los campos intermedios para las relaciones has-*-through

public function getIntermediateModel(): string;

Obtiene el modelo intermedio para las relaciones has-*-through

public function getIntermediateReferencedFields();

Obtiene los campos intermedios referenciados para las relaciones has-*-through

public function getOption( string $name );

Devuelve una opción por el nombre especificado Si la opción no existe se devuelve null

public function getOptions(): array;

Devuelve las opciones

public function getParams();

Devuelve parámetros que deben utilizarse siempre cuando se obtengan los registros relacionados

public function getReferencedFields();

Devuelve los campos referenciados

public function getReferencedModel(): string;

Devuelve el modelo referenciado

public function getType(): int;

Devuelve el tipo de relación

public function isForeignKey(): bool;

Comprueba si la relación actúa como una clave ajena

public function isReusable(): bool;

Comprobar si los registros devueltos al obtener belongs-to/has-many están implícitamente almacenados en caché durante la solicitud actual

public function isThrough(): bool;

Comprueba si la relación es una relación ‘muchos-a-muchos’ o no

public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );

Establece los datos intermedios del modelo para las relaciones has-*-through

Interface Phalcon\Mvc\Model\RelationInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\Model

Phalcon\Mvc\Model\RelationInterface

Interfaz para Phalcon\Mvc\Model\Relation

Métodos

public function getFields();

Devuelve los campos

public function getForeignKey();

Devuelve la configuración de clave ajena

public function getIntermediateFields();

Obtiene los campos intermedios para las relaciones has-*-through

public function getIntermediateModel(): string;

Obtiene el modelo intermedio para las relaciones has-*-through

public function getIntermediateReferencedFields();

Obtiene los campos intermedios referenciados para las relaciones has-*-through

public function getOption( string $name );

Devuelve una opción por el nombre especificado Si la opción no existe se devuelve null

public function getOptions(): array;

Devuelve las opciones

public function getParams();

Devuelve parámetros que deben utilizarse siempre cuando se obtengan los registros relacionados

public function getReferencedFields();

Devuelve los campos referenciados

public function getReferencedModel(): string;

Devuelve el modelo referenciado

public function getType(): int;

Devuelve los tipos de relación

public function isForeignKey(): bool;

Comprueba si la relación actúa como una clave ajena

public function isReusable(): bool;

Comprobar si los registros devueltos al obtener belongs-to/has-many están implícitamente almacenados en caché durante la solicitud actual

public function isThrough(): bool;

Comprueba si la relación es una relación ‘muchos-a-muchos’ o no

public function setIntermediateRelation( mixed $intermediateFields, string $intermediateModel, mixed $intermediateReferencedFields );

Establece los datos intermedios del modelo para las relaciones has-*-through

Interface Phalcon\Mvc\Model\ResultInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\ResultInterface

Todos los objetos individuales pasados como objetos base a Resultsets deben implementar esta interfaz

Métodos

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

Establece el estado del objeto

Abstract Class Phalcon\Mvc\Model\Resultset

Código fuente en GitHub

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

Phalcon\Mvc\Model\Resultset

Este componente permite que Phalcon\Mvc\Model devuelva conjuntos de resultados grandes con el consumo mínimo de memoria Los Resultsets pueden ser recorridos usando una instrucción estándar para cada uno o un tiempo. Si un conjunto de resultados se serializa volcará todos los registros en un gran vector. Entonces la deserialización recuperará las filas como estaban antes de serializar.

<br />// 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();
}

Constantes

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

Propiedades

//
protected activeRow;

//
protected cache;

//
protected count = 0;

//
protected errorMessages;

//
protected hydrateMode = 0;

//
protected isFresh = true;

//
protected pointer = 0;

//
protected row;

//
protected rows;

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

Métodos

public function __construct( mixed $result, AdapterInterface $cache = null );

Constructor Phalcon\Mvc\Model\Resultset

final public function count(): int;

Cuenta cuántos registros hay en el conjunto de resultados

public function delete( Closure $conditionCallback = null ): bool;

Elimina todos los registros del conjunto de resultados

public function filter( callable $filter ): ModelInterface[];

Filtra un conjunto de resultados devolviendo sólo aquellos que el desarrollador requiera

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);
public function getCache(): AdapterInterface;

Devuelve el caché asociado para el conjunto de resultados

public function getFirst(): mixed | null;

Obtener la primera fila del conjunto de resultados

$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;

Devuelve el modo de hidratación actual

public function getLast(): ModelInterface | null;

Obtener la última fila del conjunto de resultados

public function getMessages(): MessageInterface[];

Devuelve los mensajes de error producidos por una operación por lotes

public function getType(): int;

Devuelve el tipo interno de recuperación de datos que el conjunto de resultados está usando

public function isFresh(): bool;

Indica si el conjunto de resultados es fresco o un caché antiguo

public function jsonSerialize(): array;

Devuelve objetos de modelo serializados como vector por json_encode. Llama jsonSerialize en cada objeto si está presente

$robots = Robots::find();

echo json_encode($robots);
public function key(): int | null;

Obtiene el número de puntero del registro activo en el conjunto de resultados

public function next(): void;

Mueve el cursor a la siguiente fila del conjunto de resultados

public function offsetExists( mixed $index ): bool;

Comprueba si existe un offset en el conjunto de resultados

public function offsetGet( mixed $index ): ModelInterface | bool;

Obtiene un registro de una posición específica del conjunto de resultados

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

Los conjuntos de resultados no se pueden cambiar. Sólo se ha implementado para cumplir con la definición de la interfaz ArrayAccess

public function offsetUnset( mixed $offset ): void;

Los conjuntos de resultados no se pueden cambiar. Sólo se ha implementado para cumplir con la definición de la interfaz ArrayAccess

final public function rewind(): void;

Rebobina el conjunto de resultados a su inicio

final public function seek( mixed $position ): void;

Cambia el puntero interno a una posición específica en el conjunto de resultados. Establece la nueva posición si es necesario, y luego establece this->row

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Establece el modo de hidratación en el conjunto de resultados

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Establece si el conjunto de resultados es fresco o un caché antiguo

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Actualiza cada registro en el conjunto de resultados

public function valid(): bool;

Comprobar si el recurso interno tiene filas para recuperar

Class Phalcon\Mvc\Model\Resultset\Complex

Código fuente en GitHub

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

Phalcon\Mvc\Model\Resultset\Complex

Los conjuntos de resultados complejos pueden incluir objetos completos y valores escalares. Esta clase construye cada registro complejo ya que se requiere

Propiedades

//
protected columnTypes;

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

Métodos

public function __construct( mixed $columnTypes, ResultInterface $result = null, AdapterInterface $cache = null );

Constructor Phalcon\Mvc\Model\Resultset\Complex

final public function current(): ModelInterface | bool;

Devuelve la fila actual en el conjunto de resultados

public function serialize(): string;

Serializar un conjunto de resultados extraerá todas las filas relacionadas en un vector grande

public function toArray(): array;

Devuelve un conjunto de resultados completo como un vector, si el conjunto de resultados tiene un gran número de filas podría consumir más memoria de la que consume actualmente.

public function unserialize( mixed $data ): void;

Deserializar un conjunto de resultados sólo permitirá trabajar en las filas presentes en el estado guardado

Class Phalcon\Mvc\Model\Resultset\Simple

Código fuente en GitHub

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

Phalcon\Mvc\Model\Resultset\Simple

Los conjuntos de resultados simples solo contienen un objeto completo Esta clase construye cada objeto completo como es requerido

Propiedades

//
protected columnMap;

//
protected model;

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

Métodos

public function __construct( mixed $columnMap, mixed $model, mixed $result, AdapterInterface $cache = null, bool $keepSnapshots = null );

Constructor Phalcon\Mvc\Model\Resultset\Simple

final public function current(): ModelInterface | null;

Devuelve la fila actual en el conjunto de resultados

public function serialize(): string;

Serializar un conjunto de resultados extraerá todas las filas relacionadas en un vector grande

public function toArray( bool $renameColumns = bool ): array;

Devuelve un conjunto de resultados completo como un vector, si el conjunto de resultados tiene un gran número de filas podría consumir más memoria de la que consume actualmente. Exportar el conjunto de resultados a un vector no podría ser más rápido con un gran número de registros

public function unserialize( mixed $data ): void;

Deserializar un conjunto de resultados solo permitirá trabajar en las filas presentes en el estado guardado

Interface Phalcon\Mvc\Model\ResultsetInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\ResultsetInterface

Interfaz para Phalcon\Mvc\Model\Resultset

Métodos

public function delete( Closure $conditionCallback = null ): bool;

Elimina todos los registros del conjunto de resultados

public function filter( callable $filter ): ModelInterface[];

Filtra un conjunto de resultados devolviendo sólo aquellos que el desarrollador requiera

$filtered = $robots->filter(
    function ($robot) {
        if ($robot->id < 3) {
            return $robot;
        }
    }
);
public function getCache(): AdapterInterface;

Devuelve el caché asociado para el conjunto de resultados

public function getFirst(): mixed | null;

Obtener la primera fila del conjunto de resultados

public function getHydrateMode(): int;

Devuelve el modo de hidratación actual

public function getLast(): ModelInterface | null;

Obtener la última fila del conjunto de resultados

public function getMessages(): MessageInterface[];

Devuelve los mensajes de error producidos por una operación por lotes

public function getType(): int;

Devuelve el tipo interno de recuperación de datos que el conjunto de resultados está usando

public function isFresh(): bool;

Indica si el conjunto de resultados es fresco o un caché antiguo

public function setHydrateMode( int $hydrateMode ): ResultsetInterface;

Establece el modo de hidratación en el conjunto de resultados

public function setIsFresh( bool $isFresh ): ResultsetInterface;

Establece si el conjunto de resultados es fresco o un caché antiguo

public function toArray(): array;

Devuelve un conjunto de resultados completo como un vector, si el conjunto de resultados tiene un gran número de filas podría consumir más memoria de la que consume actualmente.

public function update( mixed $data, Closure $conditionCallback = null ): bool;

Actualiza cada registro en el conjunto de resultados

Class Phalcon\Mvc\Model\Row

Código fuente en GitHub

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

Phalcon\Mvc\Model\Row

Este componente permite a Phalcon\Mvc\Model devolver filas sin una entidad asociada. Este objeto implementa la interfaz ArrayAccess para permitir el acceso al objeto como objeto->x o array[x].

Métodos

public function jsonSerialize(): array;

Serializa el objeto por json_encode

public function offsetExists( mixed $index ): bool;

Comprueba si existe un desplazamiento en la fila

public function offsetGet( mixed $index ): mixed;

Obtiene un registro en una posición específica de la fila

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

Las filas no se pueden cambiar. Sólo se ha implementado para cumplir con la definición de la interfaz ArrayAccess

public function offsetUnset( mixed $offset ): void;

Las filas no se pueden cambiar. Sólo se ha implementado para cumplir con la definición de la interfaz ArrayAccess

public function readAttribute( string $attribute );

Lee un valor de atributo por su nombre

echo $robot->readAttribute("name");
public function setDirtyState( int $dirtyState ): ModelInterface | bool;

Establece el estado del objeto actual

public function toArray(): array;

Devuelve la instancia como una representación de vector

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

Escribe un valor de atributo por su nombre

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

Class Phalcon\Mvc\Model\Transaction

Código fuente en GitHub

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

Phalcon\Mvc\Model\Transaction

Las transacciones son bloques protectores donde las sentencias SQL solo son permanentes si todas pueden tener éxito como una acción atómica. Phalcon\Transaction está destinado a ser usado con Phalcon_Model_Base. Phalcon Transactions se debería crear usando 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();
}

Propiedades

//
protected activeTransaction = false;

//
protected connection;

//
protected isNewTransaction = true;

//
protected manager;

//
protected messages;

//
protected rollbackRecord;

//
protected rollbackOnAbort = false;

//
protected rollbackThrowException = false;

Métodos

public function __construct( DiInterface $container, bool $autoBegin = bool, string $service = string );

Constructor Phalcon\Mvc\Model\Transaction

public function begin(): bool;

Inicia la transacción

public function commit(): bool;

Confirma la transacción

public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;

Devuelve la conexión relacionada con la transacción

public function getMessages(): array;

Devuelve mensajes de validación desde el último intento de guardado

public function isManaged(): bool;

Comprueba si la transacción es administrada por un gestor de transacciones

public function isValid(): bool;

Comprueba si la conexión interna está bajo una transacción activa

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Deshace la transacción

public function setIsNewTransaction( bool $isNew ): void;

Establece si es una transacción reutilizada o nueva

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Establece la opción de cancelación al abortar la conexión HTTP

public function setRollbackedRecord( ModelInterface $record ): void;

Establece el objeto que genera la acción de deshacer

public function setTransactionManager( ManagerInterface $manager ): void;

Establece el gestor de transacciones relacionado con la transacción

public function throwRollbackException( bool $status ): TransactionInterface;

Permite lanzar excepciones

Class Phalcon\Mvc\Model\Transaction\Exception

Código fuente en GitHub

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

Phalcon\Mvc\Model\Transaction\Exception

Las excepciones lanzadas en Phalcon\Mvc\Model\Transaction usarán esta clase

Class Phalcon\Mvc\Model\Transaction\Failed

Código fuente en GitHub

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

Phalcon\Mvc\Model\Transaction\Failed

Esta clase será lanzada para salir de un bloque try/catch para transacciones aisladas

Propiedades

//
protected record;

Métodos

public function __construct( string $message, ModelInterface $record = null );

Constructor Phalcon\Mvc\Model\Transaction\Failed

public function getRecord(): ModelInterface;

Devuelve mensajes de validación de registro que detienen la transacción

public function getRecordMessages(): MessageInterface[];

Devuelve mensajes de validación de registro que detienen la transacción

Class Phalcon\Mvc\Model\Transaction\Manager

Código fuente en GitHub

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

Phalcon\Mvc\Model\Transaction\Manager

Una transacción actúa en una única conexión de base de datos. Si tienes múltiples bases de datos específicas de clase, la transacción no protegerá la interacción entre ellas.

Esta clase administra los objetos que componen una transacción. Una transacción produce una conexión única que se pasa a cada objeto parte de la transacción.

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

Propiedades

//
protected container;

//
protected initialized = false;

//
protected number = 0;

//
protected rollbackPendent = true;

//
protected service = db;

/**
 * @var array
 */
protected transactions;

Métodos

public function __construct( DiInterface $container = null );

Constructor Phalcon\Mvc\Model\Transaction\Manager

public function collectTransactions(): void;

Eliminar todas las transacciones del gestor

public function commit();

Confirma las transacciones activas dentro del gestor

public function get( bool $autoBegin = bool ): TransactionInterface;

Devuelve una nueva \Phalcon\Mvc\Model\Transaction o una ya creada Este método registra una función de apagado para deshacer las conexiones activas

public function getDI(): DiInterface;

Devuelve el contenedor de inyección de dependencias

public function getDbService(): string;

Devuelve el servicio de base de datos usado para aislar la transacción

public function getOrCreateTransaction( bool $autoBegin = bool ): TransactionInterface;

Crear/Devuelve una nueva transacción o una existente

public function getRollbackPendent(): bool;

Compruebe si el gestor de transacciones está registrando una función de apagado para limpiar transacciones pendientes

public function has(): bool;

Comprueba si el gestor tiene una transacción activa

public function notifyCommit( TransactionInterface $transaction ): void;

Notifica al gestor sobre una transacción confirmada

public function notifyRollback( TransactionInterface $transaction ): void;

Notifica al gestor sobre una transacción deshecha

public function rollback( bool $collect = bool ): void;

Deshace las transacciones activas dentro del gestor La recogida eliminará la transacción del gestor

public function rollbackPendent(): void;

Deshace las transacciones activas dentro del gestor

public function setDI( DiInterface $container ): void;

Establece el contenedor de inyección de dependencias

public function setDbService( string $service ): ManagerInterface;

Establece el servicio de base de datos usado para ejecutar las transacciones aisladas

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Establece si el gestor de transacciones debe registrar una función de apagado para limpiar transacciones pendientes

protected function collectTransaction( TransactionInterface $transaction ): void;

Elimina las transacciones del TransactionManager

Interface Phalcon\Mvc\Model\Transaction\ManagerInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\Transaction\ManagerInterface

Interfaz para Phalcon\Mvc\Model\Transaction\Manager

Métodos

public function collectTransactions(): void;

Eliminar todas las transacciones del gestor

public function commit();

Confirma las transacciones activas dentro del gestor

public function get( bool $autoBegin = bool ): TransactionInterface;

Devuelve un nuevo \Phalcon\Mvc\Model\Transaction o uno ya creado

public function getDbService(): string;

Devuelve el servicio de base de datos usado para aislar la transacción

public function getRollbackPendent(): bool;

Compruebe si el gestor de transacciones está registrando una función de apagado para limpiar transacciones pendientes

public function has(): bool;

Comprueba si el gestor tiene una transacción activa

public function notifyCommit( TransactionInterface $transaction ): void;

Notifica al gestor sobre una transacción confirmada

public function notifyRollback( TransactionInterface $transaction ): void;

Notifica al gestor sobre una transacción deshecha

public function rollback( bool $collect = bool ): void;

Deshace las transacciones activas dentro del gestor La recogida eliminará la transacción del gestor

public function rollbackPendent(): void;

Deshace las transacciones activas dentro del gestor

public function setDbService( string $service ): ManagerInterface;

Establece el servicio de base de datos usado para ejecutar las transacciones aisladas

public function setRollbackPendent( bool $rollbackPendent ): ManagerInterface;

Establece si el gestor de transacciones debe registrar una función de apagado para limpiar transacciones pendientes

Interface Phalcon\Mvc\Model\TransactionInterface

Código fuente en GitHub

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

Phalcon\Mvc\Model\TransactionInterface

Interfaz para Phalcon\Mvc\Model\Transaction

Métodos

public function begin(): bool;

Inicia la transacción

public function commit(): bool;

Confirma la transacción

public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;

Devuelve la conexión relacionada con la transacción

public function getMessages(): array;

Devuelve mensajes de validación desde el último intento de guardado

public function isManaged(): bool;

Comprueba si la transacción es administrada por un gestor de transacciones

public function isValid(): bool;

Comprueba si la conexión interna está bajo una transacción activa

public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;

Deshace la transacción

public function setIsNewTransaction( bool $isNew ): void;

Establece si es una transacción reutilizada o nueva

public function setRollbackOnAbort( bool $rollbackOnAbort ): void;

Establece la opción de cancelación al abortar la conexión HTTP

public function setRollbackedRecord( ModelInterface $record ): void;

Establece el objeto que genera la acción de deshacer

public function setTransactionManager( ManagerInterface $manager ): void;

Establece el gestor de transacciones relacionado con la transacción

public function throwRollbackException( bool $status ): TransactionInterface;

Permite lanzar excepciones

Class Phalcon\Mvc\Model\ValidationFailed

Código fuente en GitHub

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

Phalcon\Mvc\Model\ValidationFailed

Esta excepción se genera cuando un modelo falla al guardar un registro Se debe configurar Phalcon\Mvc\Model para tener este comportamiento

Propiedades

//
protected messages;

//
protected model;

Métodos

public function __construct( ModelInterface $model, array $validationMessages );

Constructor Phalcon\Mvc\Model\ValidationFailed

public function getMessages(): Message[];

Devuelve el grupo completo de mensajes producidos en la validación

public function getModel(): ModelInterface;

Devuelve el modelo que generó los mensajes

Interface Phalcon\Mvc\ModelInterface

Código fuente en 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

Interfaz para Phalcon\Mvc\Model

Métodos

public function appendMessage( MessageInterface $message ): ModelInterface;

Añade un mensaje personalizado a un proceso de validación

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

Asigna valores a un modelo desde un vector

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

Permite calcular el valor promedio de una columna que coincida con las condiciones especificadas

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

Asigna valores a un modelo desde un vector devolviendo un nuevo modelo

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

Asigna valores a un modelo desde un vector devolviendo un nuevo modelo

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

Devuelve un resultado hidratado basado en los datos y el mapa de columnas

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

Permite contar cuántos registros coinciden con las condiciones especificadas

Devuelve un entero para consultas simples o una instancia de ResultsetInterface para cuando se utiliza la condición GROUP. Los resultados contendrán el contador de cada grupo.

public function create(): bool;

Inserta una instancia de modelo. Si la instancia ya existe en la persistencia lanzará una excepción. Devuelve true en caso de éxito o false en caso contrario.

public function delete(): bool;

Borra una instancia del modelo. Devuelve true en caso de éxito o false en caso contrario.

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

Permite consultar un conjunto de registros que coinciden con las condiciones especificadas

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

Permite consultar el primer registro que coincide con las condiciones especificadas

public function fireEvent( string $eventName ): bool;

Dispara un evento, llama implícitamente a comportamientos y se notifica a los oyentes del gestor de eventos

public function fireEventCancel( string $eventName ): bool;

Dispara un evento, llama implícitamente a comportamientos y se notifica a los oyentes del gestor de eventos. Este método se detiene si alguna de las funciones de retorno/oyentes devuelve false

public function getDirtyState(): int;

Devuelve una de las constantes DIRTY_STATE_* que indica si el registro existe en la base de datos o no

public function getMessages(): MessageInterface[];

Devuelve un vector de mensajes de validación

public function getModelsMetaData(): MetaDataInterface;

Devuelve el servicio de metadatos de los modelos relacionados a la instancia de entidad.

public function getOperationMade(): int;

Devuelve el tipo de la operación realizada por el ORM más reciente. Devuelve una de las constantes de clase OP_*

public function getReadConnection(): AdapterInterface;

Obtiene la conexión interna de base de datos

public function getReadConnectionService(): string;

Devuelve el servicio de conexión DependencyInjection usado para leer datos

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

Devuelve registros relacionados basados en relaciones definidas

public function getSchema(): string;

Devuelve el nombre del esquema donde se encuentra la tabla mapeada

public function getSource(): string;

Devuelve el nombre de tabla mapeado en el modelo

public function getWriteConnection(): AdapterInterface;

Obtiene la conexión interna de base de datos

public function getWriteConnectionService(): string;

Devuelve el servicio de conexión DependencyInjection usado para escribir datos

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

Permite obtener el valor máximo de una columna que coincida con las condiciones especificadas

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

Permite obtener el valor mínimo de una columna que coincida con las condiciones especificadas

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

Crea un criterio para un modelo específico

public function refresh(): ModelInterface;

Refresca los atributos del modelo consultando otra vez el registro desde la base de datos

public function save(): bool;

Inserta o actualiza una instancia de modelo. Devuelve true en caso de éxito o false en caso contrario.

public function setConnectionService( string $connectionService ): void;

Establecer ambos servicios de conexión de lectura/escritura

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

Establece el estado de suciedad del objeto usando una de las constantes DIRTY_STATE_*

public function setReadConnectionService( string $connectionService ): void;

Establece el servicio de conexión DependencyInjection usado para leer datos

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

Establece los datos de instantánea del registro. Este método se usa internamente para establecer los datos de instantánea cuando el modelo fue configurado para mantener datos de instantánea

public function setTransaction( TransactionInterface $transaction ): ModelInterface;

Establece una transacción relacionada con la instancia del modelo

public function setWriteConnectionService( string $connectionService ): void;

Establece el servicio de conexión DependencyInjection usado para escribir datos

public function skipOperation( bool $skip ): void;

Omite la operación actual forzando un estado de éxito

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

Permite calcular una suma sobre una columna que coincida con las condiciones especificadas

public function update(): bool;

Actualiza una instancia de modelo. Si la instancia no existe en la persistencia lanzará una excepción. Devuelve true en caso de éxito o false en caso contrario.

public function validationHasFailed(): bool;

Comprueba si el proceso de validación ha generado algún mensaje

Interface Phalcon\Mvc\ModuleDefinitionInterface

Código fuente en GitHub

Namespace Phalcon\Mvc   Uses Phalcon\Di\DiInterface

Phalcon\Mvc\ModuleDefinitionInterface

Se debe implementar esta interfaz por definiciones de módulo de clase

Métodos

public function registerAutoloaders( DiInterface $container = null );

Registra un autocargador relacionado con el módulo

public function registerServices( DiInterface $container );

Registrar servicios relacionados con el módulo

Class Phalcon\Mvc\Router

Código fuente en 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 es el enrutador estándar del framework. 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();

Constantes

const POSITION_FIRST = 0;
const POSITION_LAST = 1;

Propiedades

//
protected action;

//
protected controller;

//
protected defaultAction;

//
protected defaultController;

//
protected defaultModule;

//
protected defaultNamespace;

//
protected defaultParams;

//
protected eventsManager;

//
protected keyRouteNames;

//
protected keyRouteIds;

//
protected matchedRoute;

//
protected matches;

//
protected module;

//
protected namespaceName;

//
protected notFoundPaths;

//
protected params;

//
protected removeExtraSlashes;

//
protected routes;

//
protected wasMatched = false;

Métodos

public function __construct( bool $defaultRoutes = bool );

Phalcon\Mvc\Router constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router without any HTTP constraint

use Phalcon\Mvc\Router;

$router->add("/about", "About::index");

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"]
);

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"],
    Router::POSITION_FIRST
);
public function addConnect( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null, mixed $position = static-constant-access ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, mixed $position = static-constant-access ): RouterInterface;

Attach Route object to the routes stack.

use Phalcon\Mvc\Router;
use Phalcon\Mvc\Router\Route;

class CustomRoute extends Route {
     // ...
}

$router = new Router();

$router->attach(
    new CustomRoute("/about", "About::index", ["GET", "HEAD"]),
    Router::POSITION_FIRST
);
public function clear(): void;

Removes all the pre-defined routes

public function getActionName(): string;

Returns the processed action name

public function getControllerName(): string;

Returns the processed controller name

public function getDefaults(): array;

Returns an array of default parameters

public function getEventsManager(): ManagerInterface;

Devuelve el administrador de eventos interno

public function getKeyRouteIds()
public function getKeyRouteNames()
public function getMatchedRoute(): RouteInterface;

Devuelve la ruta que coincide con el URI gestionado

public function getMatches(): array;

Devuelve las sub expresiones en la expresión regular combinada

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;

Devuelve un objeto de ruta por su identidad

public function getRouteByName( string $name ): RouteInterface | bool;

Devuelve un objeto de ruta por su nombre

public function getRoutes(): RouteInterface[];

Devuelve todas las rutas definidas en el enrutador

public function handle( string $uri ): void;

Gestiona la información de enrutamiento recibida del motor de reescritura

// Passing a URL
$router->handle("/posts/edit/1");
public function isExactControllerName(): bool;

Devuelve si el nombre del controlador no debe ser roto

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;

Establece el nombre de acción predeterminado

public function setDefaultController( string $controllerName ): RouterInterface;

Establece el nombre predeterminado del controlador

public function setDefaultModule( string $moduleName ): RouterInterface;

Establece el nombre del módulo predeterminado

public function setDefaultNamespace( string $namespaceName ): RouterInterface;

Sets the name of the default namespace

public function setDefaults( array $defaults ): RouterInterface;

Establece un vector de rutas por defecto. Si a una ruta le falta el camino el enrutador usará el definido aquí. No se debe usar este método para establecer una ruta 404

$router->setDefaults(
    [
        "module" => "common",
        "action" => "index",
    ]
);
public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el administrador de eventos

public function setKeyRouteIds( $keyRouteIds )
public function setKeyRouteNames( $keyRouteNames )
public function wasMatched(): bool;

Comprueba si el enrutador coincide con alguna de las rutas definidas

Class Phalcon\Mvc\Router\Annotations

Código fuente en 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;
    }
);

Propiedades

//
protected actionSuffix = Action;

//
protected actionPreformatCallback;

//
protected controllerSuffix = Controller;

//
protected handlers;

//
protected routePrefix;

Métodos

public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations The class is located in a module

public function addResource( string $handler, string $prefix = null ): Annotations;

Adds a resource to the annotations handler A resource is a class that contains routing annotations

public function getActionPreformatCallback();
public function getResources(): array;

Return the registered resources

public function handle( string $uri ): void;

Produce the routing parameters from the rewrite information

public function processActionAnnotation( string $module, string $namespaceName, string $controller, string $action, Annotation $annotation );

Checks for annotations in the public methods of the controller

public function processControllerAnnotation( string $handler, Annotation $annotation );

Checks for annotations in the controller docblock

public function setActionPreformatCallback( mixed $callback = null );

Sets the action preformat callback $action here already without suffix ‘Action’

// Array as callback
$annotationRouter->setActionPreformatCallback([Text::class, 'uncamelize']);

// Function as callback
$annotationRouter->setActionPreformatCallback(function(action){
    return action;
});

// String as callback
$annotationRouter->setActionPreformatCallback('strtolower');

// If empty method constructor called [null], sets uncamelize with - delimiter
$annotationRouter->setActionPreformatCallback();
public function setActionSuffix( string $actionSuffix );

Changes the action method suffix

public function setControllerSuffix( string $controllerSuffix );

Changes the controller class suffix

Class Phalcon\Mvc\Router\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\Router   Extends \Phalcon\Exception

Phalcon\Mvc\Router\Exception

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

Class Phalcon\Mvc\Router\Group

Código fuente en 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);

Propiedades

//
protected beforeMatch;

//
protected hostname;

//
protected paths;

//
protected prefix;

//
protected routes;

Métodos

public function __construct( mixed $paths = null );

Phalcon\Mvc\Router\Group constructor

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Añade una ruta al enrutador en cualquier método HTTP

$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;

Establece una llamada de retorno que se llama si la ruta coincide. El desarrollador puede implementar cualquier condición arbitraria aquí. Si la función de retorno devuelve false la ruta será tratada como no coincidente

public function clear(): void;

Removes all the pre-defined routes

public function getBeforeMatch(): callable;

Devuelve la función de retorno ‘before match’ si la hay

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

Código fuente en 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);

Métodos

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Añade una ruta al enrutador en cualquier método HTTP

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;

Establece una llamada de retorno que se llama si la ruta coincide. El desarrollador puede implementar cualquier condición arbitraria aquí. Si la función de retorno devuelve false la ruta será tratada como no coincidente

public function clear(): void;

Removes all the pre-defined routes

public function getBeforeMatch(): callable;

Devuelve la función de retorno ‘before match’ si la hay

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

Código fuente en GitHub

Namespace Phalcon\Mvc\Router   Implements RouteInterface

Phalcon\Mvc\Router\Route

Esta clase representa cada ruta agregada al enrutador

Propiedades

//
protected beforeMatch;

//
protected compiledPattern;

//
protected converters;

//
protected group;

//
protected hostname;

//
protected id;

//
protected methods;

//
protected match;

//
protected name;

//
protected paths;

//
protected pattern;

//
protected static uniqueId = 0;

Métodos

public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );

Phalcon\Mvc\Router\Route constructor

public function beforeMatch( mixed $callback ): RouteInterface;

Establece una llamada de retorno que se llama si la ruta coincide. El desarrollador puede implementar cualquier condición arbitraria aquí. Si la función de retorno devuelve false la ruta será tratada como no coincidente

$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;

Extrae parámetros de una cadena

public function getBeforeMatch(): callable;

Devuelve la función de retorno ‘before match’ si la hay

public function getCompiledPattern(): string;

Devuelve el patrón compilado de la ruta

public function getConverters(): array;

Devuelve el convertidor del router

public function getGroup(): GroupInterface | null;

Returns the group associated with the route

public function getHostname(): string;

Returns the hostname restriction if any

public function getHttpMethods(): array | string;

Returns the HTTP methods that constraint matching the route

public function getId()
public function getMatch(): callable;

Returns the ‘match’ callback if any

public function getName(): string;

Devuelve el nombre de la ruta

public function getPaths(): array;

Devuelve las rutas

public function getPattern(): string;

Devuelve el patrón de la ruta

public function getReversedPaths(): array;

Devuelve las rutas usando posiciones como claves y nombres como valores

public function getRouteId(): string;

Devuelve la identidad de la ruta

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;

Reconfigura la ruta agregando un nuevo patrón y un conjunto de rutas

public static function reset(): void;

Restablece el generador de identificador de ruta interno

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;

Establece el nombre de la ruta

$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

Código fuente en GitHub

Namespace Phalcon\Mvc\Router

Phalcon\Mvc\Router\RouteInterface

Interface for Phalcon\Mvc\Router\Route

Métodos

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;

Devuelve el patrón de la ruta

public function getHostname(): string;

Returns the hostname restriction if any

public function getHttpMethods(): string | array;

Returns the HTTP methods that constraint matching the route

public function getName(): string;

Devuelve el nombre de la ruta

public function getPaths(): array;

Devuelve las rutas

public function getPattern(): string;

Devuelve el patrón de la ruta

public function getReversedPaths(): array;

Devuelve las rutas usando posiciones como claves y nombres como valores

public function getRouteId(): string;

Devuelve la identidad de la ruta

public function reConfigure( string $pattern, mixed $paths = null ): void;

Reconfigura la ruta agregando un nuevo patrón y un conjunto de rutas

public static function reset(): void;

Restablece el generador de identificador de ruta interno

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;

Establece el nombre de la ruta

public function via( mixed $httpMethods ): RouteInterface;

Set one or more HTTP methods that constraint the matching of the route

Interface Phalcon\Mvc\RouterInterface

Código fuente en GitHub

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

Interface for Phalcon\Mvc\Router

Métodos

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Añade una ruta al enrutador en cualquier método HTTP

public function addConnect( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Add a route to the router that only match if the HTTP method is OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PURGE (Squid and Varnish support)

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Adds a route to the router that only match if the HTTP method is TRACE

public function attach( RouteInterface $route, mixed $position = static-constant-access ): RouterInterface;

Attach Route object to the routes stack.

public function clear(): void;

Removes all the defined routes

public function getActionName(): string;

Devuelve el nombre de la acción procesada

public function getControllerName(): string;

Returns processed controller name

public function getMatchedRoute(): RouteInterface;

Devuelve la ruta que coincide con el URI gestionado

public function getMatches(): array;

Devuelve las subexpresiones coincidentes en la expresión regular

public function getModuleName(): string;

Devuelve el nombre del módulo procesado

public function getNamespaceName(): string;

Returns processed namespace name

public function getParams(): array;

Devuelve los parámetros extra procesados

public function getRouteById( mixed $id ): RouteInterface | bool;

Devuelve un objeto de ruta por su identidad

public function getRouteByName( string $name ): RouteInterface | bool;

Devuelve un objeto de ruta por su nombre

public function getRoutes(): RouteInterface[];

Devuelve todas las rutas definidas en el enrutador

public function handle( string $uri ): void;

Gestiona la información de enrutamiento recibida del motor de reescritura

public function mount( GroupInterface $group ): RouterInterface;

Mounts a group of routes in the router

public function setDefaultAction( string $actionName ): RouterInterface;

Establece el nombre de acción predeterminado

public function setDefaultController( string $controllerName ): RouterInterface;

Establece el nombre predeterminado del controlador

public function setDefaultModule( string $moduleName ): RouterInterface;

Establece el nombre del módulo predeterminado

public function setDefaults( array $defaults ): RouterInterface;

Establece un vector de rutas por defecto

public function wasMatched(): bool;

Comprueba si el enrutador coincide con alguna de las rutas definidas

Class Phalcon\Mvc\View

Código fuente en GitHub

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

Phalcon\Mvc\View

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

use Phalcon\Mvc\View;

$view = new View();

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

$view->start();

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

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

Constantes

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;

Propiedades

//
protected actionName;

//
protected activeRenderPaths;

//
protected basePath = ;

//
protected content = ;

//
protected controllerName;

//
protected currentRenderLevel = 0;

//
protected disabled = false;

//
protected disabledLevels;

//
protected engines = false;

//
protected eventsManager;

//
protected layout;

//
protected layoutsDir = ;

//
protected mainView = index;

//
protected options;

//
protected params;

//
protected pickView;

//
protected partialsDir = ;

//
protected registeredEngines;

//
protected renderLevel = 5;

//
protected templatesAfter;

//
protected templatesBefore;

//
protected viewsDirs;

//
protected viewParams;

Métodos

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

Constructor Phalcon\Mvc\View

public function __get( string $key ): mixed | null;

Método mágico para obtener las variables pasadas a la vista

echo $this->view->products;
public function __isset( string $key ): bool;

Método mágico para obtener si una variable está establecida en la vista

echo isset($this->view->products);
public function __set( string $key, mixed $value );

Método mágico para pasar variables a las vistas

$this->view->products = $products;
public function cleanTemplateAfter(): View;

Reestablece cualquier plantilla anterior de la disposición

public function cleanTemplateBefore(): View;

Restablece cualquier disposición de “plantilla anterior”

public function disable(): View;

Deshabilita el proceso de auto-renderizado

public function disableLevel( mixed $level ): ViewInterface;

Deshabilita un nivel específico de renderizado

// Render all levels except ACTION level
$this->view->disableLevel(
    View::LEVEL_ACTION_VIEW
);
public function enable(): View;

Habilita el proceso de auto-renderizado

public function exists( string $view ): bool;

Comprueba si existe la vista

public function finish(): View;

Finaliza el proceso de renderizado deteniendo el búfer de salida

public function getActionName(): string;

Obtiene el nombre de la acción renderizada

public function getActiveRenderPath(): string | array;

Devuelve la ruta (o rutas) de las vistas que se están renderizando actualmente

public function getBasePath(): string;

Obtiene la ruta base

public function getContent(): string;

Devuelve la salida desde otra etapa de vista

public function getControllerName(): string;

Obtiene el nombre del controlador renderizado

public function getCurrentRenderLevel()
public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getLayout(): string;

Obtiene el nombre de la vista principal

public function getLayoutsDir(): string;

Obtiene los diseños actuales del subdirectorio

public function getMainView(): string;

Obtiene el nombre de la vista principal

public function getParamsToView(): array;

Obtiene los parámetros de las vistas

public function getPartial( string $partialPath, mixed $params = null ): string;

Renderiza una vista parcial

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

Obtiene el subdirectorio actual de parciales

public function getRegisteredEngines()
public function getRender( string $controllerName, string $actionName, array $params = [], mixed $configCallback = null ): string;

Realiza el renderizado automático devolviendo la salida como una cadena

$template = $this->view->getRender(
    "products",
    "show",
    [
        "products" => $products,
    ]
);
public function getRenderLevel()
public function getVar( string $key );

Devuelve un parámetro previamente establecido en la vista

public function getViewsDir(): string | array;

Devuelve el directorio de las vistas

public function isDisabled(): bool;

Si está habilitado el renderizado automático

public function partial( string $partialPath, mixed $params = null );

Renderiza una vista parcial

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

Elige una vista diferente a renderizar en vez del último-controlador/última-acción

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;

Registra motores de plantillas

$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;

Ejecuta el proceso de renderizado desde los datos de despacho

// Shows recent posts view (app/views/posts/recent.phtml)
$view->start()->render("posts", "recent")->finish();
public function reset(): View;

Resetea el componente vista a sus valores predeterminados de fábrica

public function setBasePath( string $basePath ): View;

Establece la ruta base. Depending of your platform, always add a trailing slash or backslash

$view->setBasePath(__DIR__ . "/");
public function setContent( string $content ): View;

Establece externamente el contenido de la vista

$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el administrador de eventos

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;

Establece el nombre de la vista predeterminada. 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;

Añade parámetros a las vistas (alias de setVar)

$this->view->setParamToView("products", $products);
public function setPartialsDir( string $partialsDir ): View;

Establece un subdirectorio de parciales. 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;

Establece el nivel de renderizado de la vista

// Render the view related to the controller only
$this->view->setRenderLevel(
    View::LEVEL_LAYOUT
);
public function setTemplateAfter( mixed $templateAfter ): View;

Establece una disposición de controlador “plantilla posterior”

public function setTemplateBefore( mixed $templateBefore ): View;

Establece una plantilla anterior a la disposición del controlador

public function setVar( string $key, mixed $value ): View;

Establece un parámetro de vista único

$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): View;

Establece todos los parámetros de renderizado

$this->view->setVars(
    [
        "products" => $products,
    ]
);
public function setViewsDir( mixed $viewsDir ): View;

Establece el directorio de las vistas. Depending of your platform, always add a trailing slash or backslash

public function start(): View;

Inicia el proceso de renderizado habilitando el búfer de salida

public function toString( string $controllerName, string $actionName, array $params = [] ): string;

Renderiza la vista y la devuelve como una cadena

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;

Devuelve los directorios de las vistas

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

Código fuente en 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.

Propiedades

//
protected view;

Métodos

public function __construct( ViewBaseInterface $view, DiInterface $container = null );

Phalcon\Mvc\View\Engine constructor

public function getContent(): string;

Devuelve la salida almacenada en caché en otra etapa de visualización

public function getView(): ViewBaseInterface;

Devuelve el componente de vista relacionados con el adaptador

public function partial( string $partialPath, mixed $params = null ): void;

Representa una vista parcial dentro de otro punto de vista

Interface Phalcon\Mvc\View\Engine\EngineInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\View\Engine

Interface for Phalcon\Mvc\View engine adapters

Métodos

public function getContent(): string;

Devuelve la salida almacenada en caché en otra etapa de visualización

public function partial( string $partialPath, mixed $params = null ): void;

Representa una vista parcial dentro de otro punto de vista

public function render( string $path, mixed $params, bool $mustClean = bool );

Renderiza una vista utilizando el motor de plantillas

Class Phalcon\Mvc\View\Engine\Php

Código fuente en GitHub

Namespace Phalcon\Mvc\View\Engine   Extends AbstractEngine

Adapter to use PHP itself as templating engine

Métodos

public function render( string $path, mixed $params, bool $mustClean = bool );

Renderiza una vista utilizando el motor de plantillas

Class Phalcon\Mvc\View\Engine\Volt

Código fuente en GitHub

Namespace Phalcon\Mvc\View\Engine   Uses Phalcon\Di\DiInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface, Phalcon\Mvc\View\Engine\Volt\Compiler, Phalcon\Mvc\View\Exception   Extends AbstractEngine   Implements EventsAwareInterface

Designer friendly and fast template engine for PHP written in Zephir/C

Propiedades

//
protected compiler;

//
protected eventsManager;

//
protected macros;

//
protected options;

Métodos

public function callMacro( string $name, array $arguments = [] ): mixed;

Comprueba si una macro está definida y la llama

public function convertEncoding( string $text, string $from, string $to ): string;

Realiza una conversión cadena

public function getCompiler(): Compiler;

Devuelve el compilador del Volt

public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getOptions(): array;

Obtener las opciones de Volt

public function isIncluded( mixed $needle, mixed $haystack ): bool;

Comprueba si se incluye la aguja en el pajar

public function length( mixed $item ): int;

Filtro de longitud. Si se pasa un objeto o matriz se realiza un count(), de lo contrario realiza un strlen()<code>/mb_strlen()</code>

public function render( string $templatePath, mixed $params, bool $mustClean = bool );

Renderiza una vista utilizando el motor de plantillas

public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el administrador de eventos

public function setOptions( array $options );

Establecer las opciones del Volt

public function slice( mixed $value, int $start = int, mixed $end = null );

Extrae un trozo de un valor de un string/array/objecto iterable

public function sort( array $value ): array;

Ordena una matriz

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

Código fuente en 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();

Propiedades

//
protected autoescape = false;

//
protected blockLevel = 0;

//
protected blocks;

//
protected container;

//
protected compiledTemplatePath;

//
protected currentBlock;

//
protected currentPath;

//
protected exprLevel = 0;

//
protected extended = false;

//
protected extensions;

//
protected extendedBlocks;

//
protected filters;

//
protected foreachLevel = 0;

//
protected forElsePointers;

//
protected functions;

//
protected level = 0;

//
protected loopPointers;

//
protected macros;

//
protected options;

//
protected prefix;

//
protected view;

Métodos

public function __construct( ViewBaseInterface $view = null );

Phalcon\Mvc\View\Engine\Volt\Compiler

public function addExtension( mixed $extension ): Compiler;

Registers a Volt’s extension

public function addFilter( string $name, mixed $definition ): Compiler;

Register a new filter in the compiler

public function addFunction( string $name, mixed $definition ): Compiler;

Register a new function in the compiler

public function attributeReader( array $expr ): string;

Resuelve la lectura de atributos

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;

Compila una sentencia “autoescape” devolviendo código PHP

public function compileCache( array $statement, bool $extendsMode = bool ): string;

Compiles a “cache” statement returning PHP code

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

public function compileCall( array $statement, bool $extendsMode );

Compila llamadas a 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;

Compila una sentencia {{ }} devolviendo código PHP

public function compileElseIf( array $statement ): string;

Compiles a “elseif” statement returning PHP code

public function compileFile( string $path, string $compiledPath, bool $extendsMode = bool );

Compiles a template into a file forcing the destination path

$compiler->compileFile(
    "views/layouts/main.volt",
    "views/layouts/main.volt.php"
);
public function compileForElse(): string;

Generates a ‘forelse’ PHP code

public function compileForeach( array $statement, bool $extendsMode = bool ): string;

Compiles a “foreach” intermediate code representation into plain PHP code

public function compileIf( array $statement, bool $extendsMode = bool ): string;

Compiles a ‘if’ statement returning PHP code

public function compileInclude( array $statement ): string;

Compiles a ‘include’ statement returning PHP code

public function compileMacro( array $statement, bool $extendsMode ): string;

Compiles macros

public function compileReturn( array $statement ): string;

Compiles a “return” statement returning PHP code

public function compileSet( array $statement ): string;

Compiles a “set” statement returning PHP code

public function compileString( string $viewCode, bool $extendsMode = bool ): string;

Compila una plantilla en una cadena

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

Resuelve un nodo de expresión en un árbol AST de Volt

final public function fireExtensionEvent( string $name, mixed $arguments = null );

Fires an event to registered extensions

public function functionCall( array $expr ): string;

Resuelve el código intermedio de funciones en llamadas a funciones PHP

public function getCompiledTemplatePath(): string;

Devuelve la ruta a la última plantilla compilada

public function getDI(): DiInterface;

Devuelve el inyector de dependencias interno

public function getExtensions(): array;

Returns the list of extensions registered in Volt

public function getFilters(): array;

Register the user registered filters

public function getFunctions(): array;

Register the user registered functions

public function getOption( string $option );

Returns a compiler’s option

public function getOptions(): array;

Devuelve las opciones del compilador

public function getTemplatePath(): string;

Devuelve la ruta que está siendo compilada actualmente

public function getUniquePrefix(): string;

Return a unique prefix to be used as prefix for compiled variables and contexts

public function parse( string $viewCode );

Analiza una plantilla Volt devolviendo su representación intermedia

print_r(
    $compiler->parse("{{ 3 + 2 }}")
);
public function resolveTest( array $test, string $left ): string;

Resuelve el código intermedio de filtro en una expresión PHP válida

public function setDI( DiInterface $container ): void;

Configura el inyector de dependencia

public function setOption( string $option, mixed $value );

Establece una única opción del compilador

public function setOptions( array $options );

Establece las opciones del compilador

public function setUniquePrefix( string $prefix ): Compiler;

Establece un prefijo único a usar como prefijo de las variables compiladas

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

Código fuente en GitHub

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

Class for exceptions thrown by Phalcon\Mvc\View

Propiedades

//
protected statement;

Métodos

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

Código fuente en GitHub

Namespace Phalcon\Mvc\View   Extends \Phalcon\Exception

Phalcon\Mvc\View\Exception

Class for exceptions thrown by Phalcon\Mvc\View

Class Phalcon\Mvc\View\Simple

Código fuente en GitHub

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

Phalcon\Mvc\View\Simple

This component allows to render views without hierarchical levels

use Phalcon\Mvc\View\Simple as View;

$view = new View();

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

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

Propiedades

//
protected activeRenderPath;

//
protected content;

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

//
protected eventsManager;

//
protected options;

//
protected partialsDir;

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

//
protected viewsDir;

//
protected viewParams;

Métodos

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

Phalcon\Mvc\View\Simple constructor

public function __get( string $key ): mixed | null;

Método mágico para obtener las variables pasadas a la vista

echo $this->view->products;
public function __set( string $key, mixed $value );

Método mágico para pasar variables a las vistas

$this->view->products = $products;
public function getActiveRenderPath(): string;

Returns the path of the view that is currently rendered

public function getContent(): string;

Devuelve la salida desde otra etapa de vista

public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getParamsToView(): array;

Obtiene los parámetros de las vistas

public function getRegisteredEngines(): array|null
public function getVar( string $key ): mixed | null;

Devuelve un parámetro previamente establecido en la vista

public function getViewsDir(): string;

Devuelve el directorio de las vistas

public function partial( string $partialPath, mixed $params = null );

Renderiza una vista parcial

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

Registra motores de plantillas

$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;

Establece externamente el contenido de la vista

$this->view->setContent("<h1>hello</h1>");
public function setEventsManager( ManagerInterface $eventsManager ): void;

Establece el administrador de eventos

public function setParamToView( string $key, mixed $value ): Simple;

Añade parámetros a las vistas (alias de setVar)

$this->view->setParamToView("products", $products);
public function setVar( string $key, mixed $value ): Simple;

Establece un parámetro de vista único

$this->view->setVar("products", $products);
public function setVars( array $params, bool $merge = bool ): Simple;

Establece todos los parámetros de renderizado

$this->view->setVars(
    [
        "products" => $products,
    ]
);
public function setViewsDir( string $viewsDir );

Sets views directory

final protected function internalRender( string $path, mixed $params );

Tries to render the view with every engine registered in the component

protected function loadTemplateEngines(): array;

Loads registered template engines, if none are registered it will use Phalcon\Mvc\View\Engine\Php

Interface Phalcon\Mvc\ViewBaseInterface

Código fuente en GitHub

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

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View and Phalcon\Mvc\View\Simple

Métodos

public function getContent(): string;

Returns cached output from another view stage

public function getParamsToView(): array;

Obtiene los parámetros de las vistas

public function getViewsDir(): string | array;

Devuelve el directorio de las vistas

public function partial( string $partialPath, mixed $params = null );

Renderiza una vista parcial

public function setContent( string $content );

Establece externamente el contenido de la vista

public function setParamToView( string $key, mixed $value );

Añade parámetros a las vistas (alias de 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

Código fuente en GitHub

Namespace Phalcon\Mvc   Extends ViewBaseInterface

Phalcon\Mvc\ViewInterface

Interface for Phalcon\Mvc\View

Métodos

public function cleanTemplateAfter();

Reestablece cualquier plantilla anterior de la disposición

public function cleanTemplateBefore();

Reestablece cualquier plantilla anterior de la disposición

public function disable();

Deshabilita el proceso de auto-renderizado

public function enable();

Habilita el proceso de auto-renderizado

public function finish();

Finaliza el proceso de renderizado deteniendo el búfer de salida

public function getActionName(): string;

Obtiene el nombre de la acción renderizada

public function getActiveRenderPath(): string | array;

Returns the path of the view that is currently rendered

public function getBasePath(): string;

Obtiene la ruta base

public function getControllerName(): string;

Obtiene el nombre del controlador renderizado

public function getLayout(): string;

Obtiene el nombre de la vista principal

public function getLayoutsDir(): string;

Obtiene los diseños actuales del subdirectorio

public function getMainView(): string;

Obtiene el nombre de la vista principal

public function getPartialsDir(): string;

Obtiene el subdirectorio actual de parciales

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

Registra motores de plantillas

public function render( string $controllerName, string $actionName, array $params = [] ): ViewInterface | bool;

Ejecuta el proceso de renderizado desde los datos de despacho

public function reset();

Resetea el componente vista a sus valores predeterminados de fábrica

public function setBasePath( string $basePath );

Establece la ruta base. 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 );

Establece el nombre de la vista predeterminada. Must be a file without extension in the views directory

public function setPartialsDir( string $partialsDir );

Establece un subdirectorio de parciales. 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;

Establece el nivel de renderizado de la vista

public function setTemplateAfter( mixed $templateAfter );

Appends template after controller layout

public function setTemplateBefore( mixed $templateBefore );

Appends template before controller layout

public function start();

Inicia el proceso de renderizado habilitando el búfer de salida