| 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.
Czech
German
Greek
English (US)
Persian
French
Indonesian
Italian
Japanese
Korean
Polish
Portuguese, Brazilian
Russian
Turkish
Ukrainian
Chinese Simplifieduse 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();
/**
* @var bool
*/
protected implicitView = true;
/**
* @var bool
*/
protected sendCookies = true;
/**
* @var bool
*/
protected sendHeaders = true;
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
| 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
| 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",
]
);
}
}
final public function __construct();
Constructor Phalcon\Mvc\Controller
| Namespace | Phalcon\Mvc\Controller |
Phalcon\Mvc\Controller\BindModelInterface
Interfaz para Phalcon\Mvc\Controller
public static function getModelName(): string;
Devuelve el nombre del modelo asociado con este controlador
| Namespace | Phalcon\Mvc |
Phalcon\Mvc\ControllerInterface
Interfaz para manejadores de controlador
| 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();
//
protected defaultAction = index;
//
protected defaultHandler = index;
//
protected handlerSuffix = Controller;
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
| Namespace | Phalcon\Mvc\Dispatcher | Extends | \Phalcon\Dispatcher\Exception |
Phalcon\Mvc\Dispatcher\Exception
Las excepciones lanzadas en Phalcon\Mvc\Dispatcher usarán esta clase
| Namespace | Phalcon\Mvc | Uses | Phalcon\Dispatcher\DispatcherInterface | Extends | DispatcherInterfaceBase |
Phalcon\Mvc\DispatcherInterface
Interfaz para Phalcon\Mvc\Dispatcher
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
| Namespace | Phalcon\Mvc |
Phalcon\Mvc\EntityInterface
Interfaz para Phalcon\Mvc\Collection y Phalcon\Mvc\Model
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
| 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");
/**
* @var callable|null
*/
protected activeHandler;
/**
* @var array
*/
protected afterBindingHandlers;
/**
* @var array
*/
protected afterHandlers;
/**
* @var array
*/
protected beforeHandlers;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var callable|null
*/
protected errorHandler;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected finishHandlers;
/**
* @var array
*/
protected handlers;
/**
* @var BinderInterface|null
*/
protected modelBinder;
/**
* @var callable|null
*/
protected notFoundHandler;
/**
* @var callable|null
*/
protected responseHandler;
/**
* @var mixed|null
*/
protected returnedValue;
/**
* @var RouterInterface|null
*/
protected router;
/**
* @var bool
*/
protected stopped = false;
public function __construct( DiInterface $container = null );
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(): void;
Detiene la ejecución del software intermedio evitando que se ejecuten otros softwares intermedios
| 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);
/**
* @var callable
*/
protected handler;
/**
* @var array
*/
protected handlers;
/**
* @var bool
*/
protected lazy = false;
/**
* @var string
*/
protected prefix = ;
public function delete( string $routePattern, callable $handler, string $name = null ): CollectionInterface;
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.
| Namespace | Phalcon\Mvc\Micro |
Phalcon\Mvc\Micro\CollectionInterface
Interfaz para Phalcon\Mvc\Micro\Collection
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
| Namespace | Phalcon\Mvc\Micro | Extends | \Exception |
Las excepciones lanzadas en Phalcon\Mvc\Micro usarán esta clase
| Namespace | Phalcon\Mvc\Micro | Uses | Phalcon\Mvc\Model\BinderInterface |
Phalcon\Mvc\Micro\LazyLoader
Carga perezosa de manejadores para Mvc\Micro utilizando la autocarga
/**
* @var string
*/
protected definition;
/**
* @var object|null
*/
protected handler;
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;
| Namespace | Phalcon\Mvc\Micro | Uses | Phalcon\Mvc\Micro |
Permite implementar el software intermedio Phalcon\Mvc\Micro en clases
public function call( Micro $application );
Llama al software intermedio
| 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!";
}
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;
/**
* @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
*/
protected uniqueTypes;
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);
}
}
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface | Implements | BehaviorInterface |
Phalcon\Mvc\Model\Behavior
Este es una clase base opcional para comportamientos ORM
/**
* @var array
*/
protected options;
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
| 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
public function notify( string $type, ModelInterface $model );
Escucha las notificaciones del gestor de modelos
| 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
public function notify( string $type, ModelInterface $model );
Escucha las notificaciones del gestor de modelos
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\BehaviorInterface
Interfaz para Phalcon\Mvc\Model\Behavior
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
| 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
/**
* Array for storing active bound models
*
* @var array
*/
protected boundModels;
/**
* Cache object used for caching parameters for model binding
*
* @var AdapterInterface|null
*/
protected cache;
/**
* Internal cache for caching parameters for model binding during request
*
* @var array
*/
protected internalCache;
/**
* Array for original values
*
* @var array
*/
protected originalValues;
public function __construct( AdapterInterface $cache = null );
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
| Namespace | Phalcon\Mvc\Model\Binder |
Phalcon\Mvc\Model\Binder\BindableInterface
Interfaz para clases vinculables
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
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Cache\Adapter\AdapterInterface |
Phalcon\Mvc\Model\BinderInterface
Interfaz para 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;
Obtiene modelos enlazados activos
public function getCache(): AdapterInterface;
Obtiene instancia de caché
public function setCache( AdapterInterface $cache ): BinderInterface;
Establece la instancia de caché
| 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();
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var int
*/
protected hiddenParamNumber = 0;
/**
* @var string|null
*/
protected model;
/**
* @var array
*/
protected params;
public function andWhere( string $conditions, mixed $bindParams = null, mixed $bindTypes = null ): CriteriaInterface;
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á
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
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Di\DiInterface |
Phalcon\Mvc\Model\CriteriaInterface
Interfaz para Phalcon\Mvc\Model\Criteria
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á
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
| Namespace | Phalcon\Mvc\Model | Extends | \Exception |
Phalcon\Mvc\Model\Exception
Las excepciones lanzadas en clases Phalcon\Mvc\Model* usarán esta clase
| 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);
/**
* @var array
*/
protected aliases;
/**
* Models' behaviors
*
* @var array
*/
protected behaviors;
/**
* Belongs to relations
*
* @var array
*/
protected belongsTo;
/**
* All the relationships by model
*
* @var array
*/
protected belongsToSingle;
/**
* @var BuilderInterface|null
*/
protected builder;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var array
*/
protected customEventsManager;
/**
* Does the model use dynamic update, instead of updating all rows?
*
* @var array
*/
protected dynamicUpdate;
/**
* @var EventsManagerInterface|null
*/
protected eventsManager;
/**
* Has many relations
*
* @var array
*/
protected hasMany;
/**
* Has many relations by model
*
* @var array
*/
protected hasManySingle;
/**
* Has many-Through relations
*
* @var array
*/
protected hasManyToMany;
/**
* Has many-Through relations by model
*
* @var array
*/
protected hasManyToManySingle;
/**
* Has one relations
*
* @var array
*/
protected hasOne;
/**
* Has one relations by model
*
* @var array
*/
protected hasOneSingle;
/**
* Has one through relations
*
* @var array
*/
protected hasOneThrough;
/**
* Has one through relations by model
*
* @var array
*/
protected hasOneThroughSingle;
/**
* Mark initialized models
*
* @var array
*/
protected initialized;
/**
* @var array
*/
protected keepSnapshots;
/**
* Last model initialized
*
* @var ModelInterface|null
*/
protected lastInitialized;
/**
* Last query created/executed
*
* @var QueryInterface|null
*/
protected lastQuery;
/**
* @var array
*/
protected modelVisibility;
/**
* @var string
*/
protected prefix = ;
/**
* @var array
*/
protected readConnectionServices;
/**
* @var array
*/
protected sources;
/**
* @var array
*/
protected schemas;
/**
* @var array
*/
protected writeConnectionServices;
/**
* Stores a list of reusable instances
*
* @var array
*/
protected reusable;
public function __destruct();
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
| 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
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
| 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);
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;
/**
* @var CacheAdapterInterface|null
*/
protected adapter;
/**
* @var array
*/
protected columnMap;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var array
*/
protected metaData;
/**
* @var StrategyInterface|null
*/
protected strategy;
public function getAdapter(): CacheAdapterInterface | null;
Return the internal cache adapter
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 ): array | null;
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 | null;
Lee los metadatos completos para cierto modelo
print_r(
$metaData->readMetaData(
new Robots()
)
);
final public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;
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 );
Initialize old behaviour for compatability
final protected function initializeColumnMap( ModelInterface $model, mixed $key ): bool;
Initialize ColumnMap for a certain table
final protected function initializeMetaData( ModelInterface $model, mixed $key ): bool;
Inicializa los metadatos para cierta tabla
| 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,
]
);
public function __construct( AdapterFactory $factory, array $options = null );
Constructor Phalcon\Mvc\Model\MetaData\Apcu
| 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)
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
| 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
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
| 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,
]
);
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
| 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.
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
| 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
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
| 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.
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
| 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/",
]
);
/**
* @var string
*/
protected metaDataDir = ./;
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
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\MetaData\Strategy\StrategyInterface |
Phalcon\Mvc\Model\MetaDataInterface
Interfaz para Phalcon\Mvc\Model\MetaData
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 ): array | null;
Lee información del mapa de columnas para cierto modelo usando una constante MODEL_*
public function readMetaData( ModelInterface $model ): array | null;
Lee los metadatos para cierto modelo
public function readMetaDataIndex( ModelInterface $model, int $index ): array | null;
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_*
| 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();
const TYPE_DELETE = 303;
const TYPE_INSERT = 306;
const TYPE_SELECT = 309;
const TYPE_UPDATE = 300;
/**
* @var array
* TODO: Add default value, instead of null, also remove type check
*/
protected ast;
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var mixed|null
*/
protected cache;
/**
* @var array|null
*/
protected cacheOptions;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var bool
*/
protected enableImplicitJoins;
/**
* @var array
*/
protected intermediate;
/**
* @var \Phalcon\Mvc\Model\ManagerInterface|null
*/
protected manager;
/**
* @var \Phalcon\Mvc\Model\MetaDataInterface|null
*/
protected metaData;
/**
* @var array
*/
protected models;
/**
* @var array
*/
protected modelsInstances;
/**
* @var int
*/
protected nestingLevel = -1;
/**
* @var string|null
*/
protected phql;
/**
* @var bool
*/
protected sharedLock = false;
/**
* @var array
*/
protected sqlAliases;
/**
* @var array
*/
protected sqlAliasesModels;
/**
* @var array
*/
protected sqlAliasesModelsInstances;
/**
* @var array
*/
protected sqlColumnAliases;
/**
* @var array
*/
protected sqlModelsAliases;
/**
* @var int|null
*/
protected type;
/**
* @var bool
*/
protected uniqueRow = false;
/**
* TransactionInterface so that the query can wrap a transaction
* around batch updates and intermediate selects within the transaction.
* however if a model got a transaction set inside it will use the local
* transaction instead of this one
*
* @var TransactionInterface|null
*/
protected transaction;
/**
* @var array|null
*/
protected static internalPhqlCache;
public function __construct( string $phql = null, DiInterface $container = null, array $options = [] );
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
| 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);
/**
* @var array
*/
protected bindParams;
/**
* @var array
*/
protected bindTypes;
/**
* @var array|string|null
*/
protected columns;
/**
* @var array|string|null
*/
protected conditions;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var mixed
*/
protected distinct;
/**
* @var bool
*/
protected forUpdate = false;
/**
* @var array
*/
protected group;
/**
* @var string|null
*/
protected having;
/**
* @var int
*/
protected hiddenParamNumber = 0;
/**
* @var array
*/
protected joins;
/**
* @var array|string
*/
protected limit;
/**
* @var array|string
*/
protected models;
/**
* @var int
*/
protected offset = 0;
/**
* @var array|string
*/
protected order;
/**
* @var bool
*/
protected sharedLock = false;
public function __construct( mixed $params = null, DiInterface $container = null );
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
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Mvc\Model\QueryInterface |
Phalcon\Mvc\Model\Query\BuilderInterface
Interfaz para Phalcon\Mvc\Model\Query\Builder
const OPERATOR_AND = and;
const OPERATOR_OR = or;
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
| 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"
);
public static function parsePHQL( string $phql ): array;
Analiza una sentencia PHQL devolviendo una representación intermedia (IR)
| 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";
}
/**
* @var ModelInterface|null
*/
protected model;
/**
* @var bool
*/
protected success;
public function __construct( bool $success, ModelInterface $model = null );
Phalcon\Mvc\Model\Query\Status
public function getMessages(): MessageInterface[];
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
| Namespace | Phalcon\Mvc\Model\Query | Uses | Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\Query\StatusInterface
Interfaz para Phalcon\Mvc\Model\Query\Status
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
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\QueryInterface
Interfaz para Phalcon\Mvc\Model\Query
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
| Namespace | Phalcon\Mvc\Model | Implements | RelationInterface |
Phalcon\Mvc\Model\Relation
Esta clase representa una relación entre dos modelos
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;
/**
* @var array|string
*/
protected fields;
/**
* @var array|string
*/
protected intermediateFields;
/**
* @var string|null
*/
protected intermediateModel;
/**
* @var array|string
*/
protected intermediateReferencedFields;
/**
* @var array
*/
protected options;
/**
* @var array|string
*/
protected referencedFields;
/**
* @var string
*/
protected referencedModel;
/**
* @var int
*/
protected type;
public function __construct( int $type, string $referencedModel, mixed $fields, mixed $referencedFields, array $options = [] );
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
| Namespace | Phalcon\Mvc\Model |
Phalcon\Mvc\Model\RelationInterface
Interfaz para 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 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
| 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
public function setDirtyState( int $dirtyState ): ModelInterface | bool;
Establece el estado del objeto
| 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();
}
const HYDRATE_ARRAYS = 1;
const HYDRATE_OBJECTS = 2;
const HYDRATE_RECORDS = 0;
const TYPE_RESULT_FULL = 0;
const TYPE_RESULT_PARTIAL = 1;
/**
* @var mixed|null
*/
protected activeRow;
/**
* @var CacheInterface|null
*/
protected cache;
/**
* @var int
*/
protected count = 0;
/**
* @var array
*/
protected errorMessages;
/**
* @var int
*/
protected hydrateMode = 0;
/**
* @var bool
*/
protected isFresh = true;
/**
* @var int
*/
protected pointer = 0;
/**
* @var mixed|null
*/
protected row;
/**
* @var array|null
*/
protected rows;
/**
* Phalcon\Db\ResultInterface or false for empty resultset
*
* @var ResultInterface|bool
*/
protected result;
public function __construct( mixed $result, mixed $cache = null );
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
| 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
/**
* @var array
*/
protected columnTypes;
/**
* Unserialised result-set hydrated all rows already. unserialise() sets
* disableHydration to true
*
* @var bool
*/
protected disableHydration = false;
public function __construct( mixed $columnTypes, ResultInterface $result = null, mixed $cache = null );
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
| 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
/**
* @var array|string
*/
protected columnMap;
/**
* @var ModelInterface|Row
*/
protected model;
/**
* @var bool
*/
protected keepSnapshots = false;
public function __construct( mixed $columnMap, mixed $model, mixed $result, mixed $cache = null, bool $keepSnapshots = bool );
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
| Namespace | Phalcon\Mvc\Model | Uses | Closure, Phalcon\Messages\MessageInterface, Phalcon\Mvc\ModelInterface |
Phalcon\Mvc\Model\ResultsetInterface
Interfaz para Phalcon\Mvc\Model\Resultset
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
| Namespace | Phalcon\Mvc\Model | Uses | ArrayAccess, JsonSerializable, Phalcon\Mvc\EntityInterface, Phalcon\Mvc\ModelInterface | Extends | \stdClass | 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].
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");
| 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();
}
/**
* @var bool
*/
protected activeTransaction = false;
/**
* @var AdapterInterface
*/
protected connection;
/**
* @var bool
*/
protected isNewTransaction = true;
/**
* @var ManagerInterface|null
*/
protected manager;
/**
* @var array
*/
protected messages;
/**
* @var ModelInterface|null
*/
protected rollbackRecord;
/**
* @var bool
*/
protected rollbackOnAbort = false;
/**
* @var bool
*/
protected rollbackThrowException = false;
public function __construct( DiInterface $container, bool $autoBegin = bool, string $service = string );
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
| 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
| 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
/**
* @var ModelInterface|null
*/
protected record;
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
| 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();
}
/**
* @var DiInterface|null
*/
protected container;
/**
* @var bool
*/
protected initialized = false;
/**
* @var int
*/
protected number = 0;
/**
* @var bool
*/
protected rollbackPendent = true;
/**
* @var string
*/
protected service = db;
/**
* @var array
*/
protected transactions;
public function __construct( DiInterface $container = null );
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
| Namespace | Phalcon\Mvc\Model\Transaction | Uses | Phalcon\Mvc\Model\TransactionInterface |
Phalcon\Mvc\Model\Transaction\ManagerInterface
Interfaz para 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 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
| Namespace | Phalcon\Mvc\Model | Uses | Phalcon\Mvc\ModelInterface, Phalcon\Mvc\Model\Transaction\ManagerInterface |
Phalcon\Mvc\Model\TransactionInterface
Interfaz para Phalcon\Mvc\Model\Transaction
public function begin(): bool;
Inicia la transacción
public function commit(): bool;
Confirma la transacción
public function getConnection(): \Phalcon\Db\Adapter\AdapterInterface;
Devuelve la conexión relacionada con la transacción
public function getMessages(): array;
Devuelve mensajes de validación desde el último intento de guardado
public function isManaged(): bool;
Comprueba si la transacción es administrada por un gestor de transacciones
public function isValid(): bool;
Comprueba si la conexión interna está bajo una transacción activa
public function rollback( string $rollbackMessage = null, ModelInterface $rollbackRecord = null ): bool;
Deshace la transacción
public function setIsNewTransaction( bool $isNew ): void;
Establece si es una transacción reutilizada o nueva
public function setRollbackOnAbort( bool $rollbackOnAbort ): void;
Establece la opción de cancelación al abortar la conexión HTTP
public function setRollbackedRecord( ModelInterface $record ): void;
Establece el objeto que genera la acción de deshacer
public function setTransactionManager( ManagerInterface $manager ): void;
Establece el gestor de transacciones relacionado con la transacción
public function throwRollbackException( bool $status ): TransactionInterface;
Permite lanzar excepciones
| 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
/**
* @var array
*/
protected messages;
/**
* @var ModelInterface
*/
protected model;
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
| 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
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
| Namespace | Phalcon\Mvc | Uses | Phalcon\Di\DiInterface |
Phalcon\Mvc\ModuleDefinitionInterface
Se debe implementar esta interfaz por definiciones de módulo de clase
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
| 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();
const POSITION_FIRST = 0;
const POSITION_LAST = 1;
/**
* @var string
*/
protected action = "";
/**
* @var string
*/
protected controller = "";
/**
* @var string
*/
protected defaultAction = "";
/**
* @var string
*/
protected defaultController = "";
/**
* @var string
*/
protected defaultModule = "";
/**
* @var string
*/
protected defaultNamespace = "";
/**
* @var array
*/
protected defaultParams;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected keyRouteNames;
/**
* @var array
*/
protected keyRouteIds;
/**
* @var RouteInterface|null
*/
protected matchedRoute;
/**
* @var array
*/
protected matches;
/**
* @var string
*/
protected module = "";
/**
* @var string
*/
protected namespaceName = "";
/**
* @var array|string|null
*/
protected notFoundPaths;
/**
* @var array
*/
protected params;
/**
* @var bool
*/
protected removeExtraSlashes = false;
/**
* @var array
*/
protected routes;
/**
* @var bool
*/
protected wasMatched = false;
public function __construct( bool $defaultRoutes = bool );
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
| 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;
}
);
/**
* @var string
*/
protected actionSuffix = Action;
/**
* @var callable|string|null
*/
protected actionPreformatCallback;
/**
* @var string
*/
protected controllerSuffix = Controller;
/**
* @var array
*/
protected handlers;
/**
* @var string
*/
protected routePrefix = ;
public function addModuleResource( string $module, string $handler, string $prefix = null ): Annotations;
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
| Namespace | Phalcon\Mvc\Router | Extends | \Exception |
Phalcon\Mvc\Router\Exception
Las excepciones lanzadas en Phalcon\Mvc\Router usarán esta clase
| 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);
/**
* @var callable|null
*/
protected beforeMatch;
/**
* @var string|null
*/
protected hostname;
/**
* @var array|string|null
*/
protected paths;
/**
* @var string|null
*/
protected prefix;
/**
* @var array
*/
protected routes;
public function __construct( mixed $paths = null );
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
| Namespace | Phalcon\Mvc\Router |
Phalcon\Mvc\Router\GroupInterface
$router = new \Phalcon\Mvc\Router();
// Create a group with a common module and controller
$blog = new Group(
[
"module" => "blog",
"controller" => "index",
]
);
// All the routes start with /blog
$blog->setPrefix("/blog");
// Add a route to the group
$blog->add(
"/save",
[
"action" => "save",
]
);
// Add another route to the group
$blog->add(
"/edit/{id}",
[
"action" => "edit",
]
);
// This route maps to a controller different than the default
$blog->add(
"/blog",
[
"controller" => "about",
"action" => "index",
]
);
// Add the group to the router
$router->mount($blog);
public function add( string $pattern, mixed $paths = null, mixed $httpMethods = null ): RouteInterface;
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
| Namespace | Phalcon\Mvc\Router | Implements | RouteInterface |
Phalcon\Mvc\Router\Route
Esta clase representa cada ruta agregada al enrutador
/**
* @var callable|null
*/
protected beforeMatch;
/**
* @var string|null
*/
protected compiledPattern;
/**
* @var array
*/
protected converters;
/**
* @var GroupInterface|null
*/
protected group;
/**
* @var string|null
*/
protected hostname;
/**
* @var string|null
*/
protected id;
/**
* @var array|string
*/
protected methods;
/**
* @var callable|null
*/
protected match;
/**
* @var string|null
*/
protected name;
/**
* @var array
*/
protected paths;
/**
* @var string
*/
protected pattern;
/**
* @var int
*/
protected static uniqueId = 0;
public function __construct( string $pattern, mixed $paths = null, mixed $httpMethods = null );
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",
]
);
| Namespace | Phalcon\Mvc\Router |
Phalcon\Mvc\Router\RouteInterface
Interface for Phalcon\Mvc\Router\Route
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
| Namespace | Phalcon\Mvc | Uses | Phalcon\Mvc\Router\RouteInterface, Phalcon\Mvc\Router\GroupInterface |
Interfaz para Phalcon\Mvc\Router
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
| 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",
]
);
/**
* @var null | string
*/
protected baseUri;
/**
* @var null | string
*/
protected basePath;
/**
* @var RouterInterface | null
*/
protected router;
/**
* @var null | string
*/
protected staticBaseUri;
public function __construct( RouterInterface $router = null );
public function get( mixed $uri = null, mixed $args = null, bool $local = null, mixed $baseUri = null ): string;
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/");
| Namespace | Phalcon\Mvc\Url | Extends | \Exception |
Phalcon\Mvc\Url\Exception
Exceptions thrown in Phalcon\Mvc\Url will use this class
| Namespace | Phalcon\Mvc\Url |
Interface for Phalcon\Mvc\Url\UrlInterface
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
| 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();
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;
/**
* @var string
*/
protected actionName;
/**
* @var array
*/
protected activeRenderPaths;
/**
* @var string
*/
protected basePath = ;
/**
* @var string
*/
protected content = ;
/**
* @var string
*/
protected controllerName;
/**
* @var int
*/
protected currentRenderLevel = 0;
/**
* @var bool
*/
protected disabled = false;
/**
* @var array
*/
protected disabledLevels;
/**
* @var array|bool
*/
protected engines = false;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var string|null
*/
protected layout;
/**
* @var string
*/
protected layoutsDir = ;
/**
* @var string
*/
protected mainView = index;
/**
* @var array
*/
protected options;
/**
* @var array
*/
protected params;
/**
* @var array|null
*/
protected pickView;
/**
* @var string
*/
protected partialsDir = ;
/**
* @var array
*/
protected registeredEngines;
/**
* @var int
*/
protected renderLevel = 5;
/**
* @var array
*/
protected templatesAfter;
/**
* @var array
*/
protected templatesBefore;
/**
* @var array
*/
protected viewsDirs;
/**
* @var array
*/
protected viewParams;
public function __construct( array $options = [] );
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 ): mixed | null;
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
| 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.
/**
* @var ViewBaseInterface
*/
protected view;
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
| Namespace | Phalcon\Mvc\View\Engine |
Interfaz para los adaptadores de motor Phalcon\Mvc\View
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
| Namespace | Phalcon\Mvc\View\Engine | Extends | AbstractEngine |
Adaptador para utilizar el mismo PHP como motor de plantillas
public function render( string $path, mixed $params, bool $mustClean = bool );
Renderiza una vista utilizando el motor de plantillas
| 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
/**
* @var Compiler
*/
protected compiler;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected macros;
/**
* @var array
*/
protected options;
public function callMacro( string $name, array $arguments = [] ): mixed;
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
| 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();
/**
* @var bool
*/
protected autoescape = false;
/**
* @var int
*/
protected blockLevel = 0;
/**
* @var array|null
*
* TODO: Make array only?
*/
protected blocks;
/**
* @var DiInterface|null
*/
protected container;
/**
* @var string|null
*/
protected compiledTemplatePath;
/**
* @var string|null
*/
protected currentBlock;
/**
* @var string|null
*/
protected currentPath;
/**
* @var int
*/
protected exprLevel = 0;
/**
* @var bool
*/
protected extended = false;
/**
* @var array
*/
protected extensions;
/**
* @var array|bool
*
* TODO: Make it always array
*/
protected extendedBlocks;
/**
* @var array
*/
protected filters;
/**
* @var int
*/
protected foreachLevel = 0;
/**
* @var array
*/
protected forElsePointers;
/**
* @var array
*/
protected functions;
/**
* @var int
*/
protected level = 0;
/**
* @var array
*/
protected loopPointers;
/**
* @var array
*/
protected macros;
/**
* @var array
*/
protected options;
/**
* @var string
*/
protected prefix = ;
/**
* @var ViewBaseInterface|null
*/
protected view;
public function __construct( ViewBaseInterface $view = null );
Phalcon\Mvc\View\Engine\Volt\Compiler
public function addExtension( mixed $extension ): Compiler;
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
| Namespace | Phalcon\Mvc\View\Engine\Volt | Uses | Phalcon\Mvc\View\Exception | Extends | BaseException |
Clase para excepciones lanzadas por Phalcon\Mvc\View
/**
* @var array
*/
protected statement;
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).
| Namespace | Phalcon\Mvc\View | Extends | \Exception |
Phalcon\Mvc\View\Exception
Clase para excepciones lanzadas por Phalcon\Mvc\View
| 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,
]
);
/**
* @var string
*/
protected activeRenderPath;
/**
* @var string
*/
protected content;
/**
* @var EngineInterface[]|false
*/
protected engines = false;
/**
* @var ManagerInterface|null
*/
protected eventsManager;
/**
* @var array
*/
protected options;
/**
* @var array
*/
protected registeredEngines;
/**
* @var string
*/
protected viewsDir;
/**
* @var array
*/
protected viewParams;
public function __construct( array $options = [] );
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
| Namespace | Phalcon\Mvc | Uses | Phalcon\Cache\Adapter\AdapterInterface |
Phalcon\Mvc\ViewInterface
Interfaz para Phalcon\Mvc\View y Phalcon\Mvc\View\Simple
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
| Namespace | Phalcon\Mvc | Extends | ViewBaseInterface |
Phalcon\Mvc\ViewInterface
Interfaz para Phalcon\Mvc\View
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