Add Spanish translation for advanced.md (#913)

docs/fluent/advanced.es.md

@@ -0,0 +1,194 @@
+# Avanzado
+
+Fluent se esfuerza por crear una API general e independiente de cualquier base de datos que te permita trabajar con tus datos. Esto facilita el proceso de aprendizaje de Fluent, sin importar el conector de base de datos que uses. Crear APIs generalizadas también puede hacer que trabajar con tu base de datos en Swift se sienta más cómodo. 
+
+Sin embargo, puede que necesites usar una característica de tu base de datos subyacente que todavía no tenga soporte en Fluent. Esta guía cubre APIs y patrones avanzados en Fluent que solo funcionan con ciertas bases de datos.
+
+## SQL
+
+Todos los conectores SQL de Fluent están construidos con [SQLKit](https://github.com/vapor/sql-kit). Esta implementación general de SQL se incluye con Fluent en el módulo `FluentSQL`.
+
+### Base de datos SQL
+
+Cualquier `Database` de Fluent puede convertirse (cast) a una `SQLDatabase`. Esto incluye `req.db`, `app.db`, la `database` pasada a `Migration`, etc. 
+
+```swift
+import FluentSQL
+
+if let sql = req.db as? SQLDatabase {
+    // El conector subyacente de base de datos es SQL.
+    let planets = try await sql.raw("SELECT * FROM planets").all(decoding: Planet.self)
+} else {
+    // La base de datos subyacente _no_ es SQL.
+}
+```
+
+Esta conversión solo funcionará si el conector de la base de datos subyacente es una base de datos SQL. Aprende más acerca de los métodos de `SQLDatabase` en el [README de SQLKit](https://github.com/vapor/sql-kit).
+
+### Bases de datos SQL específicas
+
+También puedes convertir a bases de datos SQL específicas importando el conector (driver). 
+
+```swift
+import FluentPostgresDriver
+
+if let postgres = req.db as? PostgresDatabase {
+    // El conector subyacente de base de datos es PostgreSQL.
+    postgres.simpleQuery("SELECT * FROM planets").all()
+} else {
+    // La base de datos subyacente _no_ es PostgreSQL.
+}
+```
+
+En el momento de esta redacción, están soportados los siguientes conectores SQL:
+
+|Base de Datos|Conector|Librería|
+|-|-|-|
+|`PostgresDatabase`|[vapor/fluent-postgres-driver](https://github.com/vapor/fluent-postgres-driver)|[vapor/postgres-nio](https://github.com/vapor/postgres-nio)|
+|`MySQLDatabase`|[vapor/fluent-mysql-driver](https://github.com/vapor/fluent-mysql-driver)|[vapor/mysql-nio](https://github.com/vapor/mysql-nio)|
+|`SQLiteDatabase`|[vapor/fluent-sqlite-driver](https://github.com/vapor/fluent-sqlite-driver)|[vapor/sqlite-nio](https://github.com/vapor/sqlite-nio)|
+
+Visita los README de la librerías para más información sobre las APIs específicas de cada base de datos.
+
+### SQL Personalizado
+
+Casi todos los tipos de consultas y esquemas de Fluent soportan la opción `.custom`. Esto te permite utilizar características de bases de datos que Fluent todavía no soporta.
+
+```swift
+import FluentPostgresDriver
+
+let query = Planet.query(on: req.db)
+if req.db is PostgresDatabase {
+    // ILIKE soportado.
+    query.filter(\.$name, .custom("ILIKE"), "earth")
+} else {
+    // ILIKE no soportado.
+    query.group(.or) { or in
+        or.filter(\.$name == "earth").filter(\.$name == "Earth")
+    }
+}
+query.all()
+```
+
+Las bases de datos SQL soportan tanto `String` como `SQLExpression` en todos los casos `.custom`. El módulo `FluentSQL` ofrece métodos convenientes para casos de uso comunes.
+
+```swift
+import FluentSQL
+
+let query = Planet.query(on: req.db)
+if req.db is SQLDatabase {
+    // El conector subyacente de base de datos es SQL.
+    query.filter(.sql(raw: "LOWER(name) = 'earth'"))
+} else {
+    //  La base de datos subyacente _no_ es SQL.
+}
+```
+
+A continuación tienes un ejemplo de `.custom` usando el método `.sql(raw:)` con el constructor del esquema.
+
+```swift
+import FluentSQL
+
+let builder = database.schema("planets").id()
+if database is MySQLDatabase {
+    // El conector subyacente de base de datos es MySQL.
+    builder.field("name", .sql(raw: "VARCHAR(64)"), .required)
+} else {
+    // La base de datos subyacente _no_ es MySQL.
+    builder.field("name", .string, .required)
+}
+builder.create()
+```
+
+## MongoDB
+
+Fluent MongoDB es una integración entre [Fluent](../fluent/overview.md) y el conector [MongoKitten](https://github.com/OpenKitten/MongoKitten/). Aprovecha el sistema de tipado fuerte de Swift y la interfaz no anclada a bases de datos de Fluent, usando MongoDB.
+
+El identificador más común en MongoDB es ObjectId. Puedes usarlo para tus proyectos usando `@ID(custom: .id)`.
+Si necesitas usar los mismos modelos con SQL, no uses `ObjectId`. Usa `UUID` en su lugar.
+
+```swift
+final class User: Model {
+    // Nombre de la tabla o colección.
+    static let schema = "users"
+
+    // Identificador único para este User.
+    // En este caso, se usa ObjectId
+    // Fluent recomienda usar UUID por defecto, sin embargo ObjectId también está soportado
+    @ID(custom: .id)
+    var id: ObjectId?
+
+    // La dirección email del User
+    @Field(key: "email")
+    var email: String
+
+    // La contraseña de User se guarda como un hash de BCrypt
+    @Field(key: "password")
+    var passwordHash: String
+
+    // Crea una nueva instancia de User vacía para el uso de Fluent
+    init() { }
+
+    // Crea un nuevo User con todas las propiedades establecidas.
+    init(id: ObjectId? = nil, email: String, passwordHash: String, profile: Profile) {
+        self.id = id
+        self.email = email
+        self.passwordHash = passwordHash
+        self.profile = profile
+    }
+}
+```
+
+### Modelado de Datos
+
+En MongoDB, los Modelos se definen de la misma manera que en cualquier otro entorno de Fluent. La principal diferencia entre bases de datos SQL y MongoDB reside en las relaciones y la arquitectura.
+
+En entornos SQL, es muy común crear tablas de unión para relaciones entre dos entidades. En MongoDB, sin embargo, una colección (array) puede usarse para guardar identificadores relacionados. Debido al diseño de MongoDB, es más práctico y eficiente diseñar tus modelos con estructuras de datos anidadas.
+
+### Datos Flexibles
+
+Puedes añadir datos flexibles en MongoDB, pero este código no funcionará en entornos SQL.
+Para crear un almacenamiento de datos arbitrarios agrupados puedes usar `Document`.
+
+```swift
+@Field(key: "document")
+var document: Document
+```
+
+Fluent no puede soportar consultas de tipos estrictos en estos valores. Puedes usar un key path con notación de punto (dot notated key path) en tus consultas.
+Esto está aceptado en MongoDB para acceder a valores anidados.
+
+```swift
+Something.query(on: db).filter("document.key", .equal, 5).first()
+```
+### Uso de expresiones regulares
+
+Puedes consultar a MongoDB usando el caso `.custom()`, y pasando una expresión regular. [MongoDB](https://www.mongodb.com/docs/manual/reference/operator/query/regex/) acepta expresiones regulares compatibles con Perl. 
+
+Por ejemplo, puedes hacer una consulta que obvie mayúsculas y minúsculas sobre el campo `name`:
+
+```swift
+import FluentMongoDriver
+
+var queryDocument = Document()
+queryDocument["name"]["$regex"] = "e"
+queryDocument["name"]["$options"] = "i"
+
+let planets = try Planet.query(on: req.db).filter(.custom(queryDocument)).all()
+```
+
+Esto devolverá planetas que contengan 'e' y 'E'. También puedes crear otras RegEx complejas aceptadas por MongoDB.
+
+### Raw Access
+
+Para acceder a la instancia `MongoDatabase` en bruto, convierte (cast) la instancia de base de datos a `MongoDatabaseRepresentable` de la siguiente manera:
+
+```swift
+guard let db = req.db as? MongoDatabaseRepresentable else {
+  throw Abort(.internalServerError)
+}
+
+let mongodb = db.raw
+```
+
+A partir de aquí puedes usar todas las APIs de MongoKitten.