From f76aa64eb8cbeea959bb5ffe1f2d1c115365cee7 Mon Sep 17 00:00:00 2001
From: Nikolaos Dimopoulos <nikos@niden.net>
Date: Fri, 27 Oct 2017 13:20:27 -0400
Subject: [PATCH] New Crowdin translations (#1373)

* New translations db-models-behaviors.md (Spanish)

* New translations db-models-cache.md (Spanish)

* New translations db-models-transactions.md (Spanish)

* New translations db-layer.md (Spanish)

* New translations db-models-events.md (Spanish)

* New translations db-models-metadata.md (Spanish)

* New translations new-feature-request.md (Spanish)

* New translations new-pull-request.md (Spanish)
---
 es/db-layer.md               | 178 ++++++++++++++--------------
 es/db-models-behaviors.md    |  64 +++++-----
 es/db-models-cache.md        | 224 +++++++++++++++++------------------
 es/db-models-events.md       | 128 ++++++++++----------
 es/db-models-metadata.md     | 135 +++++++++++----------
 es/db-models-transactions.md |  76 ++++++------
 es/new-feature-request.md    |  12 +-
 es/new-pull-request.md       |  10 +-
 8 files changed, 412 insertions(+), 415 deletions(-)

diff --git a/es/db-layer.md b/es/db-layer.md
index 93ee936e1c3f..d481340edd6b 100644
--- a/es/db-layer.md
+++ b/es/db-layer.md
@@ -1,68 +1,68 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">Database Abstraction Layer</a> <ul>
+      <a href="#overview">Capa de abstracción de base de datos</a> <ul>
         <li>
-          <a href="#adapters">Database Adapters</a> <ul>
+          <a href="#adapters">Adaptadores de base de datos</a> <ul>
             <li>
               <a href="#adapters-custom">Implementing your own adapters</a>
             </li>
           </ul>
         </li>
         <li>
-          <a href="#dialects">Database Dialects</a> <ul>
+          <a href="#dialects">Dialectos de la base de datos</a> <ul>
             <li>
-              <a href="#dialects-custom">Implementing your own dialects</a>
+              <a href="#dialects-custom">Implementar sus propios dialectos</a>
             </li>
           </ul>
         </li>
         <li>
-          <a href="#connection">Connecting to Databases</a> <ul>
+          <a href="#connection">Conexión a bases de datos</a> <ul>
             <li>
-              <a href="#connection-factory">Connecting using Factory</a>
+              <a href="#connection-factory">Conexión usando Factory</a>
             </li>
           </ul>
         </li>
         <li>
-          <a href="#options">Setting up additional PDO options</a>
+          <a href="#options">Configuración de opciones adicionales de PDO</a>
         </li>
         <li>
-          <a href="#finding-rows">Finding Rows</a>
+          <a href="#finding-rows">Encontrar Registros</a>
         </li>
         <li>
-          <a href="#binding-parameters">Binding Parameters</a>
+          <a href="#binding-parameters">Enlazando parámetros</a>
         </li>
         <li>
-          <a href="#crud">Inserting/Updating/Deleting Rows</a>
+          <a href="#crud">Insertar/Actualizar/Borrar registros</a>
         </li>
         <li>
-          <a href="#transactions">Transactions and Nested Transactions</a>
+          <a href="#transactions">Transacciones y transacciones anidadas</a>
         </li>
         <li>
-          <a href="#events">Database Events</a>
+          <a href="#events">Eventos de base de datos</a>
         </li>
         <li>
-          <a href="#profiling">Profiling SQL Statements</a>
+          <a href="#profiling">Perfiles de sentencias SQL</a>
         </li>
         <li>
-          <a href="#logging-statements">Logging SQL Statements</a>
+          <a href="#logging-statements">Log de sentencias SQL</a>
         </li>
         <li>
-          <a href="#logger-custom">Implementing your own Logger</a>
+          <a href="#logger-custom">Implementar tu propio Logger</a>
         </li>
         <li>
-          <a href="#describing-tables">Describing Tables/Views</a>
+          <a href="#describing-tables">Descripción de tablas o vistas</a>
         </li>
         <li>
-          <a href="#tables">Creating/Altering/Dropping Tables</a> <ul>
+          <a href="#tables">Crear/Modificar/Eliminar tablas</a> <ul>
             <li>
-              <a href="#tables-create">Creating Tables</a>
+              <a href="#tables-create">Crear tablas</a>
             </li>
             <li>
-              <a href="#tables-altering">Altering Tables</a>
+              <a href="#tables-altering">Modificar tablas</a>
             </li>
             <li>
-              <a href="#tables-dropping">Dropping Tables</a>
+              <a href="#tables-dropping">Eliminar tablas</a>
             </li>
           </ul>
         </li>
@@ -73,23 +73,23 @@
 
 <a name='overview'></a>
 
-# Database Abstraction Layer
+# Capa de abstracción de base de datos
 
-`Phalcon\Db` is the component behind `Phalcon\Mvc\Model` that powers the model layer in the framework. It consists of an independent high-level abstraction layer for database systems completely written in C.
+`Phalcon\Db` es el componente detrás de `Phalcon\Mvc\Model` que impulsa la capa del modelo del framework. Este consiste en una capa de abstracción de alto nivel independiente para bases de datos, escrito completamente en C.
 
-This component allows for a lower level database manipulation than using traditional models.
+Este componente permite una manipulación de base de datos a nivel inferior que el uso de los modelos tradicionales.
 
 <a name='adapters'></a>
 
-## Database Adapters
+## Adaptadores de base de datos
 
 This component makes use of adapters to encapsulate specific database system details. Phalcon uses PDO_ to connect to databases. The following database engines are supported:
 
-| Class                                   | Description                                                                                                                                                                                                                          |
-| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `Phalcon\Db\Adapter\Pdo\Mysql`      | Is the world's most used relational database management system (RDBMS) that runs as a server providing multi-user access to a number of databases                                                                                    |
-| `Phalcon\Db\Adapter\Pdo\Postgresql` | PostgreSQL is a powerful, open source relational database system. It has more than 15 years of active development and a proven architecture that has earned it a strong reputation for reliability, data integrity, and correctness. |
-| `Phalcon\Db\Adapter\Pdo\Sqlite`     | SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine                                                                                                     |
+| Clase                                   | Descripción                                                                                                                                                                                                                                                |
+| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Phalcon\Db\Adapter\Pdo\Mysql`      | Is the world's most used relational database management system (RDBMS) that runs as a server providing multi-user access to a number of databases                                                                                                          |
+| `Phalcon\Db\Adapter\Pdo\Postgresql` | PostgreSQL es un sistema de base de datos relacional de código abierto muy potente. Tiene más de 15 años de desarrollo activo y una arquitectura probada que se ha ganado una sólida reputación por la fiabilidad, la integridad y exactitud de los datos. |
+| `Phalcon\Db\Adapter\Pdo\Sqlite`     | SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine                                                                                                                           |
 
 <a name='adapters-custom'></a>
 
@@ -99,25 +99,25 @@ The `Phalcon\Db\AdapterInterface` interface must be implemented in order to crea
 
 <a name='dialects'></a>
 
-## Database Dialects
+## Dialectos de la base de datos
 
 Phalcon encapsulates the specific details of each database engine in dialects. Those provide common functions and SQL generator to the adapters.
 
-| Class                              | Description                                         |
-| ---------------------------------- | --------------------------------------------------- |
-| `Phalcon\Db\Dialect\Mysql`      | SQL specific dialect for MySQL database system      |
-| `Phalcon\Db\Dialect\Postgresql` | SQL specific dialect for PostgreSQL database system |
-| `Phalcon\Db\Dialect\Sqlite`     | SQL specific dialect for SQLite database system     |
+| Clase                              | Descripción                                           |
+| ---------------------------------- | ----------------------------------------------------- |
+| `Phalcon\Db\Dialect\Mysql`      | Dialecto específico SQL para base de datos MySQL      |
+| `Phalcon\Db\Dialect\Postgresql` | Dialecto específico SQL para base de datos PostgreSQL |
+| `Phalcon\Db\Dialect\Sqlite`     | Dialecto específico SQL para base de datos de SQLite  |
 
 <a name='dialects-custom'></a>
 
-### Implementing your own dialects
+### Implementar sus propios dialectos
 
 The `Phalcon\Db\DialectInterface` interface must be implemented in order to create your own database dialects or extend the existing ones.
 
 <a name='connection'></a>
 
-## Connecting to Databases
+## Conexión a bases de datos
 
 To create a connection it's necessary instantiate the adapter class. It only requires an array with the connection parameters. The example below shows how to create a connection passing both required and optional parameters:
 
@@ -171,7 +171,7 @@ $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
 
 <a name='options'></a>
 
-## Setting up additional PDO options
+## Configuración de opciones adicionales de PDO
 
 You can set PDO options at connection time by passing the parameters `options`:
 
@@ -195,7 +195,7 @@ $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(
 
 <a name='connection-factory'></a>
 
-## Connecting using Factory
+## Conexión usando Factory
 
 You can also use a simple `ini` file to configure/connect your `db` service to your database.
 
@@ -234,7 +234,7 @@ The above will return the correct database instance and also has the advantage t
 
 <a name='finding-rows'></a>
 
-## Finding Rows
+## Encontrar Registros
 
 `Phalcon\Db` provides several methods to query rows from tables. The specific SQL syntax of the target database engine is required in this case:
 
@@ -263,12 +263,12 @@ $robot = $connection->fetchOne($sql);
 
 By default these calls create arrays with both associative and numeric indexes. You can change this behavior by using `Phalcon\Db\Result::setFetchMode()`. This method receives a constant, defining which kind of index is required.
 
-| Constant                   | Description                                               |
-| -------------------------- | --------------------------------------------------------- |
-| `Phalcon\Db::FETCH_NUM`   | Return an array with numeric indexes                      |
-| `Phalcon\Db::FETCH_ASSOC` | Return an array with associative indexes                  |
-| `Phalcon\Db::FETCH_BOTH`  | Return an array with both associative and numeric indexes |
-| `Phalcon\Db::FETCH_OBJ`   | Return an object instead of an array                      |
+| Constante                  | Descripción                                           |
+| -------------------------- | ----------------------------------------------------- |
+| `Phalcon\Db::FETCH_NUM`   | Devuelve un array con índices numéricos               |
+| `Phalcon\Db::FETCH_ASSOC` | Devuelve un array con índices asociativos             |
+| `Phalcon\Db::FETCH_BOTH`  | Devuelve un array con índices asociativos y numéricos |
+| `Phalcon\Db::FETCH_OBJ`   | Devolver un objeto en lugar de un array               |
 
 ```php
 <?php
@@ -305,7 +305,7 @@ echo $result->numRows();
 
 <a name='binding-parameters'></a>
 
-## Binding Parameters
+## Enlazando parámetros
 
 Bound parameters is also supported in `Phalcon\Db`. Although there is a minimal performance impact by using bound parameters, you are encouraged to use this methodology so as to eliminate the possibility of your code being subject to SQL injection attacks. Both string and positional placeholders are supported. Binding parameters can simply be achieved as follows:
 
@@ -353,7 +353,7 @@ $result = $connection->query(
 
 <a name='crud'></a>
 
-## Inserting/Updating/Deleting Rows
+## Insertar/Actualizar/Borrar registros
 
 To insert, update or delete rows, you can use raw SQL or use the preset functions provided by the class:
 
@@ -478,7 +478,7 @@ $success = $connection->delete(
 
 <a name='transactions'></a>
 
-## Transactions and Nested Transactions
+## Transacciones y transacciones anidadas
 
 Working with transactions is supported as it is with PDO. Perform data manipulation inside transactions often increase the performance on most database systems:
 
@@ -542,19 +542,19 @@ try {
 
 <a name='events'></a>
 
-## Database Events
+## Eventos de base de datos
 
 `Phalcon\Db` is able to send events to a [EventsManager](/[[language]]/[[version]]/events) if it's present. Some events when returning boolean false could stop the active operation. The following events are supported:
 
-| Event Name            | Triggered                                            | Can stop operation? |
-| --------------------- | ---------------------------------------------------- |:-------------------:|
-| `afterConnect`        | After a successfully connection to a database system |         No          |
-| `beforeQuery`         | Before send a SQL statement to the database system   |         Yes         |
-| `afterQuery`          | After send a SQL statement to database system        |         No          |
-| `beforeDisconnect`    | Before close a temporal database connection          |         No          |
-| `beginTransaction`    | Before a transaction is going to be started          |         No          |
-| `rollbackTransaction` | Before a transaction is rollbacked                   |         No          |
-| `commitTransaction`   | Before a transaction is committed                    |         No          |
+| Nombre de Evento      | Activador                                                          | ¿Puede detener la operación? |
+| --------------------- | ------------------------------------------------------------------ |:----------------------------:|
+| `afterConnect`        | Después de una conexión con éxito a un sistema de base de datos    |              No              |
+| `beforeQuery`         | Antes de enviar una instrucción SQL en el sistema de base de datos |              Sí              |
+| `afterQuery`          | Después de enviar una instrucción SQL a la base de datos           |              No              |
+| `beforeDisconnect`    | Antes de cerrar una conexión temporal de base de datos             |              No              |
+| `beginTransaction`    | Antes de comenzar una transacción                                  |              No              |
+| `rollbackTransaction` | Antes de anular (roolback) una transacción                         |              No              |
+| `commitTransaction`   | Antes de que una finalizar (commit) una transacción                |              No              |
 
 Bind an EventsManager to a connection is simple, `Phalcon\Db` will trigger the events with the type `db`:
 
@@ -609,7 +609,7 @@ $eventsManager->attach(
 
 <a name='profiling'></a>
 
-## Profiling SQL Statements
+## Perfiles de sentencias SQL
 
 `Phalcon\Db` includes a profiling component called `Phalcon\Db\Profiler`, that is used to analyze the performance of database operations so as to diagnose performance problems and discover bottlenecks.
 
@@ -703,7 +703,7 @@ $eventsManager->attach('db', $dbProfiler);
 
 <a name='logging-statements'></a>
 
-## Logging SQL Statements
+## Log de sentencias SQL
 
 Using high-level abstraction components such as `Phalcon\Db` to access a database, it is difficult to understand which statements are sent to the database system. `Phalcon\Logger` interacts with `Phalcon\Db`, providing logging capabilities on the database abstraction layer.
 
@@ -754,13 +754,13 @@ As above, the file `app/logs/db.log` will contain something like this:
 
 <a name='logger-custom'></a>
 
-## Implementing your own Logger
+## Implementar tu propio Logger
 
 You can implement your own logger class for database queries, by creating a class that implements a single method called `log`. The method needs to accept a string as the first argument. You can then pass your logging object to `Phalcon\Db::setLogger()`, and from then on any SQL statement executed will call that method to log the results.
 
 <a name='describing-tables'></a>
 
-## Describing Tables/Views
+## Descripción de tablas o vistas
 
 `Phalcon\Db` also provides methods to retrieve detailed information about tables and views:
 
@@ -799,9 +799,9 @@ foreach ($references as $reference) {
 
 A table description is very similar to the MySQL describe command, it contains the following information:
 
-| Field        | Type        | Key                                                | Null                               |
-| ------------ | ----------- | -------------------------------------------------- | ---------------------------------- |
-| Field's name | Column Type | Is the column part of the primary key or an index? | Does the column allow null values? |
+| Campo            | Tipo            | Clave                                                      | Nulo                              |
+| ---------------- | --------------- | ---------------------------------------------------------- | --------------------------------- |
+| Nombre del campo | Tipo de columna | ¿Es la columna parte de la clave principal o de un índice? | ¿La columna permite valores null? |
 
 Methods to get information about views are also implemented for every supported database system:
 
@@ -817,13 +817,13 @@ $exists = $connection->viewExists('robots');
 
 <a name='tables'></a>
 
-## Creating/Altering/Dropping Tables
+## Crear/Modificar/Eliminar tablas
 
 Different database systems (MySQL, Postgresql etc.) offer the ability to create, alter or drop tables with the use of commands such as CREATE, ALTER or DROP. The SQL syntax differs based on which database system is used. `Phalcon\Db` offers a unified interface to alter tables, without the need to differentiate the SQL syntax based on the target storage system.
 
 <a name='tables-create'></a>
 
-### Creating Tables
+### Crear tablas
 
 The following example shows how to create a table:
 
@@ -870,19 +870,19 @@ $connection->createTable(
 
 `Phalcon\Db::createTable()` accepts an associative array describing the table. Columns are defined with the class `Phalcon\Db\Column`. The table below shows the options available to define a column:
 
-| Option          | Description                                                                                                                                | Optional |
-| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |:--------:|
-| `type`          | Column type. Must be a `Phalcon\Db\Column` constant (see below for a list)                                                               |    No    |
-| `primary`       | True if the column is part of the table's primary key                                                                                      |   Yes    |
-| `size`          | Some type of columns like `VARCHAR` or `INTEGER` may have a specific size                                                                  |   Yes    |
-| `scale`         | `DECIMAL` or `NUMBER` columns may be have a scale to specify how many decimals should be stored                                            |   Yes    |
-| `unsigned`      | `INTEGER` columns may be signed or unsigned. This option does not apply to other types of columns                                          |   Yes    |
-| `notNull`       | Column can store null values?                                                                                                              |   Yes    |
-| `default`       | Default value (when used with `'notNull' => true`).                                                                                     |   Yes    |
-| `autoIncrement` | With this attribute column will filled automatically with an auto-increment integer. Only one column in the table can have this attribute. |   Yes    |
-| `bind`          | One of the `BIND_TYPE_*` constants telling how the column must be bound before save it                                                     |   Yes    |
-| `first`         | Column must be placed at first position in the column order                                                                                |   Yes    |
-| `after`         | Column must be placed after indicated column                                                                                               |   Yes    |
+| Opción          | Descripción                                                                                                                         | Opcional |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------- |:--------:|
+| `type`          | Tipo de columna. Debe ser una constante de `Phalcon\Db\Column` (ver lista de abajo)                                               |    No    |
+| `primary`       | `true` si la columna forma parte de la clave primaria de la tabla                                                                   |    Sí    |
+| `size`          | Algunos tipos de columnas como `VARCHAR` o `INTEGER` puede tener un tamaño específico                                               |    Sí    |
+| `scale`         | Columnas `DECIMAL` o `NUMBER` pueden tener una escala para especificar cuántos decimales deben almacenarse                          |    Sí    |
+| `unsigned`      | Las columnas `INTEGER` pueden tener signo o no. Esta opción no se aplica a otros tipos de columnas                                  |    Sí    |
+| `notNull`       | ¿La columna puede almacenar valores nulos?                                                                                          |    Sí    |
+| `default`       | Valor por defecto (cuando se usa con `'notNull' => true`).                                                                       |    Sí    |
+| `autoIncrement` | Con este atributo la columna se incrementará automáticamente con un entero. Solo una columna en la tabla puede tener este atributo. |    Sí    |
+| `bind`          | Una de las constantes `BIND_TYPE_*` que indica como debe tratarse la columna antes de guardarse                                     |    Sí    |
+| `first`         | La columna debe colocarse en primera posición en el orden de columnas                                                               |    Sí    |
+| `after`         | La columna debe colocarse después de la columna indicada                                                                            |    Sí    |
 
 `Phalcon\Db` supports the following database column types:
 
@@ -896,16 +896,16 @@ $connection->createTable(
 
 The associative array passed in `Phalcon\Db::createTable()` can have the possible keys:
 
-| Index        | Description                                                                                                                            | Optional |
-| ------------ | -------------------------------------------------------------------------------------------------------------------------------------- |:--------:|
-| `columns`    | An array with a set of table columns defined with `Phalcon\Db\Column`                                                                |    No    |
-| `indexes`    | An array with a set of table indexes defined with `Phalcon\Db\Index`                                                                 |   Yes    |
-| `references` | An array with a set of table references (foreign keys) defined with `Phalcon\Db\Reference`                                           |   Yes    |
-| `options`    | An array with a set of table creation options. These options often relate to the database system in which the migration was generated. |   Yes    |
+| Índice       | Descripción                                                                                                                                                     | Opcional |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |:--------:|
+| `columns`    | Un array con un conjunto de columnas de la tabla definida con `Phalcon\Db\Column`                                                                             |    No    |
+| `indexes`    | Un array con un conjunto de índices de la tabla definida con `Phalcon\Db\Index`                                                                               |    Sí    |
+| `references` | Un array con un conjunto de referencias de tabla (foreign keys) definidas con `Phalcon\Db\Reference`                                                          |    Sí    |
+| `options`    | Un array con un conjunto de opciones de creación de la tabla. Estas opciones se refieren a menudo al sistema de base de datos en la que se generó la migración. |    Sí    |
 
 <a name='tables-altering'></a>
 
-### Altering Tables
+### Modificar tablas
 
 As your application grows, you might need to alter your database, as part of a refactoring or adding new features. Not all database systems allow to modify existing columns or add columns between two existing ones. `Phalcon\Db` is limited by these constraints.
 
@@ -953,7 +953,7 @@ $connection->dropColumn(
 
 <a name='tables-dropping'></a>
 
-### Dropping Tables
+### Eliminar tablas
 
 Examples on dropping tables:
 
diff --git a/es/db-models-behaviors.md b/es/db-models-behaviors.md
index f4801d8160aa..90ccfa489c7b 100644
--- a/es/db-models-behaviors.md
+++ b/es/db-models-behaviors.md
@@ -1,7 +1,7 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">Model Behaviors</a> <ul>
+      <a href="#overview">Comportamientos en modelos (Behaviors)</a> <ul>
         <li>
           <a href="#timestampable">Timestampable</a>
         </li>
@@ -9,10 +9,10 @@
           <a href="#softdelete">SoftDelete</a>
         </li>
         <li>
-          <a href="#create-your-own-behaviors">Creating your own behaviors</a>
+          <a href="#create-your-own-behaviors">Crea tus propios comportamientos</a>
         </li>
         <li>
-          <a href="#traits-as-behaviors">Using Traits as behaviors</a>
+          <a href="#traits-as-behaviors">Utilizando traits como comportamientos</a>
         </li>
       </ul>
     </li>
@@ -21,11 +21,11 @@
 
 <a name='overview'></a>
 
-# Model Behaviors
+# Comportamientos en modelos (Behaviors)
 
-Behaviors are shared conducts that several models may adopt in order to re-use code, the ORM provides an API to implement behaviors in your models. Also, you can use the events and callbacks as seen before as an alternative to implement Behaviors with more freedom.
+Los comportamientos son conductas compartidas que varios modelos pueden adoptar con el fin de reutilizar código, el ORM proporciona una API para implementar comportamientos en sus modelos. Además, puede utilizar los eventos y callbacks, como se ha visto antes, como una alternativa para implementar comportamientos con más libertad.
 
-A behavior must be added in the model initializer, a model can have zero or more behaviors:
+Un comportamiento debe agregarse en el inicializador del modelo, un modelo puede tener cero o más comportamientos:
 
 ```php
 <?php
@@ -57,18 +57,18 @@ class Users extends Model
 }
 ```
 
-The following built-in behaviors are provided by the framework:
+Phalcon proporciona los siguientes comportamientos listos para utilizarse:
 
-| Name          | Description                                                                                                |
-| ------------- | ---------------------------------------------------------------------------------------------------------- |
-| Timestampable | Allows to automatically update a model's attribute saving the datetime when a record is created or updated |
-| SoftDelete    | Instead of permanently delete a record it marks the record as deleted changing the value of a flag column  |
+| Nombre        | Descripción                                                                                                                     |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| Timestampable | Permite actualizar automáticamente el atributo de un modelo guardando el datetime cuando es creado o actualizado un registro    |
+| SoftDelete    | En lugar de eliminar permanentemente un registro, se marca el registro como borrado, al cambiar el valor de una columna bandera |
 
 <a name='timestampable'></a>
 
 ## Timestampable
 
-This behavior receives an array of options, the first level key must be an event name indicating when the column must be assigned:
+Este comportamiento recibe un array de opciones, la primera clave debe ser un nombre de evento que indica cuando la columna debe ser asignada:
 
 ```php
 <?php
@@ -90,7 +90,7 @@ public function initialize()
 }
 ```
 
-Each event can have its own options, `field` is the name of the column that must be updated, if `format` is a string it will be used as format of the PHP's function [date](http://php.net/manual/en/function.date.php), format can also be an anonymous function providing you the free to generate any kind timestamp:
+Cada evento puede tener sus propias opciones, `field` es el nombre de la columna que debe actualizarse, si `format` es un `string` que se utilizará como formato de PHP para la función [date](http://php.net/manual/en/function.date.php), también puede ser una función anónima que le proporciona la libertad de generar cualquier tipo timestamp:
 
 ```php
 <?php
@@ -120,13 +120,13 @@ public function initialize()
 }
 ```
 
-If the option `format` is omitted a timestamp using the PHP's function [time](http://php.net/manual/en/function.time.php), will be used.
+Si se omite la opción `format` se utilizará la función [time](http://php.net/manual/en/function.time.php) de PHP.
 
 <a name='softdelete'></a>
 
 ## SoftDelete
 
-This behavior can be used as follows:
+Este comportamiento se puede utilizar de la sigue manera:
 
 ```php
 <?php
@@ -157,7 +157,7 @@ class Users extends Model
 }
 ```
 
-This behavior accepts two options: `field` and `value`, `field` determines what field must be updated and `value` the value to be deleted. Let's pretend the table `users` has the following data:
+Este comportamiento acepta dos opciones: `field` y `vale`, siendo `field` el campo debe ser actualizado y `vale` el valor de eliminado. Supongamos que la tabla `users` tiene los siguientes datos:
 
 ```sql
 mysql> select * from users;
@@ -170,7 +170,7 @@ mysql> select * from users;
 2 rows in set (0.00 sec)
 ```
 
-If we delete any of the two records the status will be updated instead of delete the record:
+Si borramos cualquiera de los dos usuarios se actualizará el estado (status) en vez borrarse el registro:
 
 ```php
 <?php
@@ -178,7 +178,7 @@ If we delete any of the two records the status will be updated instead of delete
 Users::findFirst(2)->delete();
 ```
 
-The operation will result in the following data in the table:
+La operación resultará en los siguientes datos en la tabla:
 
 ```sql
 mysql> select * from users;
@@ -191,15 +191,15 @@ mysql> select * from users;
 2 rows in set (0.01 sec)
 ```
 
-Note that you need to specify the deleted condition in your queries to effectively ignore them as deleted records, this behavior doesn't support that.
+Nota: Tenga en cuenta que usted necesitara especificar la condición de eliminado en sus consultas para ignorar registros marcados como eliminados, este comportamiento no tiene soporte para hacerlo automáticamente.
 
 <a name='create-your-own-behaviors'></a>
 
-## Creating your own behaviors
+## Crea tus propios comportamientos
 
-The ORM provides an API to create your own behaviors. A behavior must be a class implementing the `Phalcon\Mvc\Model\BehaviorInterface`. Also, `Phalcon\Mvc\Model\Behavior` provides most of the methods needed to ease the implementation of behaviors.
+El ORM proporciona una API para crear tus propios comportamientos. Un comportamiento debe ser una clase que implementa la interfaz `Phalcon\Mvc\Model\BehaviorInterface`. Además `Phalcon\Mvc\Model\Behavior` proporciona la mayor parte de los métodos necesarios para facilitar la aplicación de los comportamientos.
 
-The following behavior is an example, it implements the Blameable behavior which helps identify the user that is performed operations over a model:
+El siguiente comportamiento es un ejemplo, implementa el comportamiento Blameable que ayuda a identificar al usuario que realizo operaciones sobre un modelo:
 
 ```php
 <?php
@@ -217,9 +217,9 @@ class Blameable extends Behavior implements BehaviorInterface
             case 'afterDelete':
             case 'afterUpdate':
 
-                $userName = // ... get the current user from session
+                $userName = // ... obtiene el usuario actual desde la sesión
 
-                // Store in a log the username, event type and primary key
+                // Almacena en un log el nombre de usuario, tipo de evento y clave primaria
                 file_put_contents(
                     'logs/blamable-log.txt',
                     $userName . ' ' . $eventType . ' ' . $model->id
@@ -228,13 +228,13 @@ class Blameable extends Behavior implements BehaviorInterface
                 break;
 
             default:
-                /* ignore the rest of events */
+                /* ignorar el resto de los eventos */
         }
     }
 }
 ```
 
-The former is a very simple behavior, but it illustrates how to create a behavior, now let's add this behavior to a model:
+El primero es un comportamiento muy simple, pero ilustra cómo crear un comportamiento, ahora vamos a agregar este comportamiento a un modelo:
 
 ```php
 <?php
@@ -252,7 +252,7 @@ class Profiles extends Model
 }
 ```
 
-A behavior is also capable of intercepting missing methods on your models:
+Un comportamiento también es capaz de interceptar métodos faltantes en tus modelos:
 
 ```php
 <?php
@@ -265,7 +265,7 @@ class Sluggable extends Behavior implements BehaviorInterface
 {
     public function missingMethod($model, $method, $arguments = [])
     {
-        // If the method is 'getSlug' convert the title
+        // Si el método es 'getSlug', modificar el título
         if ($method === 'getSlug') {
             return Tag::friendlyTitle($model->title);
         }
@@ -273,7 +273,7 @@ class Sluggable extends Behavior implements BehaviorInterface
 }
 ```
 
-Call that method on a model that implements Sluggable returns a SEO friendly title:
+Llame a ese método en un modelo que implementa Sluggable y devolverá un título amigable para el SEO:
 
 ```php
 <?php
@@ -283,9 +283,9 @@ $title = $post->getSlug();
 
 <a name='traits-as-behaviors'></a>
 
-## Using Traits as behaviors
+## Utilizando traits como comportamientos
 
-You can use [Traits](http://php.net/manual/en/language.oop5.traits.php) to re-use code in your classes, this is another way to implement custom behaviors. The following trait implements a simple version of the Timestampable behavior:
+Usted puede utilizar [traits](http://php.net/manual/en/language.oop5.traits.php) para reutilizar código en tus clases, esta es otra manera se puede implementar comportamientos personalizados. El traits siguiente implementa una versión simple del comportamiento Timestampable:
 
 ```php
 <?php
@@ -304,7 +304,7 @@ trait MyTimestampable
 }
 ```
 
-Then you can use it in your model as follows:
+Entonces lo puedes utilizar en tu modelo de la siguiente manera:
 
 ```php
 <?php
diff --git a/es/db-models-cache.md b/es/db-models-cache.md
index b31d6c8add0f..84a0a5e83508 100644
--- a/es/db-models-cache.md
+++ b/es/db-models-cache.md
@@ -1,30 +1,30 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">ORM Caching</a> <ul>
+      <a href="#overview">Cache en ORM</a> <ul>
         <li>
-          <a href="#caching-resultsets">Caching Resultsets</a>
+          <a href="#caching-resultsets">Cacheo de Resultsets</a>
         </li>
         <li>
-          <a href="#forcing-cache">Forcing Cache</a>
+          <a href="#forcing-cache">Forzando el caché</a>
         </li>
         <li>
-          <a href="#caching-phql-queries">Caching PHQL Queries</a>
+          <a href="#caching-phql-queries">Cache de consultas PHQL</a>
         </li>
         <li>
-          <a href="#reusable-related-records">Reusable Related Records</a>
+          <a href="#reusable-related-records">Registros relacionados reutilizables</a>
         </li>
         <li>
-          <a href="#caching-related-records">Caching Related Records</a>
+          <a href="#caching-related-records">Cache de registros relacionados</a>
         </li>
         <li>
-          <a href="#caching-related-records-recursively">Caching Related Records Recursively</a>
+          <a href="#caching-related-records-recursively">Cache de registros relacionados recursivamente</a>
         </li>
         <li>
-          <a href="#caching-based-on-conditions">Caching based on Conditions</a>
+          <a href="#caching-based-on-conditions">Cache basado en condiciones</a>
         </li>
         <li>
-          <a href="#caching-phql-execution-plan">Caching PHQL execution plan</a>
+          <a href="#caching-phql-execution-plan">Plan de ejecución para cacheo de PHQL</a>
         </li>
       </ul>
     </li>
@@ -33,21 +33,21 @@
 
 <a name='orm-caching'></a>
 
-# ORM Caching
+# Cache en ORM
 
-Every application is different. In most applications though, there is data that changes infrequently. One of the most common bottlenecks in terms of performance, is accessing a database. This is due to the complex connection/communication processes that PHP perform with each request to obtain data from the database. Therefore, if we want to achieve good performance, we need to add some layers of caching where the application requires it.
+Cada aplicación es diferente. En la mayoría de las aplicaciones sin embargo, hay datos que cambian con poca frecuencia. Uno de los cuellos de botella más comunes en términos de rendimiento, es el acceso a la base de datos. Esto es debido a los procesos complejos de conexión/comunicación que PHP utiliza con cada solicitud para obtener los datos de la base de datos. Por lo tanto, si queremos lograr un buen rendimiento, necesitamos agregar algunas capas de caché donde la aplicación lo requiera.
 
-This chapter explains the potential areas where it is possible to implement caching to improve performance. Phalcon gives developers the tools they need to implement cashing where their application needs it.
+Este capítulo explica las posibles áreas donde es posible implementar el almacenamiento en caché para mejorar el rendimiento. Phalcon da a los desarrolladores las herramientas necesarias para implementar el cacheo donde su aplicación lo necesita.
 
 <a name='caching-resultsets'></a>
 
-## Caching Resultsets
+## Cacheo de Resultsets
 
-A well established technique to avoid continuously accessing the database, is to cache resultsets that don't change frequently, using a system with faster access (usually memory).
+Una técnica bien establecida para evitar continuamente accediendo a la base de datos, es el cacheo de conjunto de resultados (Resultsets) que no cambian con frecuencia, utilizando un sistema de acceso más rápido (generalmente memoria).
 
-When `Phalcon\Mvc\Model` requires a service to cache resultsets, it will request it from the Dependency Injection Container. The service name is called `modelsCache`. Phalcon offers a [cache](/[[language]]/[[version]]/cache) component that can store any kind of data. We will now see how we can integrate it with our Models.
+Cuando `Phalcon\Mvc\Model` requiere un servicio de caché de conjunto de resultados, lo solicitará desde el contenedor de inyección de dependencia (DI). El servicio se llama `modelsCache`. Phalcon ofrece un componente de [caché](/[[language]]/[[version]]/cache) que puede almacenar cualquier tipo de datos. Ahora veremos cómo podemos integrarlo con nuestros modelos.
 
-First, we will need to register the cache component as a service in the DI container.
+En primer lugar, necesitamos registrar el componente de caché como un servicio en el contenedor de DI.
 
 ```php
 <?php
@@ -55,18 +55,18 @@ First, we will need to register the cache component as a service in the DI conta
 use Phalcon\Cache\Frontend\Data as FrontendData;
 use Phalcon\Cache\Backend\Memcache as BackendMemcache;
 
-// Set the models cache service
+// Configuración del servicio de cacheo para modelos
 $di->set(
     'modelsCache',
     function () {
-        // Cache data for one day (default setting)
+        // Almacenar datos por un día (valor por defecto)
         $frontCache = new FrontendData(
             [
                 'lifetime' => 86400,
             ]
         );
 
-        // Memcached connection settings
+        // Configuración de conexión a Memcached 
         $cache = new BackendMemcache(
             $frontCache,
             [
@@ -80,15 +80,15 @@ $di->set(
 );
 ```
 
-Phalcon offers complete control in creating and customizing the cache component before registering it as a service in the DI container. Once the cache component is properly set up, resultsets can be cached as follows:
+Phalcon ofrece un control completo en la creación y personalización del componente de caché antes de registrarlo como un servicio en el contenedor de DI. Una vez que el componente de caché está correctamente configurado, los conjuntos de resultados pueden cachearse de la siguiente manera:
 
 ```php
 <?php
 
-// Get products without caching
+// Obtener productos sin cache
 $products = Products::find();
 
-// Just cache the resultset. The cache will expire in 1 hour (3600 seconds)
+// Almacenar en el cache el Resultset. El cacheo expira en una hora (3600 segundos)
 $products = Products::find(
     [
         'cache' => [
@@ -97,7 +97,7 @@ $products = Products::find(
     ]
 );
 
-// Cache the resultset for only for 5 minutes
+// Almacenar el resultset por solo 5 minutos
 $products = Products::find(
     [
         'cache' => [
@@ -107,7 +107,7 @@ $products = Products::find(
     ]
 );
 
-// Use the 'cache' service from the DI instead of 'modelsCache'
+// Utilizar el servicio 'cache' desde DI en vez del 'modelsCache'
 $products = Products::find(
     [
         'cache' => [
@@ -118,15 +118,15 @@ $products = Products::find(
 );
 ```
 
-Caching could also be applied to resultsets generated using relationships:
+El cache también puede aplicarse a conjuntos de resultados generados mediante relaciones:
 
 ```php
 <?php
 
-// Query some post
+// Consultamos algún post
 $post = Post::findFirst();
 
-// Get comments related to a post, also cache it
+// Obtenemos los comentarios relacionados y los cacheamos
 $comments = $post->getComments(
     [
         'cache' => [
@@ -135,7 +135,7 @@ $comments = $post->getComments(
     ]
 );
 
-// Get comments related to a post, setting lifetime
+// Obtener los comentarios relacionados al post, configurando el tiempo de vida 'lifetime'
 $comments = $post->getComments(
     [
         'cache' => [
@@ -146,20 +146,20 @@ $comments = $post->getComments(
 );
 ```
 
-When a cached resultset needs to be invalidated, you can simply delete it from the cache using the key specified as seen above.
+Cuando un resultset en caché debe ser invalidado, simplemente se puede borrar la caché utilizando la clave especificada como se ve arriba.
 
-Which resultset to cache and for how long is up to the developer, after having evaluated the needs of the application. Resultsets that change frequently should not be cached, since the cache results will be invalidated quickly. Additionally caching resultsets consumes processing cycles, therefore the cache that was intended to speed up the application actually slows it down. Resultsets that do not change frequently should be cached to minimize the database interactions. The decision on where to use caching and for how long is dictated by the application needs.
+Que resultset almacenar en caché y por cuánto tiempo es tarea del desarrollador, después de haber evaluado las necesidades de la aplicación. Los conjuntos de resultados que cambian con frecuencia no deben ser cacheados, ya que los resultados de la caché se invalidaran rápidamente. Además el cacheo de resultsets consume ciclos de procesamiento, por lo tanto el caché que pretendía acelerar la aplicación realmente la desacelera. Los resultsets que no cambian con frecuencia deben ser almacenados en caché para reducir al mínimo las interacciones de la base de datos. La decisión sobre dónde usar almacenamiento en caché y por cuánto tiempo, es dictada por las necesidades de aplicación.
 
 <a name='forcing-cache'></a>
 
-## Forcing Cache
+## Forzando el caché
 
-Earlier we saw how `Phalcon\Mvc\Model` integrates with the caching component provided by the framework. To make a record/resultset cacheable we pass the key `cache` in the array of parameters:
+Anteriormente vimos cómo `Phalcon\Mvc\Model` se integra con el componente de caché proporcionado por el framework. Para hacer cache de un registro o conjunto de resultados debemos pasar la clave `cache` en el array de parámetros:
 
 ```php
 <?php
 
-// Cache the resultset for only for 5 minutes
+// Cachear el resultset por solo 5 minutos
 $products = Products::find(
     [
         'cache' => [
@@ -170,7 +170,7 @@ $products = Products::find(
 );
 ```
 
-This gives us the freedom to cache specific queries, however if we want to cache globally every query performed over the model, we can override the `find()`/`findFirst()` methods to force every query to be cached:
+Esto nos da la libertad para almacenar en caché consultas específicas, sin embargo si queremos almacenar en memoria a nivel global cada consulta realizada sobre el modelo, podemos sobrecargar los métodos `find()`/`findFirst()` para forzar el cacheo en cada consulta:
 
 ```php
 <?php
@@ -180,8 +180,8 @@ use Phalcon\Mvc\Model;
 class Robots extends Model
 {
     /**
-     * Implement a method that returns a string key based
-     * on the query parameters
+     * Implementar un método que retorne una clave en string
+     * basada en los parámetros de la consulta
      */
     protected static function _createKey($parameters)
     {
@@ -200,13 +200,13 @@ class Robots extends Model
 
     public static function find($parameters = null)
     {
-        // Convert the parameters to an array
+        // Convertir parámetros a un array
         if (!is_array($parameters)) {
             $parameters = [$parameters];
         }
 
-        // Check if a cache key wasn't passed
-        // and create the cache parameters
+        // Chequear si la clave de cache no fue enviada,
+        // en tal caso, crearla
         if (!isset($parameters['cache'])) {
             $parameters['cache'] = [
                 'key'      => self::_createKey($parameters),
@@ -224,9 +224,9 @@ class Robots extends Model
 }
 ```
 
-Accessing the database is several times slower than calculating a cache key. You're free to implement any key generation strategy you find to better for your needs. Note that a good key avoids collisions as much as possible - meaning that different keys should return unrelated records.
+El acceso a la base de datos es varias veces más lento que el cálculo de una clave de caché. Eres libre de implementar cualquier estrategia de generación de claves que encuentres mejor para tus necesidades. Tenga en cuenta que una buena clave evita colisiones tanto como sea posibles - lo que significa que diferentes claves deben devolver registros no relacionados.
 
-This gives you full control on how the cache should be implemented for each model. If this strategy is common to several models you can create a base class for all of them:
+Esto le da control total sobre cómo debería implementarse la caché para cada modelo. Si esta estrategia es común a varios modelos puede crear una clase base para todos ellos:
 
 ```php
 <?php
@@ -237,22 +237,22 @@ class CacheableModel extends Model
 {
     protected static function _createKey($parameters)
     {
-        // ... Create a cache key based on the parameters
+        // ... Crear clave de cacheo con los parámetros
     }
 
     public static function find($parameters = null)
     {
-        // ... Custom caching strategy
+        // ... Estrategia de cacheo personalizada
     }
 
     public static function findFirst($parameters = null)
     {
-        // ... Custom caching strategy
+        // ... Estrategia de cacheo personalizada
     }
 }
 ```
 
-Then use this class as base class for each `Cacheable` model:
+Luego utilice esta clase como clase base para cada modelo `Cacheable`:
 
 ```php
 <?php
@@ -265,9 +265,9 @@ class Robots extends CacheableModel
 
 <a name='caching-phql-queries'></a>
 
-## Caching PHQL Queries
+## Cache de consultas PHQL
 
-Regardless of the syntax we used to create them, all queries in the ORM are handled internally using PHQL. This language gives you much more freedom to create all kinds of queries. Of course these queries can be cached:
+Independientemente de la sintaxis que utilizamos para crearlos, todas las consultas en el ORM se manejan internamente con PHQL. Este lenguaje le da mucho más libertad a usted para crear todo tipo de consultas. Por supuesto estas consultas pueden ser almacenadas en caché:
 
 ```php
 <?php
@@ -292,43 +292,43 @@ $cars = $query->execute(
 
 <a name='reusable-related-records'></a>
 
-## Reusable Related Records
+## Registros relacionados reutilizables
 
-Some models may have relationships with other models. This allows us to easily check the records that relate to instances in memory:
+Algunos modelos pueden tener relaciones con otros modelos. Esto nos permite comprobar fácilmente los registros que tienen instancias en memoria:
 
 ```php
 <?php
 
-// Get some invoice
+// Buscar alguna factura
 $invoice = Invoices::findFirst();
 
-// Get the customer related to the invoice
+// Obtener el cliente relacionado a la factura
 $customer = $invoice->customer;
 
-// Print his/her name
+// Imprimir su nombre
 echo $customer->name, "\n";
 ```
 
-This example is very simple, a customer is queried and can be used as required, for example, to show its name. This also applies if we retrieve a set of invoices to show customers that correspond to these invoices:
+Este ejemplo es muy simple, un cliente es consultado y se puede utilizar según sea necesario, por ejemplo, para mostrar su nombre. Esto también se aplica si recuperamos un conjunto de facturas para mostrar los clientes de las correspondientes facturas:
 
 ```php
 <?php
 
-// Get a set of invoices
+// Obtener algunas facturas
 // SELECT * FROM invoices;
 $invoices = Invoices::find();
 
 foreach ($invoices as $invoice) {
-    // Get the customer related to the invoice
+    // Obtener el cliente relacionado a la factura
     // SELECT * FROM customers WHERE id = ?;
     $customer = $invoice->customer;
 
-    // Print his/her name
+    // Imprimir su nombre
     echo $customer->name, "\n";
 }
 ```
 
-A customer may have one or more bills so, in this example, the same customer record may be unnecessarily queried several times. To avoid this, we could mark the relationship as reusable; by doing so, we tell the ORM to automatically reuse the records from memory instead of re-querying them again and again:
+Un cliente puede tener una o más facturas entonces, en este ejemplo, el mismo cliente puede ser consultado varias veces innecesariamente. Para evitar esto, podríamos marcar la relación como `reusable`; por ello le decimos al ORM que reutilice automáticamente registros de la memoria en lugar de volver a consultarles una y otra vez:
 
 ```php
 <?php
@@ -351,36 +351,36 @@ class Invoices extends Model
 }
 ```
 
-Note that this type of cache works in memory only, this means that cached data are released when the request is terminated.
+Tenga en cuenta que este tipo de caché trabaja en memoria solamente, esto quiere decir que los datos almacenados en caché se liberan cuando se termina la petición.
 
 <a name='caching-related-records'></a>
 
-## Caching Related Records
+## Cache de registros relacionados
 
-When a related record is queried, the ORM internally builds the appropriate condition and gets the required records using `find()`/`findFirst()` in the target model according to the following table:
+Cuando se consulta un registro relacionado, el ORM internamente construye la condición adecuada y obtiene los registros necesarios utilizando `find()`/`findFirst()` en el modelo; según la siguiente tabla:
 
-| Type       | Description                                                     | Implicit Method |
-| ---------- | --------------------------------------------------------------- | --------------- |
-| Belongs-To | Returns a model instance of the related record directly         | `findFirst()`   |
-| Has-One    | Returns a model instance of the related record directly         | `findFirst()`   |
-| Has-Many   | Returns a collection of model instances of the referenced model | `find()`        |
+| Tipo       | Descripción                                                                    | Método implícito |
+| ---------- | ------------------------------------------------------------------------------ | ---------------- |
+| Belongs-To | Devuelve una instancia del modelo relacionado directamente                     | `findFirst()`    |
+| Has-One    | Devuelve una instancia del modelo relacionado directamente                     | `findFirst()`    |
+| Has-Many   | Devuelve una colección de instancias del modelo, según el modelo de referencia | `find()`         |
 
-This means that when you get a related record you could intercept how the data is obtained by implementing the corresponding method:
+Esto significa que cuando usted obtiene un registro relacionado, podría interceptar cómo los datos se obtuvieron aplicando el método correspondiente:
 
 ```php
 <?php
 
-// Get some invoice
+// Obtener la primer factura
 $invoice = Invoices::findFirst();
 
-// Get the customer related to the invoice
+// Obtiene el cliente relacionado a la factura
 $customer = $invoice->customer; // Invoices::findFirst('...');
 
-// Same as above
+// El mismo resultado que la linea anterior
 $customer = $invoice->getCustomer(); // Invoices::findFirst('...');
 ```
 
-Accordingly, we could replace the `findFirst()` method in the Invoices model and implement the cache we consider most appropriate:
+En consecuencia, podríamos reemplazar el método `findFirst()` en el modelo Invoices e implementar la caché que consideramos más adecuada:
 
 ```php
 <?php
@@ -391,16 +391,16 @@ class Invoices extends Model
 {
     public static function findFirst($parameters = null)
     {
-        // ... Custom caching strategy
+        // ... Estrategia de cache personalizada
     }
 }
 ```
 
 <a name='caching-related-records-recursively'></a>
 
-## Caching Related Records Recursively
+## Cache de registros relacionados recursivamente
 
-In this scenario, we assume that every time we query a result we also retrieve their associated records. If we store the records found together with their related entities perhaps we could reduce a bit the overhead required to obtain all entities:
+En este escenario, asumimos que en cada consulta de un registro también recuperamos sus registros asociados. Si almacenamos los registros encontrados junto con sus entidades relacionadas, quizá podríamos reducir un poco la sobrecarga requerida para obtener todas las entidades:
 
 ```php
 <?php
@@ -411,28 +411,28 @@ class Invoices extends Model
 {
     protected static function _createKey($parameters)
     {
-        // ... Create a cache key based on the parameters
+        // ... Creamos una clave de cache basada en los parámetros
     }
 
     protected static function _getCache($key)
     {
-        // Returns data from a cache
+        // Retorna datos desde el cache
     }
 
     protected static function _setCache($key, $results)
     {
-        // Stores data in the cache
+        // Almacena datos en cache
     }
 
     public static function find($parameters = null)
     {
-        // Create a unique key
+        // Crea una clave única
         $key = self::_createKey($parameters);
 
-        // Check if there are data in the cache
+        // Chequeamos si los datos están en cache
         $results = self::_getCache($key);
 
-        // Valid data is an object
+        // Validamos si los datos son un objecto
         if (is_object($results)) {
             return $results;
         }
@@ -442,16 +442,16 @@ class Invoices extends Model
         $invoices = parent::find($parameters);
 
         foreach ($invoices as $invoice) {
-            // Query the related customer
+            // Obtenemos los clientes relacionados
             $customer = $invoice->customer;
 
-            // Assign it to the record
+            // Los asignamos a la factura
             $invoice->customer = $customer;
 
             $results[] = $invoice;
         }
 
-        // Store the invoices in the cache + their customers
+        // Almacenamos la factura en cache con sus clientes
         self::_setCache($key, $results);
 
         return $results;
@@ -459,12 +459,12 @@ class Invoices extends Model
 
     public function initialize()
     {
-        // Add relations and initialize other stuff
+        // Agregar relaciones e iniciar otras cosas
     }
 }
 ```
 
-Getting the invoices from the cache already obtains the customer data in just one hit, reducing the overall overhead of the operation. Note that this process can also be performed with PHQL following an alternative solution:
+Al recibir las facturas de la caché ya obtiene también los datos del cliente todo en un solo paso, reduciendo la carga total de la operación. Tenga en cuenta que este proceso puede realizarse también con PHQL, con la siguiente solución alternativa:
 
 ```php
 <?php
@@ -475,12 +475,12 @@ class Invoices extends Model
 {
     public function initialize()
     {
-        // Add relations and initialize other stuff
+        // Agregar relaciones e iniciar otras cosas
     }
 
     protected static function _createKey($conditions, $params)
     {
-        // ... Create a cache key based on the parameters
+        // ... Creamos una clave de cache basada en los parámetros
     }
 
     public function getInvoicesCustomers($conditions, $params = null)
@@ -504,17 +504,17 @@ class Invoices extends Model
 
 <a name='caching-based-on-conditions'></a>
 
-## Caching based on Conditions
+## Cache basado en condiciones
 
-In this scenario, the cache is implemented differently depending on the conditions received. We might decide that the cache backend should be determined by the primary key:
+En este escenario, la caché se implementa dependiendo de diferentes condiciones. Nosotros podríamos decidir que tipo de cache backend debe implementarse dependiendo de la clave primaria:
 
-| Type          | Cache Backend |
+| Tipo          | Cache Backend |
 | ------------- | ------------- |
 | 1 - 10000     | mongo1        |
 | 10000 - 20000 | mongo2        |
 | > 20000       | mongo3        |
 
-The easiest way to achieve this is by adding a static method to the model that chooses the right cache to be used:
+La forma más sencilla de lograr esto es agregando un método estático para el modelo que elige el caché adecuado para ser utilizado:
 
 ```php
 <?php
@@ -545,7 +545,7 @@ class Robots extends Model
 }
 ```
 
-This approach solves the problem, however, if we want to add other parameters such orders or conditions we would have to create a more complicated method. Additionally, this method does not work if the data is obtained using related records or a `find()`/`findFirst()`:
+Este planteamiento resuelve el problema, sin embargo, si queremos añadir otros parámetros tales como ordenamiento o condiciones, tendríamos que crear un método más complejo. Además, este método no funciona si los datos se obtuvieron mediante registros relacionados o un `find()`/`findFirst()`:
 
 ```php
 <?php
@@ -563,9 +563,9 @@ $robots = Robots::find(
 );
 ```
 
-To achieve this we need to intercept the intermediate representation (IR) generated by the PHQL parser and thus customize the cache everything possible:
+Para lograr esto tenemos que interceptar la intermediate representation (IR) generada por el analizador PHQL y así personalizar el cache todo lo posible:
 
-The first is create a custom builder, so we can generate a totally customized query:
+La primera es crear un builder personalizado, entonces podremos generar una consulta totalmente personalizada:
 
 ```php
 <?php
@@ -585,7 +585,7 @@ class CustomQueryBuilder extends QueryBuilder
 }
 ```
 
-Instead of directly returning a `Phalcon\Mvc\Model\Query`, our custom builder returns a CustomQuery instance, this class looks like:
+En lugar de regresar directamente un `Phalcon\Mvc\Model\Query`, nuestro constructor personalizado devuelve una instancia de CustomQuery, que se parece a esta clase:
 
 ```php
 <?php
@@ -595,37 +595,37 @@ use Phalcon\Mvc\Model\Query as ModelQuery;
 class CustomQuery extends ModelQuery
 {
     /**
-     * The execute method is overridden
+     * El método execute es sobrecargado
      */
     public function execute($params = null, $types = null)
     {
-        // Parse the intermediate representation for the SELECT
+        // Analizamos el intermediate representation del SELECT
         $ir = $this->parse();
 
-        // Check if the query has conditions
+        // Chequeamos si la consulta tiene condiciones
         if (isset($ir['where'])) {
-            // The fields in the conditions can have any order
-            // We need to recursively check the conditions tree
-            // to find the info we're looking for
+            // Las condiciones pueden tener un orden
+            // Necesitamos chequear el árbol de condiciones
+            // para encontrar la información que estamos buscando
             $visitor = new CustomNodeVisitor();
 
-            // Recursively visits the nodes
+            // Visitamos los nodos recursivamente
             $visitor->visit($ir['where']);
 
             $initial = $visitor->getInitial();
             $final   = $visitor->getFinal();
 
-            // Select the cache according to the range
+            // Seleccionamos el cache acorde al rango
             // ...
 
-            // Check if the cache has data
+            // Chequeamos si el cache tiene datos
             // ...
         }
 
-        // Execute the query
+        // Ejecutamos la consulta
         $result = $this->_executeSelect($ir, $params, $types);
 
-        // Cache the result
+        // Cache el resultado
         // ...
 
         return $result;
@@ -633,7 +633,7 @@ class CustomQuery extends ModelQuery
 }
 ```
 
-Implementing a helper (`CustomNodeVisitor`) that recursively checks the conditions looking for fields that tell us the possible range to be used in the cache:
+Implementando un ayudante (`CustomNodeVisitor`) que comprueba recursivamente las condiciones de los campos que nos dicen el rango posible para ser utilizado en el cache:
 
 ```php
 <?php
@@ -706,7 +706,7 @@ class CustomNodeVisitor
 }
 ```
 
-Finally, we can replace the find method in the Robots model to use the custom classes we've created:
+Por último, podemos reemplazar el método `find()` del modelo Robots para utilizar las clases personalizadas que hemos creado:
 
 ```php
 <?php
@@ -738,9 +738,9 @@ class Robots extends Model
 
 <a name='caching-phql-execution-plan'></a>
 
-## Caching PHQL execution plan
+## Plan de ejecución para cacheo de PHQL
 
-As well as most moderns database systems PHQL internally caches the execution plan, if the same statement is executed several times PHQL reuses the previously generated plan improving performance, for a developer to take better advantage of this is highly recommended build all your SQL statements passing variable parameters as bound parameters:
+Como en la mayoría de los sistemas de bases de datos modernos, PHQL internamente almacena en caché el plan de ejecución, si la misma sentencia se ejecuta varias veces, PHQL reutiliza el plan previamente generado mejorando el rendimiento, para que un desarrollador aproveche mejor esta opción es altamente recomendado armar todas las consultas SQL con parámetros enlazados:
 
 ```php
 <?php
@@ -754,7 +754,7 @@ for ($i = 1; $i <= 10; $i++) {
 }
 ```
 
-In the above example, ten plans were generated increasing the memory usage and processing in the application. Rewriting the code to take advantage of bound parameters reduces the processing by both ORM and database system:
+En el ejemplo anterior, se generaron diez planes aumentando el uso de memoria y procesamiento en la aplicación. Reescribir el código para aprovechar las ventajas de los parámetros enlazados reduce el procesamiento por el sistema ORM y la base de datos:
 
 ```php
 <?php
@@ -773,7 +773,7 @@ for ($i = 1; $i <= 10; $i++) {
 }
 ```
 
-Performance can be also improved reusing the PHQL query:
+El rendimiento puede mejorarse más aún reutilizando la consulta PHQL:
 
 ```php
 <?php
@@ -794,4 +794,4 @@ for ($i = 1; $i <= 10; $i++) {
 }
 ```
 
-Execution plans for queries involving [prepared statements](http://en.wikipedia.org/wiki/Prepared_statement) are also cached by most database systems reducing the overall execution time, also protecting your application against [SQL Injections](http://en.wikipedia.org/wiki/SQL_injection).
\ No newline at end of file
+Los planes de ejecución para consultas que implican [sentencias preparadas](http://en.wikipedia.org/wiki/Prepared_statement) también son almacenadas en caché en la mayoría sistemas de bases de datos, reduciendo el tiempo total de ejecución, también protegen su aplicación contra las [inyecciones de SQL (SQL Injections)](http://en.wikipedia.org/wiki/SQL_injection).
\ No newline at end of file
diff --git a/es/db-models-events.md b/es/db-models-events.md
index 24725c920387..dddeb3eb53d4 100644
--- a/es/db-models-events.md
+++ b/es/db-models-events.md
@@ -1,22 +1,22 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">Model Events</a> <ul>
+      <a href="#overview">Eventos del Modelo</a> <ul>
         <li>
-          <a href="#events">Events and Events Manager</a> <ul>
+          <a href="#events">Eventos y Gestor de eventos</a> <ul>
             <li>
-              <a href="#events-in-models">Implementing Events in the Model's class</a>
+              <a href="#events-in-models">Implementando eventos en clases de Modelos</a>
             </li>
             <li>
-              <a href="#custom-events-manager">Using a custom Events Manager</a>
+              <a href="#custom-events-manager">Utilizando un Gestor de Eventos personalizado</a>
             </li>
           </ul>
         </li>
         <li>
-          <a href="#logging-sql-statements">Logging Low-Level SQL Statements</a>
+          <a href="#logging-sql-statements">Registro de sentencias SQL de bajo nivel</a>
         </li>
         <li>
-          <a href="#profiling-sql-statements">Profiling SQL Statements</a>
+          <a href="#profiling-sql-statements">Perfilando sentencias SQL</a>
         </li>
       </ul>
     </li>
@@ -25,36 +25,36 @@
 
 <a name='overview'></a>
 
-# Model Events
+# Eventos del Modelo
 
 <a name='events'></a>
 
-## Events and Events Manager
-
-Models allow you to implement events that will be thrown while performing an insert/update/delete which can be used to define business rules. The following are the events supported by `Phalcon\Mvc\Model` and their order of execution:
-
-| Operation          | Name                     |  Can stop operation?  | Explanation                                                                                                                       |
-| ------------------ | ------------------------ |:---------------------:| --------------------------------------------------------------------------------------------------------------------------------- |
-| Inserting          | afterCreate              |          NO           | Runs after the required operation over the database system only when an inserting operation is being made                         |
-| Updating           | afterUpdate              |          NO           | Runs after the required operation over the database system only when an updating operation is being made                          |
-| Inserting/Updating | afterSave                |          NO           | Runs after the required operation over the database system                                                                        |
-| Inserting/Updating | afterValidation          |          YES          | Is executed after the fields are validated for not nulls/empty strings or foreign keys                                            |
-| Inserting          | afterValidationOnCreate  |          YES          | Is executed after the fields are validated for not nulls/empty strings or foreign keys when an insertion operation is being made  |
-| Updating           | afterValidationOnUpdate  |          YES          | Is executed after the fields are validated for not nulls/empty strings or foreign keys when an updating operation is being made   |
-| Inserting/Updating | beforeValidation         |          YES          | Is executed before the fields are validated for not nulls/empty strings or foreign keys                                           |
-| Inserting          | beforeCreate             |          YES          | Runs before the required operation over the database system only when an inserting operation is being made                        |
-| Inserting/Updating | beforeSave               |          YES          | Runs before the required operation over the database system                                                                       |
-| Updating           | beforeUpdate             |          YES          | Runs before the required operation over the database system only when an updating operation is being made                         |
-| Inserting          | beforeValidationOnCreate |          YES          | Is executed before the fields are validated for not nulls/empty strings or foreign keys when an insertion operation is being made |
-| Updating           | beforeValidationOnUpdate |          YES          | Is executed before the fields are validated for not nulls/empty strings or foreign keys when an updating operation is being made  |
-| Inserting/Updating | onValidationFails        | YES (already stopped) | Is executed after an integrity validator fails                                                                                    |
-| Inserting/Updating | validation               |          YES          | Is executed before the fields are validated for not nulls/empty strings or foreign keys when an updating operation is being made  |
+## Eventos y Manager de eventos
+
+Los modelos permiten implementar eventos que se disparan al realizar una inserción/actualización/eliminación, pueden usarse para definir reglas de negocio. Son soportados los siguientes eventos por `Phalcon\Mvc\Model` y su respectivo orden de ejecución:
+
+| Operación          | Nombre                   | ¿Puede detener la operación? | Explicación                                                                                                                                      |
+| ------------------ | ------------------------ |:----------------------------:| ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Inserting          | afterCreate              |              NO              | Se ejecuta después de la operación sobre el sistema de base de datos pero sólo cuando se realiza una operación de inserción                      |
+| Updating           | afterUpdate              |              NO              | Se ejecuta después de la operación sobre el sistema de base de datos pero sólo cuando se realiza una operación de actualización                  |
+| Inserting/Updating | afterSave                |              NO              | Después que la operación se ejecuta sobre el sistema de base de datos solo para inserción o actualización                                        |
+| Inserting/Updating | afterValidation          |              SI              | Se ejecuta después de que se validan los campos no nulos/cadenas vacías o llaves foráneas                                                        |
+| Inserting          | afterValidationOnCreate  |              SI              | Se ejecuta después de que se validan los campos no nulos/cadenas vacías o llaves foráneas solo cuando se realiza una operación de inserción      |
+| Updating           | afterValidationOnUpdate  |              SI              | Se ejecuta después de que se validan los campos no nulos/cadenas vacías o llaves foráneas, solo cuando se realiza una operación de actualización |
+| Inserting/Updating | beforeValidation         |              SI              | Se ejecuta antes de que se validan los campos no nulos/cadenas vacías o llaves foráneas, para operaciones de inserción o actualización           |
+| Inserting          | beforeCreate             |              SI              | Se ejecuta antes de la operación sobre el sistema de base de datos, sólo cuando se realiza una operación de inserción                            |
+| Inserting/Updating | beforeSave               |              SI              | Se ejecuta antes de la operación sobre el sistema de base de datos, para operaciones de inserción o actualización                                |
+| Updating           | beforeUpdate             |              SI              | Se ejecuta antes de la operación sobre el sistema de base de datos, sólo cuando se realiza una operación de actualización                        |
+| Inserting          | beforeValidationOnCreate |              SI              | Se ejecuta antes de que se validan los campos no nulos/cadenas vacías o llaves foráneas, solo cuando se realiza una operación de inserción       |
+| Updating           | beforeValidationOnUpdate |              SI              | Se ejecuta antes de que se validan los campos no nulos/cadenas vacías o llaves foráneas, solo cuando se realiza una operación de actualización   |
+| Inserting/Updating | onValidationFails        |        SI (detenido)         | Se ejecuta después de un validador de integridad falla                                                                                           |
+| Inserting/Updating | validation               |              SI              | Se ejecuta antes de que se validan los campos no nulos/cadenas vacías o llaves foráneas, solo cuando se realiza una operación de actualización   |
 
 <a name='events-in-models'></a>
 
-### Implementing Events in the Model's class
+### Implementando eventos en clases de Modelos
 
-The easier way to make a model react to events is to implement a method with the same name of the event in the model's class:
+La manera más fácil para hacer a un modelo reaccionar a los eventos es implementar un método con el mismo nombre del evento en la clase del modelo:
 
 ```php
 <?php
@@ -67,12 +67,12 @@ class Robots extends Model
 {
     public function beforeValidationOnCreate()
     {
-        echo 'This is executed before creating a Robot!';
+        echo 'Esto se ejecuta antes de crear un Robot!';
     }
 }
 ```
 
-Events can be used to assign values before performing an operation, for example:
+Los eventos pueden utilizarse para asignar valores antes de realizar una operación, por ejemplo:
 
 ```php
 <?php
@@ -83,13 +83,13 @@ class Products extends Model
 {
     public function beforeCreate()
     {
-        // Set the creation date
+        // Establecer fecha de creación
         $this->created_at = date('Y-m-d H:i:s');
     }
 
     public function beforeUpdate()
     {
-        // Set the modification date
+        // Establecer fecha de actualización
         $this->modified_in = date('Y-m-d H:i:s');
     }
 }
@@ -97,9 +97,9 @@ class Products extends Model
 
 <a name='custom-events-manager'></a>
 
-### Using a custom Events Manager
+### Utilizando un Manager de eventos personalizado
 
-Additionally, this component is integrated with `Phalcon\Events\Manager`, this means we can create listeners that run when an event is triggered.
+Además, este componente está integrado con `Phalcon\Events\Manager`, esto significa que podemos crear oyentes o listeners que se ejecutan cuando se activa un evento.
 
 ```php
 <?php
@@ -116,12 +116,12 @@ class Robots extends Model
     {
         $eventsManager = new EventsManager();
 
-        // Attach an anonymous function as a listener for 'model' events
+        // Adjuntamos una función anónima para escuchar los eventos del modelo
         $eventsManager->attach(
             'model:beforeSave',
             function (Event $event, $robot) {
                 if ($robot->name === 'Scooby Doo') {
-                    echo "Scooby Doo isn't a robot!";
+                    echo "Scooby Doo no es un robot!";
 
                     return false;
                 }
@@ -130,13 +130,13 @@ class Robots extends Model
             }
         );
 
-        // Attach the events manager to the event
+        // Adjuntamos el event manager al evento
         $this->setEventsManager($eventsManager);
     }
 }
 ```
 
-In the example given above, the Events Manager only acts as a bridge between an object and a listener (the anonymous function). Events will be fired to the listener when `robots` are saved:
+En el ejemplo anterior, el gestor de eventos sólo actúa como un puente entre un objeto y un oyente (la función anónima). Los eventos se dispararán al oyente cuando los `robots` se guarden:
 
 ```php
 <?php
@@ -151,7 +151,7 @@ $robot->year = 1969;
 $robot->save();
 ```
 
-If we want all objects created in our application use the same EventsManager, then we need to assign it to the Models Manager:
+Si queremos que todos los objetos creados en nuestra aplicación utilicen el mismo EventsManager, tenemos que asignarlo al administrador de modelos (Models Manager):
 
 ```php
 <?php
@@ -159,20 +159,20 @@ If we want all objects created in our application use the same EventsManager, th
 use Phalcon\Events\Event;
 use Phalcon\Events\Manager as EventsManager;
 
-// Registering the modelsManager service
+// Registramos el servicio modelsManager
 $di->setShared(
     'modelsManager',
     function () {
         $eventsManager = new EventsManager();
 
-        // Attach an anonymous function as a listener for 'model' events
+        // Adjuntamos una función anónima como listener para los eventos del 'model'
         $eventsManager->attach(
             'model:beforeSave',
             function (Event $event, $model) {
-                // Catch events produced by the Robots model
+                // Capturamos los eventos producidos en el modelo Robots
                 if (get_class($model) === 'Store\Toys\Robots') {
                     if ($model->name === 'Scooby Doo') {
-                        echo "Scooby Doo isn't a robot!";
+                        echo "Scooby Doo no es un robot!";
 
                         return false;
                     }
@@ -182,7 +182,7 @@ $di->setShared(
             }
         );
 
-        // Setting a default EventsManager
+        // Configuramos el EventsManager por defecto
         $modelsManager = new ModelsManager();
 
         $modelsManager->setEventsManager($eventsManager);
@@ -192,13 +192,13 @@ $di->setShared(
 );
 ```
 
-If a listener returns false that will stop the operation that is executing currently.
+Si un oyente devuelve `false` detendrá la operación que se esté ejecutando actualmente.
 
 <a name='logging-sql-statements'></a>
 
-## Logging Low-Level SQL Statements
+## Registro de sentencias SQL de bajo nivel
 
-When using high-level abstraction components such as `Phalcon\Mvc\Model` to access a database, it is difficult to understand which statements are finally sent to the database system. `Phalcon\Mvc\Model` is supported internally by `Phalcon\Db`. `Phalcon\Logger` interacts with `Phalcon\Db`, providing logging capabilities on the database abstraction layer, thus allowing us to log SQL statements as they happen.
+Al utilizar componentes de alto nivel de abstracción como `Phalcon\Mvc\Model` para acceder a una base de datos, es difícil entender qué sentencias son finalmente enviadas al sistema de base de datos. `Phalcon\Mvc\Model` es soportado internamente por `Phalcon\Db`. `Phalcon\Logger` interactúa con `Phalcon\Db`, proporcionando las funciones de registro en la capa de abstracción de base de datos, esto nos permite registrar las sentencias SQL cuando suceden.
 
 ```php
 <?php
@@ -215,7 +215,7 @@ $di->set(
 
         $logger = new FileLogger('app/logs/debug.log');
 
-        // Listen all the database events
+        // Escucharemos todos los eventos de la base de datos
         $eventsManager->attach(
             'db:beforeQuery',
             function ($event, $connection) use ($logger) {
@@ -235,7 +235,7 @@ $di->set(
             ]
         );
 
-        // Assign the eventsManager to the db adapter instance
+        // Asignamos el eventsManager a la instancia del adaptador de db
         $connection->setEventsManager($eventsManager);
 
         return $connection;
@@ -243,7 +243,7 @@ $di->set(
 );
 ```
 
-As models access the default database connection, all SQL statements that are sent to the database system will be logged in the file:
+Como los modelos acceden a la conexión de base de datos por defecto, todas las sentencias SQL que se envían al sistema de base de datos se registrarán en un archivo:
 
 ```php
 <?php
@@ -252,23 +252,23 @@ use Store\Toys\Robots;
 
 $robot = new Robots();
 
-$robot->name       = 'Robby the Robot';
+$robot->name       = 'Robby el Robot';
 $robot->created_at = '1956-07-21';
 
 if ($robot->save() === false) {
-    echo 'Cannot save robot';
+    echo 'No se pudo guardar el robot';
 }
 ```
 
-As above, the file *app/logs/db.log* will contain something like this:
+Como en el anterior ejemplo, el archivo *app/logs/db.log* contendrá algo como esto:
 
-> `[Mon, 30 Apr 12 13:47:18 -0500][DEBUG][Resource Id #77] INSERT INTO robots` `(name, created_at) VALUES ('Robby the Robot', '1956-07-21')`
+> `[Mon, 30 Apr 12 13:47:18 -0500][DEBUG][Resource Id #77] INSERT INTO robots` `(name, created_at) VALUES ('Robby el Robot', '1956-07-21')`
 
 <a name='profiling-sql-statements'></a>
 
-## Profiling SQL Statements
+## Profiling de sentencias SQL
 
-Thanks to `Phalcon\Db`, the underlying component of `Phalcon\Mvc\Model`, it's possible to profile the SQL statements generated by the ORM in order to analyze the performance of database operations. With this you can diagnose performance problems and to discover bottlenecks.
+Gracias a `Phalcon\Db`, el componente subyacente de `Phalcon\Mvc\Model`, es posible perfilar las sentencias SQL generadas por el ORM en orden para analizar el rendimiento de las operaciones de base de datos. Con esto usted puede diagnosticar problemas de rendimiento y descubrir cuellos de botella.
 
 ```php
 <?php
@@ -290,10 +290,10 @@ $di->set(
     function () use ($di) {
         $eventsManager = new EventsManager();
 
-        // Get a shared instance of the DbProfiler
+        // Obtenemos la instancia compartida de DbProfiler
         $profiler = $di->getProfiler();
 
-        // Listen all the database events
+        // Escuchamos todos los eventos de la base de datos
         $eventsManager->attach(
             'db',
             function ($event, $connection) use ($profiler) {
@@ -318,7 +318,7 @@ $di->set(
             ]
         );
 
-        // Assign the eventsManager to the db adapter instance
+        // Asignamos el eventsManager a la instancia del adaptador de db
         $connection->setEventsManager($eventsManager);
 
         return $connection;
@@ -326,14 +326,14 @@ $di->set(
 );
 ```
 
-Profiling some queries:
+Perfilando de algunas consultas:
 
 ```php
 <?php
 
 use Store\Toys\Robots;
 
-// Send some SQL statements to the database
+// Enviamos algunas sentencias SQL a la base de datos
 Robots::find();
 
 Robots::find(
@@ -348,7 +348,7 @@ Robots::find(
     ]
 );
 
-// Get the generated profiles from the profiler
+// Obtenemos los perfiles generados por el profiler
 $profiles = $di->get('profiler')->getProfiles();
 
 foreach ($profiles as $profile) {
@@ -359,4 +359,4 @@ foreach ($profiles as $profile) {
 }
 ```
 
-Each generated profile contains the duration in milliseconds that each instruction takes to complete as well as the generated SQL statement.
\ No newline at end of file
+Cada perfil generado contiene la duración en milisegundos que tarda cada instrucción en completarse, así como la instrucción SQL generada.
\ No newline at end of file
diff --git a/es/db-models-metadata.md b/es/db-models-metadata.md
index 687116b3a3be..3655e9106fa8 100644
--- a/es/db-models-metadata.md
+++ b/es/db-models-metadata.md
@@ -1,22 +1,22 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">Models Metadata</a> <ul>
+      <a href="#overview">Metadatos de modelos</a> <ul>
         <li>
-          <a href="#caching-metadata">Caching Metadata</a>
+          <a href="#caching-metadata">Almacenamiento en caché de metadatos</a>
         </li>
         <li>
-          <a href="#metadata-strategies">Metadata Strategies</a> <ul>
+          <a href="#metadata-strategies">Estrategias de metadatos</a> <ul>
             <li>
-              <a href="#strategies-database-introspection">Database Introspection Strategy</a>
+              <a href="#strategies-database-introspection">Estrategia de introspección de la base de datos</a>
             </li>
             <li>
-              <a href="#strategies-annotations">Annotations Strategy</a>
+              <a href="#strategies-annotations">Estrategia de anotaciones</a>
             </li>
           </ul>
         </li>
         <li>
-          <a href="#strategies-manual">Manual Metadata</a>
+          <a href="#strategies-manual">Metadata manual</a>
         </li>
       </ul>
     </li>
@@ -25,47 +25,47 @@
 
 <a name='models-metadata'></a>
 
-# Models Metadata
+# Metadatos de modelos
 
-To speed up development `Phalcon\Mvc\Model` helps you to query fields and constraints from tables related to models. To achieve this, `Phalcon\Mvc\Model\MetaData` is available to manage and cache table metadata.
+Para acelerar el desarrollo, `Phalcon\Mvc\Model` ayuda a consultar campos y restricciones de las tablas relacionadas con los modelos. Para lograr esto, está disponible `Phalcon\Mvc\Model\MetaData` para administrar y almacenar en caché los metadatos de las tablas.
 
-Sometimes it is necessary to get those attributes when working with models. You can get a metadata instance as follows:
+A veces es necesario obtener los atributos cuando se trabaja con modelos. Se puede obtener una instancia de metadatos de la siguiente manera:
 
 ```php
 <?php
 
 $robot = new Robots();
 
-// Get Phalcon\Mvc\Model\Metadata instance
+// Obtener instancia de Phalcon\Mvc\Model\Metadata
 $metadata = $robot->getModelsMetaData();
 
-// Get robots fields names
+// Obtener nombres de los campos de los robots
 $attributes = $metadata->getAttributes($robot);
 print_r($attributes);
 
-// Get robots fields data types
+// Obtener tipos de datos de los campos de los robots
 $dataTypes = $metadata->getDataTypes($robot);
 print_r($dataTypes);
 ```
 
 <a name='caching-metadata'></a>
 
-## Caching Metadata
+## Almacenamiento en caché de metadatos
 
-Once the application is in a production stage, it is not necessary to query the metadata of the table from the database system each time you use the table. This could be done caching the metadata using any of the following adapters:
+Una vez que la aplicación está en una etapa de producción, no es necesario consultar los metadatos de la tabla del sistema de base de datos cada vez que use la tabla. Esto podría hacerse almacenando en caché los metadatos, utilizando cualquiera de los siguientes adaptadores:
 
-| Adapter      | Description                                                                                                                                                                                                                                                                                                              | API                                           |
-| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------- |
-| Apc          | This adapter uses the [Alternative PHP Cache (APC)](http://www.php.net/manual/en/book.apc.php) to store the table metadata. You can specify the lifetime of the metadata with options. (Recommended for Production).                                                                                                     | `Phalcon\Mvc\Model\MetaData\Apc`          |
-| Files        | This adapter uses plain files to store metadata. This adapter reduces database queries but has an increased I/O with the file system.                                                                                                                                                                                    | `Phalcon\Mvc\Model\MetaData\Files`        |
-| Libmemcached | This adapter uses the [Memcached Server](https://www.memcached.org/) to store the table metadata. The server parameters as well as the cache lifetime are specified in the options. (Recommended for Production)                                                                                                         | `Phalcon\Mvc\Model\MetaData\Libmemcached` |
-| Memcache     | This adapter uses [Memcache](http://php.net/manual/en/book.memcache.php) to store the table metadata. You can specify the lifetime of the metadata with options. (Recommended for Production)                                                                                                                            | `Phalcon\Mvc\Model\MetaData\MEmcache`     |
-| Memory       | This adapter is the default. The metadata is cached only during the request. When the request is completed, the metadata are released as part of the normal memory of the request. (Recommended for Development)                                                                                                         | `Phalcon\Mvc\Model\MetaData\Memory`       |
-| Redis        | This adapter uses [Redis](https://redis.io/) to store the table metadata. The server parameters as well as the cache lifetime are specified in the options. (Recommended for Production).                                                                                                                                | `Phalcon\Mvc\Model\MetaData\Redis`        |
-| Session      | This adapter stores metadata in the `$_SESSION` superglobal. This adapter is recommended only when the application is actually using a small number of models. The metadata are refreshed every time a new session starts. This also requires the use of `session_start()` to start the session before using any models. | `Phalcon\Mvc\Model\MetaData\Session`      |
-| XCache       | This adapter uses [XCache](http://xcache.lighttpd.net/) to store the table metadata. You can specify the lifetime of the metadata with options. This is one of the recommended ways to store metadata when the application is in production.                                                                             | `Phalcon\Mvc\Model\MetaData\Xcache`       |
+| Adaptador    | Descripción                                                                                                                                                                                                                                                                                                                                                                 | API                                           |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
+| Apc          | Este adaptador utiliza [Alternative PHP Cache (APC)](http://www.php.net/manual/en/book.apc.php) para almacenar los metadatos de tabla. Puede especificar la duración de los metadatos con opciones. (Recomendado para producción).                                                                                                                                          | `Phalcon\Mvc\Model\MetaData\Apc`          |
+| Files        | Este adaptador utiliza archivos planos para almacenar metadatos. Este adaptador reduce consultas de base de datos pero tiene una mayor E/S con el sistema de archivos.                                                                                                                                                                                                      | `Phalcon\Mvc\Model\MetaData\Files`        |
+| Libmemcached | Este adaptador utiliza el [Servidor Memcached](https://www.memcached.org/) para almacenar los metadatos de la tabla. Los parámetros de servidor así como la duración de la caché se especifica en las opciones. (Recomendado para producción)                                                                                                                               | `Phalcon\Mvc\Model\MetaData\Libmemcached` |
+| Memcache     | Este adaptador utiliza [Memcache](http://php.net/manual/en/book.memcache.php) para almacenar los metadatos de la tabla. Puede especificar la duración de los metadatos con opciones. (Recomendado para producción)                                                                                                                                                          | `Phalcon\Mvc\Model\MetaData\Memcache`     |
+| Memory       | Este adaptador es el predeterminado. Se almacena en caché los metadatos sólo durante la solicitud. Cuando se haya completado la solicitud, los metadatos son liberados como parte de la memoria normal de la solicitud. (Recomendado para el desarrollo)                                                                                                                    | `Phalcon\Mvc\Model\MetaData\Memory`       |
+| Redis        | Este adaptador utiliza [Redis](https://redis.io/) para almacenar los metadatos de la tabla. Los parámetros de servidor así como la duración de la caché se especifica en las opciones. (Recomendado para producción).                                                                                                                                                       | `Phalcon\Mvc\Model\MetaData\Redis`        |
+| Session      | Este adaptador almacena metadatos en la variable global `$_SESSION`. Este adaptador sólo se recomienda cuando la aplicación está utilizando realmente un pequeño número de modelos. Los metadatos se actualizan cada vez que inicie una nueva sesión. Esto también requiere el uso de `session_start()` para iniciar la sesión antes de utilizar cualquiera de los modelos. | `Phalcon\Mvc\Model\MetaData\Session`      |
+| XCache       | Este adaptador utiliza [XCache](http://xcache.lighttpd.net/) para almacenar los metadatos de la tabla. Puede especificar la duración de los metadatos con opciones. Esta es una de las maneras recomendadas para almacenar metadatos cuando la aplicación está en producción.                                                                                               | `Phalcon\Mvc\Model\MetaData\Xcache`       |
 
-As other ORM's dependencies, the metadata manager is requested from the services container:
+Como otras dependencias del ORM, se solicita el administrador de metadatos al contenedor de servicios:
 
 ```php
 <?php
@@ -73,7 +73,7 @@ As other ORM's dependencies, the metadata manager is requested from the services
 use Phalcon\Mvc\Model\MetaData\Apc as ApcMetaData;
 
 $di['modelsMetadata'] = function () {
-    // Create a metadata manager with APC
+    // Creamos un gestor de metadatos con APC
     $metadata = new ApcMetaData(
         [
             'lifetime' => 86400,
@@ -87,11 +87,11 @@ $di['modelsMetadata'] = function () {
 
 <a name='metadata-strategies'></a>
 
-## Metadata Strategies
+## Estrategias de metadatos
 
-As mentioned above the default strategy to obtain the model's metadata is database introspection. In this strategy, the information schema is used to know the fields in a table, its primary key, nullable fields, data types, etc.
+Como se mencionó anteriormente la estrategia por defecto para obtener metadatos del modelo es introspección de la base de datos. En esta estrategia, el esquema de información se utiliza para conocer los campos de una tabla, su clave primaria, campos que aceptan valores NULL, los tipos de datos, etcétera.
 
-You can change the default metadata introspection in the following way:
+Se puede cambiar la introspección de metadatos por defecto de la siguiente manera:
 
 ```php
 <?php
@@ -99,7 +99,7 @@ You can change the default metadata introspection in the following way:
 use Phalcon\Mvc\Model\MetaData\Apc as ApcMetaData;
 
 $di['modelsMetadata'] = function () {
-    // Instantiate a metadata adapter
+    // Instanciar un adaptador de metadata
     $metadata = new ApcMetaData(
         [
             'lifetime' => 86400,
@@ -107,7 +107,7 @@ $di['modelsMetadata'] = function () {
         ]
     );
 
-    // Set a custom metadata introspection strategy
+    // Configurar una estratégia personalizada de instrospección
     $metadata->setStrategy(
         new MyIntrospectionStrategy()
     );
@@ -118,15 +118,15 @@ $di['modelsMetadata'] = function () {
 
 <a name='strategies-database-introspection'></a>
 
-### Database Introspection Strategy
+### Estrategia de introspección de la base de datos
 
-This strategy doesn't require any customization and is implicitly used by all the metadata adapters.
+Esta estrategia no requiere ninguna personalización y es utilizada implícitamente por todos los adaptadores de metadatos.
 
 <a name='strategies-annotations'></a>
 
-### Annotations Strategy
+### Estrategia de anotaciones
 
-This strategy makes use of `annotations <annotations>` to describe the columns in a model:
+Esta estrategia hace uso de anotaciones `<anotations>` para describir las columnas en un modelo:
 
 ```php
 <?php
@@ -159,25 +159,25 @@ class Robots extends Model
 }
 ```
 
-Annotations must be placed in properties that are mapped to columns in the mapped source. Properties without the @Column annotation are handled as simple class attributes.
+Las anotaciones deben colocarse en las propiedades que se asignan a columnas en la fuente asignada. Las propiedades sin la anotación @Column se trataran como simples atributos de la clase.
 
-The following annotations are supported:
+Son soportadas las siguientes anotaciones:
 
-| Name     | Description                                       |
-| -------- | ------------------------------------------------- |
-| Primary  | Mark the field as part of the table's primary key |
-| Identity | The field is an auto_increment/serial column      |
-| Column   | This marks an attribute as a mapped column        |
+| Nombre   | Descripción                                                 |
+| -------- | ----------------------------------------------------------- |
+| Primary  | Marcar el campo como parte de la clave primaria de la tabla |
+| Identity | El campo es una columna auto_increment/serial               |
+| Column   | Esto marca un atributo como una columna mapeada             |
 
-The annotation @Column supports the following parameters:
+La anotación @Column admite los siguientes parámetros:
 
-| Name     | Description                                           |
-| -------- | ----------------------------------------------------- |
-| type     | The column's type (string, integer, decimal, boolean) |
-| length   | The column's length if any                            |
-| nullable | Set whether the column accepts null values or not     |
+| Nombre   | Descripción                                            |
+| -------- | ------------------------------------------------------ |
+| type     | Tipo de la columna (string, integer, decimal, boolean) |
+| length   | Longitud de la columna si lo hubiere                   |
+| nullable | Si la columna acepta valores null o no                 |
 
-The annotations strategy could be set up this way:
+La estrategia de anotaciones podría ser configurada de esta manera:
 
 ```php
 <?php
@@ -186,7 +186,7 @@ use Phalcon\Mvc\Model\MetaData\Apc as ApcMetaData;
 use Phalcon\Mvc\Model\MetaData\Strategy\Annotations as StrategyAnnotations;
 
 $di['modelsMetadata'] = function () {
-    // Instantiate a metadata adapter
+    // Instancia del adaptador de metadata 
     $metadata = new ApcMetaData(
         [
             'lifetime' => 86400,
@@ -194,7 +194,7 @@ $di['modelsMetadata'] = function () {
         ]
     );
 
-    // Set a custom metadata database introspection
+    // Configurar un introspección personalizada para la base de datos
     $metadata->setStrategy(
         new StrategyAnnotations()
     );
@@ -205,13 +205,13 @@ $di['modelsMetadata'] = function () {
 
 <a name='strategies-manual'></a>
 
-## Manual Metadata
+## Metadata manual
 
-Phalcon can obtain the metadata for each model automatically without the developer must set them manually using any of the introspection strategies presented above.
+Phalcon puede obtener los metadatos de cada modelo automáticamente sin que el desarrollador deba establecerlas manualmente usando cualquiera de las estrategias de introspección presentadas arriba.
 
-The developer also has the option of define the metadata manually. This strategy overrides any strategy set in the metadata manager. New columns added/modified/removed to/from the mapped table must be added/modified/removed also for everything to work properly.
+Sin embargo, el desarrollador también tiene la opción de definir los metadatos manualmente. Esta estrategia sobrescribe cualquier estrategia establecida en el gestor de metadatos. Las nuevas columnas añadidas/modificadas/eliminadas de/hacia la tabla asignada deben agregarse/modificarse/eliminarse también para que todo funcione correctamente.
 
-The following example shows how to define the metadata manually:
+En el ejemplo siguiente se muestra cómo definir los metadatos manualmente:
 
 ```php
 <?php
@@ -225,7 +225,7 @@ class Robots extends Model
     public function metaData()
     {
         return array(
-            // Every column in the mapped table
+            // Cada columna en la tabla asignada
             MetaData::MODELS_ATTRIBUTES => [
                 'id',
                 'name',
@@ -233,26 +233,26 @@ class Robots extends Model
                 'year',
             ],
 
-            // Every column part of the primary key
+            // Cada columna que es parte de la clave primaria
             MetaData::MODELS_PRIMARY_KEY => [
                 'id',
             ],
 
-            // Every column that isn't part of the primary key
+            // Columnas que no son parte de la clave primaria
             MetaData::MODELS_NON_PRIMARY_KEY => [
                 'name',
                 'type',
                 'year',
             ],
 
-            // Every column that doesn't allows null values
+            // Columnas que no permiten valores nulos
             MetaData::MODELS_NOT_NULL => [
                 'id',
                 'name',
                 'type',
             ],
 
-            // Every column and their data types
+            // Cada columna con su tipo de datos
             MetaData::MODELS_DATA_TYPES => [
                 'id'   => Column::TYPE_INTEGER,
                 'name' => Column::TYPE_VARCHAR,
@@ -260,17 +260,16 @@ class Robots extends Model
                 'year' => Column::TYPE_INTEGER,
             ],
 
-            // The columns that have numeric data types
+            // Columnas que tienen tipos de datos numéricos
             MetaData::MODELS_DATA_TYPES_NUMERIC => [
                 'id'   => true,
                 'year' => true,
             ],
 
-            // The identity column, use boolean false if the model doesn't have
-            // an identity column
+            // Columna identidad, utilizar false si el modelo no tiene una columna identidad
             MetaData::MODELS_IDENTITY_COLUMN => 'id',
 
-            // How every column must be bound/casted
+            // Como deben enlazarse y clasificarse las columnas
             MetaData::MODELS_DATA_TYPES_BIND => [
                 'id'   => Column::BIND_PARAM_INT,
                 'name' => Column::BIND_PARAM_STR,
@@ -278,22 +277,22 @@ class Robots extends Model
                 'year' => Column::BIND_PARAM_INT,
             ],
 
-            // Fields that must be ignored from INSERT SQL statements
+            // Campos que deben ser ignorados en las instrucciones SQL INSERT
             MetaData::MODELS_AUTOMATIC_DEFAULT_INSERT => [
                 'year' => true,
             ],
 
-            // Fields that must be ignored from UPDATE SQL statements
+            // Campos que deben ser ignorados en instrucciones SQL UPDATE
             MetaData::MODELS_AUTOMATIC_DEFAULT_UPDATE => [
                 'year' => true,
             ],
 
-            // Default values for columns
+            // Valores por defecto de las columnas
             MetaData::MODELS_DEFAULT_VALUES => [
                 'year' => '2015',
             ],
 
-            // Fields that allow empty strings
+            // Campos que permiten string vacios
             MetaData::MODELS_EMPTY_STRING_VALUES => [
                 'name' => true,
             ],
diff --git a/es/db-models-transactions.md b/es/db-models-transactions.md
index ba24551d3b49..f538a5adc947 100644
--- a/es/db-models-transactions.md
+++ b/es/db-models-transactions.md
@@ -1,15 +1,15 @@
 <div class='article-menu'>
   <ul>
     <li>
-      <a href="#overview">Model Transactions</a> <ul>
+      <a href="#overview">Transacciones en modelos</a> <ul>
         <li>
-          <a href="#manual">Manual Transactions</a>
+          <a href="#manual">Transacciones manuales</a>
         </li>
         <li>
-          <a href="#implicit">Implicit Transactions</a>
+          <a href="#implicit">Transacciones implícitas</a>
         </li>
         <li>
-          <a href="#isolated">Isolated Transactions</a>
+          <a href="#isolated">Transacciones aisladas</a>
         </li>
       </ul>
     </li>
@@ -18,17 +18,17 @@
 
 <a name='overview'></a>
 
-# Model Transactions
+# Transacciones en modelos
 
-When a process performs multiple database operations, it might be important that each step is completed successfully so that data integrity can be maintained. Transactions offer the ability to ensure that all database operations have been executed successfully before the data is committed to the database.
+Cuando un proceso realiza múltiples operaciones de base de datos, sería importante que cada paso se haya completado con éxito para que pueda mantenerse la integridad de los datos. Las transacciones ofrecen la capacidad para garantizar que todas las operaciones de base de datos han sido ejecutadas con éxito antes de que los datos se asienten en la base de datos.
 
-Transactions in Phalcon allow you to commit all operations if they were executed successfully or rollback all operations if something went wrong.
+Las transacciones en Phalcon permiten comprometer a todas las operaciones si se ejecutaron con éxito o deshacer todas las operaciones si algo salió mal.
 
 <a name='manual'></a>
 
-## Manual Transactions
+## Transacciones manuales
 
-If an application only uses one connection and the transactions are not very complex, a transaction can be created by just moving the current connection into transaction mode and then commit or rollback the operation whether it is successful or not:
+Si una aplicación utiliza sólo una conexión y las transacciones no son muy complejas, se puede crear una transacción moviendo sólo la conexión actual a modo de transacción y luego confirmar o deshacer la operación sea exitosa o no:
 
 ```php
 <?php
@@ -39,7 +39,7 @@ class RobotsController extends Controller
 {
     public function saveAction()
     {
-        // Start a transaction
+        // Iniciar una transacción
         $this->db->begin();
 
         $robot = new Robots();
@@ -47,7 +47,7 @@ class RobotsController extends Controller
         $robot->name       = 'WALL-E';
         $robot->created_at = date('Y-m-d');
 
-        // The model failed to save, so rollback the transaction
+        // Si el modelo falla al guardarse, entonces deshacemos la transacción
         if ($robot->save() === false) {
             $this->db->rollback();
             return;
@@ -56,16 +56,16 @@ class RobotsController extends Controller
         $robotPart = new RobotParts();
 
         $robotPart->robots_id = $robot->id;
-        $robotPart->type      = 'head';
+        $robotPart->type      = 'cabeza';
 
-        // The model failed to save, so rollback the transaction
+        // Si el modelo falla al guardar, deshacemos la transacción
         if ($robotPart->save() === false) {
             $this->db->rollback();
 
             return;
         }
 
-        // Commit the transaction
+        // Confirmamos la transacción
         $this->db->commit();
     }
 }
@@ -73,9 +73,9 @@ class RobotsController extends Controller
 
 <a name='implicit'></a>
 
-## Implicit Transactions
+## Transacciones implícitas
 
-Existing relationships can be used to store records and their related instances, this kind of operation implicitly creates a transaction to ensure that data is correctly stored:
+Las relaciones existentes se pueden utilizar para almacenar registros y sus instancias relacionadas, este tipo de operación implícitamente crea una transacción para asegurar que los datos se almacenan correctamente:
 
 ```php
 <?php
@@ -84,23 +84,21 @@ $robotPart = new RobotParts();
 
 $robotPart->type = 'head';
 
-
-
 $robot = new Robots();
 
 $robot->name       = 'WALL-E';
 $robot->created_at = date('Y-m-d');
 $robot->robotPart  = $robotPart;
 
-// Creates an implicit transaction to store both records
+// Crea una transacción implícita para almacenar ambos registros
 $robot->save();
 ```
 
 <a name='isolated'></a>
 
-## Isolated Transactions
+## Transacciones aisladas
 
-Isolated transactions are executed in a new connection ensuring that all the generated SQL, virtual foreign key checks and business rules are isolated from the main connection. This kind of transaction requires a transaction manager that globally manages each transaction created ensuring that they are correctly rolled back/committed before ending the request:
+Las transacciones aisladas se ejecutan en una nueva conexión, asegurando que todos los SQL generados, controles de claves extranjeras virtuales y reglas de negocio están aisladas de la conexión principal. Este tipo de transacción requiere de un administrador de transacciones que gestiona globalmente cada transacción creada, asegurando que ellas sean correctamente confirmadas/desechadas antes de terminar la solicitud:
 
 ```php
 <?php
@@ -109,10 +107,10 @@ use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
 use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
 
 try {
-    // Create a transaction manager
+    // Crear un gestor de transacciones
     $manager = new TxManager();
 
-    // Request a transaction
+    // Solicitar una transacción
     $transaction = $manager->get();
 
     $robot = new Robots();
@@ -133,7 +131,7 @@ try {
     $robotPart->setTransaction($transaction);
 
     $robotPart->robots_id = $robot->id;
-    $robotPart->type      = 'head';
+    $robotPart->type      = 'cabeza';
 
     if ($robotPart->save() === false) {
         $transaction->rollback(
@@ -141,14 +139,14 @@ try {
         );
     }
 
-    // Everything's gone fine, let's commit the transaction
+    // Todo resulto bien, entonces confirmamos la transacción
     $transaction->commit();
 } catch (TxFailed $e) {
     echo 'Failed, reason: ', $e->getMessage();
 }
 ```
 
-Transactions can be used to delete many records in a consistent way:
+Las transacciones pueden utilizarse para eliminar muchos registros de forma coherente:
 
 ```php
 <?php
@@ -157,13 +155,13 @@ use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
 use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
 
 try {
-    // Create a transaction manager
+    // Crear un gestor de transacciones
     $manager = new TxManager();
 
-    // Request a transaction
+    // Solicitar una transacción
     $transaction = $manager->get();
 
-    // Get the robots to be deleted
+    // Obtener los robots a borrar
     $robots = Robots::find(
         "type = 'mechanical'"
     );
@@ -171,7 +169,7 @@ try {
     foreach ($robots as $robot) {
         $robot->setTransaction($transaction);
 
-        // Something's gone wrong, we should rollback the transaction
+        // Algo resulto mal, debemos deshacer la transacción
         if ($robot->delete() === false) {
             $messages = $robot->getMessages();
 
@@ -183,16 +181,16 @@ try {
         }
     }
 
-    // Everything's gone fine, let's commit the transaction
+    // Todo salio bien, confirmamos la transacción
     $transaction->commit();
 
-    echo 'Robots were deleted successfully!';
+    echo 'Robots borrados exitosamente!';
 } catch (TxFailed $e) {
-    echo 'Failed, reason: ', $e->getMessage();
+    echo 'Error, detalle: ', $e->getMessage();
 }
 ```
 
-Transactions are reused no matter where the transaction object is retrieved. A new transaction is generated only when a `commit()` or :code:`rollback()` is performed. You can use the service container to create the global transaction manager for the entire application:
+Las transacciones se reutilizan, sin importar de donde es obtenido el objeto de la transacción. Una nueva transacción se genera sólo cuando se realiza un `commit()` o `rollback()`. Se puede utilizar el contenedor de servicio para crear un administrador global de transacciones para toda la aplicación:
 
 ```php
 <?php
@@ -207,7 +205,7 @@ $di->setShared(
 );
 ```
 
-Then access it from a controller or view:
+Para luego acceder a él desde un controlador o vista:
 
 ```php
 <?php
@@ -218,13 +216,13 @@ class ProductsController extends Controller
 {
     public function saveAction()
     {
-        // Obtain the TransactionsManager from the services container
+        // Obtener el gestor de transacciones desde el contenedor de servicios
         $manager = $this->di->getTransactions();
 
-        // Or
+        // O simplemente
         $manager = $this->transactions;
 
-        // Request a transaction
+        // Solicitar una transacción
         $transaction = $manager->get();
 
         // ...
@@ -232,4 +230,4 @@ class ProductsController extends Controller
 }
 ```
 
-While a transaction is active, the transaction manager will always return the same transaction across the application.
\ No newline at end of file
+Mientras una transacción está activa, el administrador de transacciones siempre devuelve la misma transacción a través de la aplicación.
\ No newline at end of file
diff --git a/es/new-feature-request.md b/es/new-feature-request.md
index 2ec9d224f6b1..233d54e8637c 100644
--- a/es/new-feature-request.md
+++ b/es/new-feature-request.md
@@ -1,11 +1,11 @@
-# New Feature Request
+# Solicita una nueva funcionalidad
 
-A NFR is a short document explaining how a new feature request must be submitted, how it can be implemented, and how it can help core developers and others to understand implement it.
+Una NFR (New Feature Request) es un pequeño documento explicando cómo debe presentarse una nueva solicitud de función, cómo se puede implementar y cómo puede ayudar a los desarrolladores del núcleo y otros entender como implementarla.
 
-A NFR contains: * Suggested syntax * Suggested class names and methods * A short documentation * If the feature is already implemented in other frameworks, a short explanation of how that was implemented and its advantages
+Una NFR contiene: * sintaxis sugerida * sugerencias de nombres de clase y métodos * una breve documentación * si la función ya está implementada en otros frameworks, una breve explicación de como fue implementada y sus ventajas
 
-In the following cases a new feature request will be rejected: * The feature makes the framework slow * The feature doesn't provide any additional value to the framework * The NFR is not clear, bad documentation, unclear explanation, etc. * The NFR doesn't follow the current guidelines/philosophy of the framework * The NFR affects/breaks applications developed in current/older versions of the framework * The original poster doesn't provide feedback/input when requested * It's technically impossible to implement * It can only be used in the development/testing stages * Submitted/proposed classes/components don't follow the [Single Responsibility Principle](http://en.wikipedia.org/wiki/Single_responsibility_principle) * Static methods aren't allowed
+En los siguientes casos se rechazará una nueva solicitud de funcionalidad: * La función hace el framework más lento * La característica de no ofrece ningún valor adicional al framework * El NFR no es claro, mala documentación, explicación confusa, etcétera. * La NFR no sigue la directrices/filosofía actual del framework * La NFR afecta/rompe aplicaciones desarrolladas en versiones actuales/anteriores del framework * El autor no proporciona feedback cuando solicita * Es técnicamente imposible aplicar * Sólo se puede utilizar en las etapas de desarrollo o pruebas * Enviando o presentado, clases o componentes no siguen el [ Principio de simple responsabilidad](http://en.wikipedia.org/wiki/Single_responsibility_principle) * Métodos estáticos no son permitidos
 
-To send a NFR you don't need to provide Zephir or C code or develop the feature. New Feture requests explain the goal of the intended implementation and open discussion on how best to implement it.
+Para enviar una NFR no necesita proporcionar el código C, Zephir o desarrollar la función. Nuevas solicitudes de Funcionalidad explican el objetivo de la aplicación prevista y abren la discusión sobre la mejor manera de implementarlo.
 
-All NFRs should be posted as a new issue on [Github](https://github.com/phalcon/cphalcon/issues).
\ No newline at end of file
+Todas las NFR deben ser publicadas como un tema nuevo en [Github](https://github.com/phalcon/cphalcon/issues).
\ No newline at end of file
diff --git a/es/new-pull-request.md b/es/new-pull-request.md
index dcc9de2b9ee1..4e1fa3484219 100644
--- a/es/new-pull-request.md
+++ b/es/new-pull-request.md
@@ -1,9 +1,9 @@
-# New Pull Request
+# Nuevo Pull Request
 
-A pull request is alterations to the code that either fixes a current issue or introduces new functionality.
+Una pull request es una o varias alteraciones en el código que soluciona un problema actual o introduce nuevas funcionalidades.
 
-Your Pull request must include: * Issued to the correct branch. **We do not accept Pull Requests to the `master` branch** * Update to the CHANGELOG * Unit tests * Documentation if necessary and usage examples
+Tu Pull request debe incluir: * Referencia a la rama correcta. **No aceptarmos Pull Requests hacia la rama `master`** * Actualiza el CHANGELOG * Pruebas unitarias * Documentación si es necesaria y ejemplos de uso
 
-For fixing bugs, please ensure that you reference the issue in Github. If such issue does not exist, create one.
+Para corrección de errores, por favor asegúrate de hacer referencia al número de tema en Github. Si tal número no existe, debes crearlo.
 
-For new functionality, again we will need to have an issue created and referenced. If the functionality you are introducing collides with the philosophy and implementation of Phalcon it will be rejected. Additionally any new functionality that introduces breaking changes will be rejected at least for the current version but could very well be implemented in the next major version. It is highly recommended to discuss your NFR and PR with the core team and most importantly with the community so as to get feedback.
\ No newline at end of file
+Para una nueva funcionalidad, de nuevo, necesitamos tener un tema creado y su número de referencia. Si la funcionalidad que estás introduciendo choca con la filosofía y la aplicación de Phalcon, será rechazada. Además cualquier nueva funcionalidad que introduce cambios de última hora será rechazada por lo menos para la versión actual pero muy bien podría aplicarse en la próxima versión mayor. Se recomienda discutir sus NFR y PR con el equipo, y lo más importante, con la comunidad con el fin de obtener retroalimentación.
\ No newline at end of file