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

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

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

/**
 * @var bool
 */
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\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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 $offset ): bool;

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

public function offsetGet( mixed $offset ): 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 $offset, mixed $value ): 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 $offset ): 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

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

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

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

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

Métodos

public function delete( string $routePattern, callable $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, 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 gestor.

public function mapVia( string $routePattern, callable $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, 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 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, callable $handler, string $name = null ): void;

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 controlador 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 controlador 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 controlador 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 controlador 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 controlador 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 \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

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

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

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(): string;
public function getHandler(): object | null;

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

Phalcon\Mvc\Model

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Serializes a model

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

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

public function __unserialize( array $data ): void;

Unserializes an array to the model

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( array $parameters = [] ): 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\Di::getDefault());
$myTransaction->begin();

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

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

$newRobot->save();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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\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 | null;

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 mapeado en el modelo

public function getTransaction(): TransactionInterface | null;
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\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;

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

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

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

Escribe un valor de atributo por su nombre

$robot->writeAttribute("name", "Rosey");
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, array $options = [] ): 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

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 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 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 = null ): ResultsetInterface;

Genera una sentencia PHQL SELECT para un agregado

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

Comprueba si el registro actual ya existe

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

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

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\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;

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

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

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

Abstract Class Phalcon\Mvc\Model\Behavior

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
 *
 * @var AdapterInterface|null
 */
protected cache;

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

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

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;

Return the active bound models

public function getCache(): AdapterInterface;

Establece la instancia de caché

public function getOriginalValues(): array;

Return the array for original values

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

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

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

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

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

/**
 * @var array
 */
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 \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, ReflectionClass, ReflectionProperty   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.

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

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

$di = new Di();

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

$robot = new Robots($di);

Propiedades

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Métodos

public function __destruct();

Destruye la caché PHQL actual

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, array $options = [] ): RelationInterface;

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

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): 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, array $options = [] ): RelationInterface;

Configura una relación n-m entre dos modelos

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

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

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

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

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

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

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

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

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

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

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

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 getBuilder(): BuilderInterface | null;

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

public function getConnectionService( ModelInterface $model, array $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;

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

public function getDI(): DiInterface;

Devuelve el contenedor DependencyInjector

public function getEventsManager(): EventsManagerInterface | null;

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

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 hasBelongsTo( string $modelName, string $modelRelation ): bool;

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

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

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

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

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

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

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

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

Comprueba si un modelo tiene una relación hasOneThrough con otro 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

$param string $prefix

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, array $connectionServices ): AdapterInterface;

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

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

Une dos vectores de parámetros de búsqueda

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, array $options = [] ): RelationInterface;

Configura una relación 1-1 entre dos modelos

public function addHasMany( ModelInterface $model, mixed $fields, string $referencedModel, mixed $referencedFields, array $options = [] ): 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, array $options = [] ): RelationInterface;

Configura una relación n-m entre dos modelos

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

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

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

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 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 hasBelongsTo( string $modelName, string $modelRelation ): bool;

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

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

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

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

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

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

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

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

Comprueba si un modelo tiene una relación hasOneThrough con otro 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|null
 */
protected adapter;

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

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

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

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

@todo Remove this when we get traits

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

Inicializa los metadatos para cierta tabla

Class Phalcon\Mvc\Model\MetaData\Apcu

Código fuente en GitHub

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

Phalcon\Mvc\Model\MetaData\Apcu

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\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\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]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

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]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

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

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

Métodos

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 getTransaction(): TransactionInterface | null;
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 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 _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

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

Resolves an expression from its intermediate code into an array

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

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

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

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\Di, Phalcon\Db\Column, Phalcon\Di\DiInterface, Phalcon\Mvc\Model\Exception, Phalcon\Di\InjectionAwareInterface, Phalcon\Mvc\Model\QueryInterface   Implements BuilderInterface, InjectionAwareInterface

Phalcon\Mvc\Model\Query\Builder

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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( string $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 $conditions, array $bindParams = [], array $bindTypes = [] ): 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( mixed $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

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

/**
 * @var bool
 */
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

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

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

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

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

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

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

/**
 * @var string
 */
protected referencedModel;

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

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\Cache\CacheInterface, Phalcon\Db\Enum, Phalcon\Messages\MessageInterface, Phalcon\Mvc\Model, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface, SeekableIterator, Serializable   Implements ResultsetInterface, Iterator, SeekableIterator, Countable, ArrayAccess, Serializable, JsonSerializable

Phalcon\Mvc\Model\Resultset

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.


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

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

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

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

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

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

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

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

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

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

/**
 * Phalcon\Db\ResultInterface or false for empty resultset
 *
 * @var ResultInterface|bool
 */
protected result;

Métodos

public function __construct( mixed $result, mixed $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(): CacheInterface | null;

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

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. Set the new position if required, and then set 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\Di\Di, Phalcon\Di\DiInterface, Phalcon\Db\ResultInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\ResultsetInterface, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface, stdClass   Extends Resultset   Implements ResultsetInterface

Phalcon\Mvc\Model\Resultset\Complex

Los conjuntos de resultados complejos pueden incluir objetos completos y valores escalares. Esta clase construye cada registro complejo ya que se requiere

Propiedades

/**
 * @var array
 */
protected columnTypes;

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

Métodos

public function __construct( mixed $columnTypes, ResultInterface $result = null, mixed $cache = null );

Constructor Phalcon\Mvc\Model\Resultset\Complex

public function __serialize(): array;
public function __unserialize( array $data ): void;
final public function current(): mixed;

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\Di\Di, Phalcon\Di\DiInterface, Phalcon\Mvc\Model, Phalcon\Mvc\Model\Exception, Phalcon\Mvc\Model\Resultset, Phalcon\Mvc\Model\Row, Phalcon\Mvc\ModelInterface, Phalcon\Storage\Serializer\SerializerInterface   Extends Resultset

Phalcon\Mvc\Model\Resultset\Simple

Los conjuntos de resultados simples solo contienen un objeto completo Esta clase construye cada objeto completo como es requerido

Propiedades

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

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

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

Métodos

public function __construct( mixed $columnMap, mixed $model, mixed $result, mixed $cache = null, bool $keepSnapshots = bool );

Constructor Phalcon\Mvc\Model\Resultset\Simple

public function __serialize(): array;
public function __unserialize( array $data ): void;
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\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(): mixed | null;

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

Este componente permite a Phalcon\Mvc\Model devolver filas sin una entidad asociada. This objects implements the ArrayAccess interface to allow access the object as object->x or 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\Db\Adapter\AdapterInterface, Phalcon\Di\DiInterface, Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\Failed, Phalcon\Mvc\Model\Transaction\ManagerInterface, Phalcon\Mvc\Model\TransactionInterface   Implements TransactionInterface

Phalcon\Mvc\Model\Transaction

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

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

/**
 * @var AdapterInterface
 */
protected connection;

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

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

/**
 * @var array
 */
protected messages;

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

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

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

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

/**
 * @var ModelInterface|null
 */
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\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

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

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

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

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

/**
 * @var string
 */
protected service = db;

/**
 * @var array
 */
protected transactions;

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\Messages\Message, 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

/**
 * @var array
 */
protected messages;

/**
 * @var ModelInterface
 */
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( array $parameters = [] ): 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 = bool ): 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 | null;

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. Enrutamiento es el proceso de tomar un punto final URI (la parte del URI que viene después de la URL base) y descomponerlo en parámetros para determinar qué módulo, controlador y acción de ese controlador debería recibir la solicitud

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

/**
 * @var string
 */
protected action = "";

/**
 * @var string
 */
protected controller = "";

/**
 * @var string
 */
protected defaultAction = "";

/**
 * @var string
 */
protected defaultController = "";

/**
 * @var string
 */
protected defaultModule = "";

/**
 * @var string
 */
protected defaultNamespace = "";

/**
 * @var array
 */
protected defaultParams;

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

/**
 * @var array
 */
protected keyRouteNames;

/**
 * @var array
 */
protected keyRouteIds;

/**
 * @var RouteInterface|null
 */
protected matchedRoute;

/**
 * @var array
 */
protected matches;

/**
 * @var string
 */
protected module = "";

/**
 * @var string
 */
protected namespaceName = "";

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

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

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

/**
 * @var array
 */
protected routes;

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

Métodos

public function __construct( bool $defaultRoutes = bool );

Constructor Phalcon\Mvc\Router

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador sin ninguna restricción HTTP

use Phalcon\Mvc\Router;

$router->add("/about", "About::index");

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"]
);

$router->add(
    "/about",
    "About::index",
    ["GET", "POST"],
    Router::POSITION_FIRST
);
public function addConnect( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es GET

public function addHead( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es POST

public function addPurge( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PURGE (soporte Squid y Varnish)

public function addPut( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = static-constant-access ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es TRACE

public function attach( RouteInterface $route, int $position = static-constant-access ): RouterInterface;

Adjunta un objeto Route a la pila de rutas.

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;

Elimina todas las rutas predefinidas

public function getActionName(): string;

Devuelve el nombre de la acción procesada

public function getControllerName(): string;

Devuelve el nombre del controlador procesado

public function getDefaults(): array;

Devuelve un vector de parámetros predeterminados

public function getEventsManager(): ManagerInterface | null;

Devuelve el administrador de eventos interno

public function getKeyRouteIds(): array;
public function getKeyRouteNames(): array;
public function getMatchedRoute(): RouteInterface | null;

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;

Devuelve el nombre del módulo procesado

public function getNamespaceName(): string;

Devuelve el nombre del espacio de nombres procesado

public function getParams(): array;

Devuelve los parámetros 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

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

Monta un grupo de rutas en el enrutador

public function notFound( mixed $paths ): RouterInterface;

Establece un grupo de rutas que se devolverán cuando ninguna de las rutas definidas coincidan

public function removeExtraSlashes( bool $remove ): RouterInterface;

Establece si el enrutador debe eliminar las barras adicionales en las rutas gestionadas

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;

Establece el nombre del espacio de nombres predeterminado

@parma string namespaceName

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( array $routeIds ): Router;
public function setKeyRouteNames( array $routeNames ): Router;
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

Un enrutador que lee anotaciones de rutas desde clases/recursos

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

/**
 * @var string
 */
protected actionSuffix = Action;

/**
 * @var callable|string|null
 */
protected actionPreformatCallback;

/**
 * @var string
 */
protected controllerSuffix = Controller;

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

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

Métodos

public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;

Añade un recurso al manejador de anotaciones. Un recurso es una clase que contiene anotaciones de enrutamiento. La clase se encuentra en un módulo

public function addResource( string $handler, string $prefix = null ): Annotations;

Añade un recurso al manejador de anotaciones. Un recurso es una clase que contiene anotaciones de enrutamiento

public function getActionPreformatCallback();
public function getResources(): array;

Devuelve los recursos registrados

public function handle( string $uri ): void;

Produce los parámetros de enrutamiento desde la información de reescritura

public function processActionAnnotation( string $module, string $namespaceName, string $controller, string $action, Annotation $annotation ): void;

Comprueba las anotaciones en los métodos públicos del controlador

public function processControllerAnnotation( string $handler, Annotation $annotation );

Comprueba las anotaciones en el docblock del controlador

public function setActionPreformatCallback( mixed $callback = null );

Establece aquí la llamada de retorno de preformato de la acción $action ya sin el sufijo ‘Action’

// Array as callback
$annotationRouter->setActionPreformatCallback(
     [
         new Uncamelize(),
         '__invoke'
     ]
 );

// Function as callback
$annotationRouter->setActionPreformatCallback(
    function ($action) {
        return $action;
    }
);

// String as callback
$annotationRouter->setActionPreformatCallback('strtolower');

// If empty method constructor called [null], sets uncamelize with - delimiter
$annotationRouter->setActionPreformatCallback();
public function setActionSuffix( string $actionSuffix );

Cambia el sufijo del método de acción

public function setControllerSuffix( string $controllerSuffix );

Cambia el sufijo de la clase del controlador

Class Phalcon\Mvc\Router\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\Router   Extends \Exception

Phalcon\Mvc\Router\Exception

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

Class Phalcon\Mvc\Router\Group

Código fuente en GitHub

Namespace Phalcon\Mvc\Router   Implements GroupInterface

Phalcon\Mvc\Router\Group

Clase auxiliar para crear un grupo de rutas con atributos comunes

$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

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

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

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

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

/**
 * @var array
 */
protected routes;

Métodos

public function __construct( mixed $paths = null );

Constructor Phalcon\Mvc\Router\Group

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;

Añade una ruta al enrutador que sólo coincide si el método HTTP es CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PURGE

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es 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;

Elimina todas las rutas predefinidas

public function getBeforeMatch(): callable;

Devuelve la función de retorno ‘before match’ si la hay

public function getHostname(): string;

Devuelve la restricción del nombre de host

public function getPaths(): array | string;

Devuelve las rutas comunes definidas para este grupo

public function getPrefix(): string;

Devuelve el prefijo común para todas las rutas

public function getRoutes(): RouteInterface[];

Devuelve las rutas añadidas al grupo

public function setHostname( string $hostname ): GroupInterface;

Establece una restricción de nombre de host para todas las rutas del grupo

public function setPaths( mixed $paths ): GroupInterface;

Establece rutas comunes para todas las rutas del grupo

public function setPrefix( string $prefix ): GroupInterface;

Establece un prefijo de uri común para todas las rutas de este grupo

protected function addRoute( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;

Añade una ruta aplicando los atributos comunes

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;

Añade una ruta al enrutador que sólo coincide si el método HTTP es CONNECT

public function addDelete( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es DELETE

public function addGet( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es GET

public function addHead( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es HEAD

public function addOptions( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es OPTIONS

public function addPatch( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PATCH

public function addPost( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es POST

public function addPurge( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PURGE

public function addPut( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PUT

public function addTrace( string $pattern, mixed $paths = null ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es 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;

Elimina todas las rutas predefinidas

public function getBeforeMatch(): callable;

Devuelve la función de retorno ‘before match’ si la hay

public function getHostname(): string;

Devuelve la restricción del nombre de host

public function getPaths(): array | string;

Devuelve las rutas comunes definidas para este grupo

public function getPrefix(): string;

Devuelve el prefijo común para todas las rutas

public function getRoutes(): RouteInterface[];

Devuelve las rutas añadidas al grupo

public function setHostname( string $hostname ): GroupInterface;

Establece una restricción de nombre de host para todas las rutas del grupo

public function setPaths( mixed $paths ): GroupInterface;

Establece rutas comunes para todas las rutas del grupo

public function setPrefix( string $prefix ): GroupInterface;

Establece un prefijo de uri común para todas las rutas de este grupo

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

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

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

/**
 * @var array
 */
protected converters;

/**
 * @var GroupInterface|null
 */
protected group;

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

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

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

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

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

/**
 * @var array
 */
protected paths;

/**
 * @var string
 */
protected pattern;

/**
 * @var int
 */
protected static uniqueId = 0;

Métodos

public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );

Constructor Phalcon\Mvc\Router\Route

public function beforeMatch( callable $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;

Reemplaza los marcadores de posición del patrón devolviendo una expresión regular PCRE válida

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;

Devuelve el grupo asociado con la ruta

public function getHostname(): string | null;

Devuelve la restricción del nombre de host si hay

public function getHttpMethods(): array | string;

Devuelve los métodos HTTP que coinciden con la ruta

public function getId(): string | null;
public function getMatch(): callable;

Devuelve la función de retorno ‘match’ si la hay

public function getName(): string | null;

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;

Devuelve routePaths

public function match( mixed $callback ): RouteInterface;

Permite establecer un función de retorno para manejar la solicitud directamente en la ruta

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

Establece el grupo asociado a la ruta

public function setHostname( string $hostname ): RouteInterface;

Establece una restricción de nombre de host a la ruta

$route->setHostname("localhost");
public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Establece un conjunto de métodos HTTP que restringen la coincidencia de la ruta (alias de 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;

Establece uno o más métodos HTTP que restringen la coincidencia de la ruta

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

Reemplaza los marcadores de posición del patrón devolviendo una expresión regular PCRE válida

public function convert( string $name, mixed $converter ): RouteInterface;

Agrega un convertidor para realizar una transformación adicional para cierto parámetro.

public function getCompiledPattern(): string;

Devuelve el patrón de la ruta

public function getHostname(): string | null;

Devuelve la restricción del nombre de host si hay

public function getHttpMethods(): string | array;

Devuelve los métodos HTTP que coinciden con la ruta

public function getName(): string | null;

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;

Establece una restricción de nombre de host a la ruta

public function setHttpMethods( mixed $httpMethods ): RouteInterface;

Establece un conjunto de métodos HTTP que restringen la coincidencia de la ruta

public function setName( string $name ): RouteInterface;

Establece el nombre de la ruta

public function via( mixed $httpMethods ): RouteInterface;

Establece uno o más métodos HTTP que restringen la coincidencia de la ruta

Interface Phalcon\Mvc\RouterInterface

Código fuente en GitHub

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

Interfaz para Phalcon\Mvc\Router

Métodos

public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador en cualquier método HTTP

public function addConnect( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es CONNECT

public function addDelete( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es DELETE

public function addGet( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es GET

public function addHead( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es HEAD

public function addOptions( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es OPTIONS

public function addPatch( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PATCH

public function addPost( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es POST

public function addPurge( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PURGE (soporte Squid y Varnish)

public function addPut( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es PUT

public function addTrace( string $pattern, mixed $paths = null, int $position = Router::POSITION_LAST ): RouteInterface;

Añade una ruta al enrutador que sólo coincide si el método HTTP es TRACE

public function attach( RouteInterface $route, int $position = Router::POSITION_LAST ): RouterInterface;

Adjunta un objeto Route a la pila de rutas.

public function clear(): void;

Elimina todas las rutas definidas

public function getActionName(): string;

Devuelve el nombre de la acción procesada

public function getControllerName(): string;

Devuelve el nombre del controlador procesado

public function getMatchedRoute(): RouteInterface | null;

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;

Devuelve el nombre del espacio de nombres procesado

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;

Monta un grupo de rutas en el enrutador

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\Url

Código fuente en GitHub

Namespace Phalcon\Mvc   Uses Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Mvc\RouterInterface, Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Url\Exception, Phalcon\Mvc\Url\UrlInterface   Extends AbstractInjectionAware   Implements UrlInterface

Estos componentes ayudan en la generación de: URIs, URLs y rutas

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2012",
    ]
);

Propiedades

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

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

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

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

Métodos

public function __construct( RouterInterface $router = null );
public function get( mixed $uri = null, mixed $args = null, bool $local = null, mixed $baseUri = null ): string;

Genera una URL

// Generate a URL appending the URI to the base URI
echo $url->get("products/edit/1");

// Generate a URL for a predefined route
echo $url->get(
    [
        "for"   => "blog-post",
        "title" => "some-cool-stuff",
        "year"  => "2015",
    ]
);

// Generate a URL with GET arguments (/show/products?id=1&name=Carrots)
echo $url->get(
    "show/products",
    [
        "id"   => 1,
        "name" => "Carrots",
    ]
);

// Generate an absolute URL by setting the third parameter as false.
echo $url->get(
    "https://phalcon.io/",
    null,
    false
);
public function getBasePath(): string;

Devuelve la ruta base

public function getBaseUri(): string;

Devuelve el prefijo para todas las urls generadas. Por defecto /

public function getStatic( mixed $uri = null ): string;

Genera una URL para un recurso estático

// Generate a URL for a static resource
echo $url->getStatic("img/logo.png");

// Generate a URL for a static predefined route
echo $url->getStatic(
    [
        "for" => "logo-cdn",
    ]
);
public function getStaticBaseUri(): string;

Devuelve el prefijo para todas las urls estáticas generadas. Por defecto /

public function path( string $path = null ): string;

Genera una ruta local

public function setBasePath( string $basePath ): UrlInterface;

Establece una ruta base para todas las rutas generadas

$url->setBasePath("/var/www/htdocs/");
public function setBaseUri( string $baseUri ): UrlInterface;

Establece un prefijo para todas las URIs a generar

$url->setBaseUri("/invo/");

$url->setBaseUri("/invo/index.php/");
public function setStaticBaseUri( string $staticBaseUri ): UrlInterface;

Establece un prefijo para todas las URLs estáticas generadas

$url->setStaticBaseUri("/invo/");

Class Phalcon\Mvc\Url\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\Url   Extends \Exception

Phalcon\Mvc\Url\Exception

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

Interface Phalcon\Mvc\Url\UrlInterface

Código fuente en GitHub

Namespace Phalcon\Mvc\Url

Interface for Phalcon\Mvc\Url\UrlInterface

Métodos

public function get( mixed $uri = null, mixed $args = null, bool $local = null ): string;

Genera una URL

public function getBasePath(): string;

Devuelve una ruta base

public function getBaseUri(): string;

Devuelve el prefijo para todas las urls generadas. Por defecto /

public function path( string $path = null ): string;

Genera una ruta local

public function setBasePath( string $basePath ): UrlInterface;

Establece una ruta base para todas las rutas generadas

public function setBaseUri( string $baseUri ): UrlInterface;

Establece un prefijo para todas las urls generadas

Class Phalcon\Mvc\View

Código fuente en GitHub

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

Phalcon\Mvc\View

Phalcon\Mvc\View es una clase para trabajar con la porción “vista” del patrón modelo-vista-controlador. Es decir, existe para ayudar a mantener el script de vistas separado de los scripts de modelos y controladores. Proporciona un sistema de ayudantes, filtros de salida y escape de variables.

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

/**
 * @var string
 */
protected actionName;

/**
 * @var array
 */
protected activeRenderPaths;

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

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

/**
 * @var string
 */
protected controllerName;

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

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

/**
 * @var array
 */
protected disabledLevels;

/**
 * @var array|bool
 */
protected engines = false;

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

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

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

/**
 * @var string
 */
protected mainView = index;

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

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

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

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

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

/**
 * @var int
 */
protected renderLevel = 5;

/**
 * @var array
 */
protected templatesAfter;

/**
 * @var array
 */
protected templatesBefore;

/**
 * @var array
 */
protected viewsDirs;

/**
 * @var array
 */
protected viewParams;

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;

Checks whether view exists @deprecated

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(): int;
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(): array;
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(): int;
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 has( string $view ): bool;

Comprueba si existe la vista

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;

Procesa la vista y las plantillas; Dispara eventos si es necesario

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. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

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

Cambia la disposición a usar en vez de usar el nombre del último nombre de controlador

$this->view->setLayout("main");
public function setLayoutsDir( string $layoutsDir ): View;

Establece el subdirectorio de disposiciones. Debe ser un directorio dentro del directorio de vistas. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

$view->setLayoutsDir("../common/layouts/");
public function setMainView( string $viewPath ): View;

Establece el nombre de la vista predeterminada. Debe ser un fichero sin extensión en el directorio de vistas

// 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. Debe ser un directorio dentro del directorio de vistas. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

$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. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

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

Comprueba si la vista existe en las extensiones registradas y la renderiza

protected function getViewsDirs(): array;

Devuelve los directorios de las vistas

final protected function isAbsolutePath( string $path );

Comprueba si una ruta es absoluta o no

protected function loadTemplateEngines(): array;

Carga motores de plantilla registrados, si no hay ninguno registrado usará 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

Todos los adaptadores del motor de plantillas deben heredar esta clase. Esto proporciona interfaz básica entre el motor y el componente Phalcon\Mvc\View.

Propiedades

/**
 * @var ViewBaseInterface
 */
protected view;

Métodos

public function __construct( ViewBaseInterface $view, DiInterface $container = null );

Constructor Phalcon\Mvc\View\Engine

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

Interfaz para los adaptadores de motor Phalcon\Mvc\View

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

TODO: Change params to array type

Class Phalcon\Mvc\View\Engine\Php

Código fuente en GitHub

Namespace Phalcon\Mvc\View\Engine   Extends AbstractEngine

Adaptador para utilizar el mismo PHP como motor de plantillas

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\Html\Link\Link, Phalcon\Html\Link\Serializer\Header, Phalcon\Mvc\View\Engine\Volt\Compiler, Phalcon\Mvc\View\Exception   Extends AbstractEngine   Implements EventsAwareInterface

Diseñador fácil y rápido motor de plantillas para PHP escrito en Zephir/C

Propiedades

/**
 * @var Compiler
 */
protected compiler;

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

/**
 * @var array
 */
protected macros;

/**
 * @var array
 */
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 preload( mixed $parameters ): string;

Parses the preload element passed and sets the necessary link headers @todo find a better way to handle this

public function render( string $path, mixed $params, bool $mustClean = bool );

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

Esta clase lee y compila plantillas Volt a código PHP plano

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

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

require $compiler->getCompiledTemplatePath();

Propiedades

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

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

/**
 * @var array|null
 *
 * TODO: Make array only?
 */
protected blocks;

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

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

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

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

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

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

/**
 * @var array
 */
protected extensions;

/**
 * @var array|bool
 *
 * TODO: Make it always array
 */
protected extendedBlocks;

/**
 * @var array
 */
protected filters;

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

/**
 * @var array
 */
protected forElsePointers;

/**
 * @var array
 */
protected functions;

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

/**
 * @var array
 */
protected loopPointers;

/**
 * @var array
 */
protected macros;

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

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

/**
 * @var ViewBaseInterface|null
 */
protected view;

Métodos

public function __construct( ViewBaseInterface $view = null );

Phalcon\Mvc\View\Engine\Volt\Compiler

public function addExtension( mixed $extension ): Compiler;

Registra una extensión de Volt

@var mixed extension

public function addFilter( string $name, mixed $definition ): Compiler;

Registra un nuevo filtro en el compilador

public function addFunction( string $name, mixed $definition ): Compiler;

Registra una nueva función en el compilador

public function attributeReader( array $expr ): string;

Resuelve la lectura de atributos

public function compile( string $templatePath, bool $extendsMode = bool );

Compila una plantilla en un archivo aplicando las opciones del compilador Este método no devuelve la ruta compilada si la plantilla no fue compilada

$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 compileCall( array $statement, bool $extendsMode );

Compila llamadas a macros

public function compileCase( array $statement, bool $caseClause = bool ): string;

Compila una cláusula “case”/”default” devolviendo código PHP

public function compileDo( array $statement ): string;

Compila una sentencia “do” devolviendo código PHP

public function compileEcho( array $statement ): string;

Compila una sentencia {{ }} devolviendo código PHP

public function compileElseIf( array $statement ): string;

Compila una sentencia “elseif” devolviendo código PHP

public function compileFile( string $path, string $compiledPath, bool $extendsMode = bool );

Compila una plantilla en un fichero forzando la ruta destino

$compiler->compileFile(
    "views/layouts/main.volt",
    "views/layouts/main.volt.php"
);
public function compileForElse(): string;

Genera un código PHP ‘forelse’

public function compileForeach( array $statement, bool $extendsMode = bool ): string;

Compila una representación intermedia de código “foreach” en código PHP plano

public function compileIf( array $statement, bool $extendsMode = bool ): string;

Compila una sentencia ‘if’ devolviendo código PHP

public function compileInclude( array $statement ): string;

Compila una sentencia ‘include’ devolviendo código PHP

public function compileMacro( array $statement, bool $extendsMode ): string;

Compila macros

public function compileReturn( array $statement ): string;

Compila una sentencia “return” devolviendo código PHP

@throws \Phalcon\Mvc\View\Engine\Volt\Exception

public function compileSet( array $statement ): string;

Compila una sentencia “set” devolviendo código PHP

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;

Compila una sentencia ‘switch’ devolviendo código PHP

final public function expression( array $expr, bool $doubleQuotes = bool ): string;

Resuelve un nodo de expresión en un árbol AST de Volt

final public function fireExtensionEvent( string $name, array $arguments = [] );

Dispara un evento a las extensiones registradas

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

Devuelve la lista de extensiones registradas en Volt

public function getFilters(): array;

Devuelve los filtros registrados por el usuario

public function getFunctions(): array;

Devuelve las funciones registradas por el usuario

public function getOption( string $option ): string | null;

Devuelve la opción de un compilador

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;

Devuelve un prefijo único a usar como prefijo de las variables y contextos compilados

public function parse( string $viewCode ): array;

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;

Compila un código fuente Volt devolviendo una versión plana en PHP

protected function getFinalPath( string $path );

Obtiene la ruta final con VIEW

final protected function resolveFilter( array $filter, string $left ): string;

Resuelve filtrar código intermedio en llamadas a funciones PHP

final protected function statementList( array $statements, bool $extendsMode = bool ): string;

Recorre una lista de sentencias compilando cada uno de sus nodos

final protected function statementListOrExtends( mixed $statements );

Compila un bloque de sentencias

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

Clase para excepciones lanzadas por Phalcon\Mvc\View

Propiedades

/**
 * @var array
 */
protected statement;

Métodos

public function __construct( string $message = string, array $statement = [], int $code = int, \Exception $previous = null );
public function getStatement(): array;

Obtiene la instrucción analizada (si existe).

Class Phalcon\Mvc\View\Exception

Código fuente en GitHub

Namespace Phalcon\Mvc\View   Extends \Exception

Phalcon\Mvc\View\Exception

Clase para excepciones lanzadas por 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\Mvc\ViewBaseInterface, Phalcon\Mvc\View\Engine\EngineInterface, Phalcon\Mvc\View\Engine\Php   Extends Injectable   Implements ViewBaseInterface, EventsAwareInterface

Phalcon\Mvc\View\Simple

Este componente permite renderizar vistas sin niveles jerárquicos

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

/**
 * @var string
 */
protected activeRenderPath;

/**
 * @var string
 */
protected content;

/**
 * @var EngineInterface[]|false
 */
protected engines = false;

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

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

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

/**
 * @var string
 */
protected viewsDir;

/**
 * @var array
 */
protected viewParams;

Métodos

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

Constructor Phalcon\Mvc\View\Simple

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

Método mágico para pasar variables a las vistas

$this->view->products = $products;
public function getActiveRenderPath(): string;

Devuelve la ruta de la vista que actualmente se está renderizando

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

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

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;

Renderiza una vista

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

Establece el directorio de las vistas

final protected function internalRender( string $path, mixed $params ): void;

Intenta renderizar la vista con cada motor registrado en el componente

protected function loadTemplateEngines(): array;

Carga los motores de plantilla registrados, si no hay ninguno registrado usará 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

Interfaz para Phalcon\Mvc\View y Phalcon\Mvc\View\Simple

Métodos

public function getContent(): string;

Devuelve la salida almacenada en caché desde otra etapa de vista

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

Añade parámetros a las vistas

public function setViewsDir( string $viewsDir );

Establece el directorio de las vistas. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

Interface Phalcon\Mvc\ViewInterface

Código fuente en GitHub

Namespace Phalcon\Mvc   Extends ViewBaseInterface

Phalcon\Mvc\ViewInterface

Interfaz para 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;

Devuelve la ruta de la vista que actualmente se está renderizando

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;

Si está deshabilitado el renderizado automático

public function pick( string $renderView );

Elige una vista diferente a renderizar en vez del último-controlador/última-acción

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. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

public function setLayout( string $layout );

Cambia la disposición a usar en vez de usar el nombre del último nombre de controlador

public function setLayoutsDir( string $layoutsDir );

Establece el subdirectorio de disposiciones. Debe ser un directorio dentro del directorio de vistas. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

public function setMainView( string $viewPath );

Establece el nombre de la vista predeterminada. Debe ser un fichero sin extensión en el directorio de vistas

public function setPartialsDir( string $partialsDir );

Establece un subdirectorio de parciales. Debe ser un directorio dentro del directorio de vistas. Dependiendo de su plataforma, siempre añada una barra diagonal o barra invertida al final

public function setRenderLevel( int $level ): ViewInterface;

Establece el nivel de renderizado de la vista

public function setTemplateAfter( mixed $templateAfter );

Añade la plantilla después del diseño del controlador

public function setTemplateBefore( mixed $templateBefore );

Añade la plantilla antes del diseño del controlador

public function start();

Inicia el proceso de renderizado habilitando el búfer de salida