Skip to content

Compare: ScalaAnorm

Showing with 25 additions and 25 deletions.
  1. +25 −25 manual/scalaGuide/main/sql/ScalaAnorm.md
View
50 manual/scalaGuide/main/sql/ScalaAnorm.md
@@ -1,14 +1,14 @@
-# Anorm, simple SQL data access
+# Anorm, accediendo fácilmente a datos SQL
> Esta página todavía no ha sido traducida al castellano. Puedes ayudarnos con la tarea simplemente presionando el botón `Edit Page`. Para más información puedes leer esta [[guía para el traductor | http://playdoces.appspot.com/documentation/latest/translation]]. [[Aquí | https://github.com/opensas/Play20Es/wiki/Progress]] puedes ver cuánto nos falta para terminar la traducción.
-Play includes a simple data access layer called Anorm that uses plain SQL to interact with the database and provides an API to parse and transform the resulting datasets.
+Play incluye una simple capa de acceso a base de datos llamada Anorm que utiliza sentencias SQL para interactuar con la base y provee una API para parsear y transformar los datos obtenidos de la base.
-**Anorm is Not an Object Relational Mapper**
+**Anorm NO es un ORM (Object Relational Mapper)**
-> In the following documentation, we will use the [[MySQL world sample database | http://dev.mysql.com/doc/world-setup/en/world-setup.html]].
+> En la siguiente documentación usaremos la [[base de datos de ejemplo de MySQL | http://dev.mysql.com/doc/world-setup/en/world-setup.html]].
>
-> If you want to enable it for your application, follow the MySQL website instructions, and enable it for your application by adding the following configuration line in your `conf/application.conf` file:
+> Si desea utilizarla para su aplicación, siga las instrucciones del sitio de MySQL, y habilítela para su aplicación agregando la siguiente línea de configuración al archivo `conf/application.conf`:
>
> ```
> db.default.driver= com.mysql.jdbc.Driver
@@ -17,43 +17,43 @@ Play includes a simple data access layer called Anorm that uses plain SQL to int
> db.default.password=secret
> ```
-## Overview
+## Introducción
-It can feel strange to return to plain old SQL to access an SQL database these days, especially for Java developers accustomed to using a high-level Object Relational Mapper like Hibernate to completely hide this aspect.
+Hoy en día, puede resultar extraño volver a las viejas sentencias SQL para acceder a una base de datos SQL, en especial para los desarrolladores Java acostumbrados a utilizar ORMs de alto nivel como Hibernate para olvidarse por completo de SQL.
-Although we agree that these tools are almost required in Java, we think that they are not needed at all when you have the power of a higher-level programming language like Scala. On the contrary, they will quickly become counter-productive.
+Aún cuando estamos de acuerdo en que este tipo de herramientas son casi obligatorias en Java, pensamos que no son necesarias en absoluto cuando contamos con un lenguage de programación de alto nivel como Scala. Por el contrario, no tardarán mucho en volverse contraproducentes.
-#### Using JDBC is a pain, but we provide a better API
+#### Usar JDBC es doloroso, pero nosotros le damos una API más placentera
-We agree that using the JDBC API directly is tedious, particularly in Java. You have to deal with checked exceptions everywhere and iterate over and over around the ResultSet to transform this raw dataset into your own data structure.
+Usar la API de JDBC de manera directa es un proceso tedioso, en especial en Java. Hay que lidiar con checked exceptions por todos lados, e iterar una y otra vez los ResultSets para transformar la información en crudo a nuestras propias estructuras de datos.
-We provide a simpler API for JDBC; using Scala you don’t need to bother with exceptions, and transforming data is really easy with a functional language. In fact, the goal of the Play Scala SQL access layer is to provide several APIs to effectively transform JDBC data into other Scala structures.
+Nosotros brindamos un API mucho más simple para JDBC, usando Scala no necesita preocuparse por las exceptions, y transformar los datos es realmente fácil con un lenguaje funcional. De hecho, el objetivo de la capa de datos de Play para Scala es proveer varias APIs que le permitan transformar de manera simple la información obtenida mediante JDBC a sus propias estructuras de datos.
-#### You don’t need another DSL to access relational databases
+#### No necesita otro DSL para acceder a una base de datos relacional
-SQL is already the best DSL for accessing relational databases. We don’t need to invent something new. Moreover the SQL syntax and features can differ from one database vendor to another.
+SQL es el mejor DSL (lenguaje de dominio específico) que existe para acceder a bases de datos relacionales. No necesitamos inventar nada nuevo. Es más, la sintaxis de SQL y las prestaciones pueden diferir de una base de datos a otra.
-If you try to abstract this point with another proprietary SQL like DSL you will have to deal with several ‘dialects’ dedicated for each vendor (like Hibernate ones), and limit yourself by not using a particular database’s interesting features.
+Si intenta abstraerse de esto con otro DSL similar a SQL, tendrá que lidiar con diversos ‘dialectos’ específicos para cada base de datos (como lo hace Hibernate), y evitar usar las prestaciones propias y exclusivas de una base de datos.
-Play will sometimes provide you with pre-filled SQL statements, but the idea is not to hide the fact that we use SQL under the hood. Play just saves typing a bunch of characters for trivial queries, and you can always fall back to plain old SQL.
+En ocasiones Play le brindará sentencias SQL pre-cargadas de datos, pero la idea es no ocultar el hecho de que por debajo estamos usando SQL. Play simplemente le evita tipear un montón de caracteres para hacer una simple consulta, y siempre podrá recurrir a escribir directamente la sentencia SQL de manera manual.
-#### A type safe DSL to generate SQL is a mistake
+#### Un DSL 'tipado' para generar SQL es un error
-Some argue that a type safe DSL is better since all your queries are checked by the compiler. Unfortunately the compiler checks your queries based on a meta-model definition that you often write yourself by ‘mapping’ your data structure to the database schema.
+Algunos argumentan que un DSL con seguridad de tipos es mejor, ya que todas sus consultas son verificadas por el compilador. Sin embargo, el compilador verifica sus consultas basándose en la definición de meta-datos que a menudo la escribe ustede mismo al 'mapear' su estructura de datos con el esquema de la base de datos.
-There are no guarantees that this meta-model is correct. Even if the compiler says that your code and your queries are correctly typed, it can still miserably fail at runtime because of a mismatch in your actual database definition.
+Nada le garantiza que esta meta-información sea correcta. Incluso cuando el compilador asegure que su código y sus consultas tienen los tipos de datos adecuados, aún así podrá fallar miserablemente en tiempo de ejecución debido a que el esquema real de la base de datos no coincide con la meta-información.
-#### Take Control of your SQL code
+#### Tome el control de su código SQL
-Object Relational Mapping works well for trivial cases, but when you have to deal with complex schemas or existing databases, you will spend most of your time fighting with your ORM to make it generate the SQL queries you want.
+Los ORM (Mapeadores objeto-relacionales) funcionan bien para casos triviales, pero cuando tiene que trabajar con un esquema complejo de datos, o con bases de datos heredadas, se pasará la mayor parte del tiempo peleando con el ORM para que produzca las consultas SQL que usted precisa.
-Writing SQL queries yourself can be tedious for a simple ‘Hello World’ application, but for any real-life application, you will eventually save time and simplify your code by taking full control of your SQL code.
+Escribir las sentencias SQL a mano puede ser tedioso para una simple aplicación ‘Hola Mundo’, pero para cualquier aplicación real, ahorrará tiempo y simplificará su código tomando el control completo de su código SQL.
-## Executing SQL queries
+## Ejecutando consultas SQL
-To start you need to learn how to execute SQL queries.
+Antes que nada debe aprender cómo ejecutar consultas SQL.
-First, import `anorm._`, and then simply use the `SQL` object to create queries. You need a `Connection` to run a query, and you can retrieve one from the `play.api.db.DB` helper:
+Primero, importe `anorm._`, y luego simplemente utilice el objeto `SQL` para creat consultas. Precisará un objeto `Connection` para ejecutar una consulta, que puede obtener a partir de la utilidad `play.api.db.DB`:
```scala
import anorm._
@@ -342,4 +342,4 @@ $ spokenLanguages("FRA")
)
```
-> **Next:** [[Integrating with other database access libraries | ScalaDatabaseOthers]]
+> **Next:** [[Integrating with other database access libraries | ScalaDatabaseOthers]]
Something went wrong with that request. Please try again.