Merge pull request #24 from carlosjml4/master

Se agregan traducciones de los archivo 4.5, 5.1, 5.0, 5.5 , 6.0 y 6.1

Author: jackgris

eBook/05.5.md

@@ -2,12 +2,11 @@
 
 ( ***Project beedb is no longer maintained, but code still there*** )
 
-beedb is a ORM, "Object/Relational Mapping", that developed in Go by me.
-It uses Go style to operate database, implemented mapping struct to database records. It's a lightweight Go ORM framework, the purpose of developing this ORM is to help people learn how to write ORM, and finds a good balance between functions and performance. 
+beedb es un ORM, "Object / Relational Mapping", que se desarrolló en Go por mí. Utiliza Go estilo para operar la base de datos, estructura de asignación aplicado a los registros de base de datos. Es un marco Go ORM ligero, con el propósito de desarrollar este ORM es ayudar a las personas a aprender cómo escribir ORM, y encuentra un buen equilibrio entre las funciones y el rendimiento.
 
-beedb is an open source project, and supports basic functions of ORM, but doesn't support associated query.
+beedb es un proyecto de código abierto, y es compatible con las funciones básicas de la ORM, pero no admite la consulta asociada.
 
-Because beedb support `database/sql` interface standards, so any driver that supports this interface can be used in beedb, I've tested following drivers:
+Debido a que beedb soporta `database/sql` interfaz estándar, cualquier controlador compatible con esta interfaz se pueden utilizar en beedb, he probado los siguientes controladores:
 
 Mysql: [github.com/ziutek/mymysql/godrv](github.com/ziutek/mymysql/godrv)
 
@@ -21,77 +20,76 @@ MS ADODB: [github.com/mattn/go-adodb](github.com/mattn/go-adodb)
 
 ODBC: [bitbucket.org/miquella/mgodbc](bitbucket.org/miquella/mgodbc)
 
-## Installation
+## Instalacion
 
-You can use `go get` to install beedb in your computer.
+Ud puede usar `go get` para instalar beedb en su computador.
 
 	go get github.com/astaxie/beedb
 
-## Initialization
+## Inicializacion
 
-First, you have to import all corresponding packages as follows:
+En primer lugar, usted tiene que importar todos los paquetes correspondientes de la siguiente manera:
 
 	import (
 	    "database/sql"
 	    "github.com/astaxie/beedb"
 	    _ "github.com/ziutek/mymysql/godrv"
 	)
 
-Then you need to open a database connection and create a beedb object(MySQL in this example):
+Luego hay que abrir una conexión de base de datos y crear un objeto beedb (MySQL en este ejemplo):
 
 	db, err := sql.Open("mymysql", "test/xiemengjun/123456")
 	if err != nil {
 	    panic(err)
 	}
 	orm := beedb.New(db)
 
-`beedb.New()` actually has two arguments, the first one is for standard requirement, and the second one is for indicating database engine, but if you are using MySQL/SQLite, you can just skip the second one.
+`beedb.New()` en realidad tiene dos argumentos, el primero es para el requisito estándar, y el segundo es para indicar el motor de base de datos, pero si usted está utilizando MySQL / SQLite, puede saltarse la segunda.
 
-Otherwise, you have to initialize, like SQLServer:
+De lo contrario, usted tiene que inicializar, como SQLServer:
 
 	orm = beedb.New(db, "mssql")
 
 PostgreSQL:
 
 	orm = beedb.New(db, "pg")
 
-beedb supports debug, and use following code to enable:
+beedb soporta depuración, use el siguiente código para permitirlo:
 
 	beedb.OnDebug=true
 
-Now we have a struct for the database table `Userinfo` that we used in previous sections.
+Ahora tenemos una estructura para la base de datos de la tabla `Userinfo` que hemos utilizado en las secciones anteriores.
 
 	type Userinfo struct {
-	    Uid     int `PK` // if the primary key is not id, you need to add tag `PK` for your customized primary key.
+	    Uid     int `PK` // si la clave principal no es id, es necesario agregar `tag` PK para su clave primaria personalizada.
 	    Username    string
 	    Departname  string
 	    Created     time.Time
 	}
 
-Be aware that beedb auto-convert your camel style name to underline and lower case letter. For example, we have `UserInfo` as the struct name, and it will be `user_info` in database, same rule for field name.
-Camel
+Tenga en cuenta que beedb auto-convert su estilo a para subrayar y letra minúscula.  Por ejemplo, tenemos `UserInfo`  como el nombre struct, y será `user_info` en la base de datos, la misma regla para el nombre del campo
 
-## Insert data
+## Isertar datos
 
-The following example shows you how to use beedb to save a struct instead of SQL command, and use Save method to apply change.
+El siguiente ejemplo muestra cómo utilizar beedb para salvar una estructura en lugar de comandos SQL y utilizar Guardar método para aplicar el cambio.
 
 	var saveone Userinfo
 	saveone.Username = "Test Add User"
 	saveone.Departname = "Test Add Departname"
 	saveone.Created = time.Now()
 	orm.Save(&saveone)
 
-And you can check `saveone.Uid` after inserted, its value is self-increase ID, Save method did this job for you.
+Y se puede comprobar `saveone.Uid` después insertado, su valor es  self-increase ID, método Save hizo este trabajo para usted.
 
-beedb provides another way to insert data, which is using map.
+beedb proporciona otra forma de insertar los datos, que está utilizando map.
 
 	add := make(map[string]interface{})
 	add["username"] = "astaxie"
 	add["departname"] = "cloud develop"
 	add["created"] = "2012-12-02"
 	orm.SetTable("userinfo").Insert(add)
 
-Insert multiple data:
+Insertar datos múltiples:
 
 	addslice := make([]map[string]interface{}, 10)
 	add:=make(map[string]interface{})
@@ -105,36 +103,36 @@ Insert multiple data:
 	addslice =append(addslice, add, add2)
 	orm.SetTable("userinfo").InsertBatch(addslice)
 
-The way I showed you above is like chain query, you should be familiar if you know jquery. It returns original ORM object after calls, and continue to do other jobs.
+La forma en que te mostré arriba es como una consulta, Ud., debe estar familiarizado si sabe jQuery. Devuelve objeto ORM original después de las llamadas y sigue haciendo otros trabajos.
 
-The method `SetTable` tells ORM we want to insert our data to table `userinfo`.
+El metodo `SetTable` dice ORM queremos insertar los datos de la tabla `userinfo`.
 
-## Update data
+## Actualización de datos
 
-Continue above example to show how to update data. Now we have primary key value of saveone(Uid), so beedb executes update operation instead of inserting new record.
+Siga el ejemplo anterior para mostrar cómo actualizar datos. Ahora tenemos el valor de clave principal de saveone (UID), por lo que beedb ejecuta operación de actualización en lugar de insertar nuevo registro.
 
 	saveone.Username = "Update Username"
 	saveone.Departname = "Update Departname"
 	saveone.Created = time.Now()
 	orm.Save(&saveone)  // update
 
-You can use map for updating data also:
+Usted puede utilizar map para la actualización de datos también:
 
 	t := make(map[string]interface{})
 	t["username"] = "astaxie"
 	orm.SetTable("userinfo").SetPK("uid").Where(2).Update(t)
 
-Let me explain some methods we used above:
+Voy a explicar algunos de los métodos que hemos utilizado anteriormente:
 
-- `.SetPK()` tells ORM `uid` is the primary key of table `userinfo`.
-- `.Where()` sets conditions, supports multiple arguments, if the first argument is a integer, it's a short form of `Where("<primary key>=?", <value>)`. 
-- `.Update()` method accepts map and update to database.
+- `.SetPK()` le dice a ORM `uid` es la clave principal de la tabla `userinfo`.
+- `.Where()` establece las condiciones, soporta múltiples argumentos, si el primer argumento es un número entero, es una forma corta de dónde `Where("<primary key>=?", <value>)`. 
+- `.Update()` método que acepta map y actualización de base de datos.
 
-## Query data
+## Datos de la consulta
 
-beedb query interface is very flexible, let's see some examples:
+interfaz de consulta beedb es muy flexible, veamos algunos ejemplos:
 
-Example 1, query by primary key:
+Ejemplo 1, consulta por clave principal:
 
 	var user Userinfo
 	// Where accepts two arguments, supports integers
@@ -145,94 +143,93 @@ Example 2:
 	var user2 Userinfo
 	orm.Where(3).Find(&user2) // short form that omits primary key
 
-Example 3, other query conditions:
+Ejemplo 3, otras condiciones de la consulta:
 
 	var user3 Userinfo
 	// Where accepts two arguments, supports char type.
 	orm.Where("name = ?", "john").Find(&user3)
 
-Example 4, more complex conditions:
+Ejemplo 4, las condiciones más complejas:
 
 	var user4 Userinfo
 	// Where accepts three arguments
 	orm.Where("name = ? and age < ?", "john", 88).Find(&user4)
 
-Examples to get multiple records:
+Ejemplos de conseguir varios registros:
 
-Example 1, gets 10 records that `id>3` and starts with position 20:
+Ejemplo 1, recibe 10 registros que id> 3 y se inicia con la posición 20:
 
 	var allusers []Userinfo
 	err := orm.Where("id > ?", "3").Limit(10,20).FindAll(&allusers)
 
-Example 2, omits the second argument of limit, so it starts with 0 and gets 10 records:
+Ejemplo 2, omite el segundo argumento del límite, por lo que empieza con 0 y recibe 10 registros:
 
 	var tenusers []Userinfo
 	err := orm.Where("id > ?", "3").Limit(10).FindAll(&tenusers)
 
-Example 3, gets all records:
+Ejemplo 3, consigue todos los registros:
 
 	var everyone []Userinfo
 	err := orm.OrderBy("uid desc,username asc").FindAll(&everyone)
 
-As you can see, the Limit method is for limiting number of results.
+Como puede ver, el método de límite es para limitar el número de resultados.
 
-- `.Limit()` supports two arguments, which are number of results and start position. 0 is the default value of start position.
-- `.OrderBy()` is for ordering results, the arguments is the order condition.
+- `.Limit()` admite dos argumentos, que son el número de resultados y la posición de inicio. 0 es el valor predeterminado de la posición de inicio.
+- `.OrderBy()` es para ordenar los resultados, que los argumentos es la condición de la orden.
 
-All examples that you see is mapping records to structs, and you can also just put data into map as follows:
+Todos los ejemplos que se ven son registros cartográficos a las estructuras, y también se puede simplemente poner los datos en el map de la siguiente manera:
 
 	a, _ := orm.SetTable("userinfo").SetPK("uid").Where(2).Select("uid,username").FindMap()
 
-- `.Select()` tells beedb how many fields you want to get from database table, returns all fields as default.
-- `.FindMap()` returns type `[]map[string][]byte`, so you need to convert to other types by yourself. 
+- `.Select()` le dice a beedb cuántos campos que desea obtener de la tabla de base de datos, devuelve todos los campos por defecto.
+- `.FindMap()`  devuelve el tipo `[]map[string][]byte`, si necesita para convertir a otros tipos. 
 
-## Delete data
+## Eliminar los datos
 
-beedb provides rich methods to delete data.
+beedb  proporciona muchos métodos para eliminar datos.
 
-Example 1, delete a single record:
+Ejemplo 1, eliminar un solo registro:
 
 	// saveone is the one in above example.
 	orm.Delete(&saveone)
 
-Example 2, delete multiple records:
+Ejemplo 2, eliminar varios registros:
 
 	// alluser is the slice which gets multiple records.
 	orm.DeleteAll(&alluser)
 
-Example 3, delete records by SQL:
+Ejemplo 3, eliminar registros mediante SQL:
 
 	orm.SetTable("userinfo").Where("uid>?", 3).DeleteRow()
 
-## Associated query
+## Consulta asociada
 
-beedb doesn't support joining between structs.
-However since some applications need this feature, here is a  implementation:
+no soporta unión entre estructuras. Sin embargo, ya que algunas aplicaciones necesitan esta característica, aquí esta una implementacion:
 
 	a, _ := orm.SetTable("userinfo").Join("LEFT", "userdetail", "userinfo.uid=userdetail.uid")
 		.Where("userinfo.uid=?", 1).Select("userinfo.uid,userinfo.username,userdetail.profile").FindMap()
 
-We see a new method called `.Join()`, it has three arguments:
+Vemos un nuevo método llamado `.Join()`, tiene tres argumentos:
 
-- The first argument: Type of Join; INNER, LEFT, OUTER, CROSS, etc.
-- The second argument: the table you want to join with.
-- The third argument: join condition.
+- El primer argumento: Tipo  of Join; INNER, LEFT, OUTER, CROSS, etc.
+- El segundo argumento: la tabla que desea que se unan a.
+- El tercer argumento: condición de combinación.
 
 ## Group By and Having
 
-beedb also has a implementation of `group by` and `having`. 
+ también tiene una implementacion `group by` and `having`. 
 
 	a, _ := orm.SetTable("userinfo").GroupBy("username").Having("username='astaxie'").FindMap()
 
-- `.GroupBy()` indicates field that is for group by.
-- `.Having()` indicates conditions of having.
+- `.GroupBy()` indica que el campo es para agrupar.
+- `.Having()` indica las condiciones de tener.
 
-## Future
+## Futuro
 
-I have received many feedback from many people from all around world, and I'm thinking about reconfiguration in following aspects:
+He recibido muchos comentarios de muchas personas de todo el mundo, y estoy pensando en la reconfiguración en los siguientes aspectos:
 
-- Implement interface design like `database/sql/driver` in order to implement corresponding CRUD operations.
-- Implement relational database design, one to one, one to many, many to many, here are some samples:
+- Implementar el diseño de interfaz como `database/sql/driver` con el fin de implementar las operaciones CRUD correspondientes.
+- Implemente el diseño de base de datos relacional, uno a uno, uno a muchos, muchos a muchos, aquí están algunas muestras:
 
 				type Profile struct {
 					Nickname string
@@ -246,8 +243,8 @@ I have received many feedback from many people from all around world, and I'm th
 					Profile     HasOne
 				}
 		 
-- Auto-create table and index.
-- Implement connection pool through goroutine.
+- Auto-crear la tabla y el índice.
+- Implementar pool de conexiones a través goroutine.
 
 ## Links
 

eBook/05.6.md

@@ -1,25 +1,25 @@
 # 5.6 NoSQL database
 
-A NoSQL database provides a mechanism for storage and retrieval of data that use looser consistency models than relational database in order to achieve horizontal scaling and higher availability. Some authors refer to them as "Not only SQL" to emphasize that some NoSQL systems do allow SQL-like query language to be used.
+Una base de datos NoSQL proporciona un mecanismo para el almacenamiento y recuperación de datos que utilizan los modelos de consistencia más flojas que base de datos relacional para lograr la escala horizontal y una mayor disponibilidad. Algunos autores se refieren a ellos como "No sólo SQL" para enfatizar que algunos sistemas NoSQL permiten que el lenguaje de consulta similar a SQL que se utilizará.
 
-As the C language of 21st century, Go has good support for NoSQL databases, and the popular NoSQL database including redis, mongoDB, Cassandra and Membase.
+Como el lenguaje C de siglo 21, Go tiene un buen soporte para bases de datos NoSQL, y la base de datos NoSQL populares incluyendo redis, mongoDB, Cassandra and Membase.
 
 ## redis
 
-redis is a key-value storage system like Memcached, it supports string, list, set and zset(ordered set) as it's value types.
+Redis es un sistema de almacenamiento de conkey-value como Memcached, es compatible con string, list, set and zset(ordered set) ya que evalua tipos.
 
-There are some Go database drivers for redis:
+Hay algunos controladores de base Go para redis:
 
 - [https://github.com/alphazero/Go-Redis](https://github.com/alphazero/Go-Redis)
 - [http://code.google.com/p/tideland-rdc/](http://code.google.com/p/tideland-rdc/)
 - [https://github.com/simonz05/godis](https://github.com/simonz05/godis)
 - [https://github.com/hoisie/redis.go](https://github.com/hoisie/redis.go)
 
-I forked the last one and fixed some bugs, and use it in my short URL service(2 million PV every day).
+He hecho forked al ultimo y corrigiendo algunos bugs lo uso en mi servicio URL(2 million PV every day).
 
 - [https://github.com/astaxie/goredis](https://github.com/astaxie/goredis)
 
-Let's see how to use the driver that I forked to operate database:
+Vamos a ver cómo utilizar el controlador que bifurqué para operar la base de datos:
 
 	package main
 
@@ -52,17 +52,17 @@ Let's see how to use the driver that I forked to operate database:
 		client.Del("l")
 	}
 
-We can see that it's quite easy to operate redis in Go, and it has high performance. Its client commands are almost the same as redis built-in commands.
+Podemos ver que es muy fácil de operar redistribución en Go, y tiene un alto rendimiento. Sus comandos de cliente son casi los mismos que redis incorporados comandos.
 
 ## mongoDB
 
-mongoDB (from "humongous") is an open source document-oriented database system developed and supported by 10gen. It is part of the NoSQL family of database systems. Instead of storing data in tables as is done in a "classical" relational database, MongoDB stores structured data as JSON-like documents with dynamic schemas (MongoDB calls the format BSON), making the integration of data in certain types of applications easier and faster.
+mongoDB (de "descomunal") es un sistema de base de datos orientada a documentos de código abierto desarrollado y apoyado por 10gen. Es parte de la familia de los sistemas de base de datos NoSQL. En lugar de almacenar datos en tablas como se hace en una base de datos relacional "clásica", tiendas de MongoDB datos estructurados como documentos JSON-como con esquemas dinámicos (MongoDB llama al BSON formato), por lo que la integración de datos en ciertos tipos de aplicaciones más fácil y más rápido .
 
 ![](images/5.6.mongodb.png?raw=true)
 
 Figure 5.1 MongoDB compares to Mysql
 
-The best driver for mongoDB is called `mgo`, and it is possible to be in the standard library in the future.
+El mejor controlador para mongoDB se llama  `mgo`, y es posible que este en la librería estándar en el futuro.
 
 Here is the example:
 
@@ -104,8 +104,7 @@ Here is the example:
 	    fmt.Println("Phone:", result.Phone)
 	}
 
-We can see that there is no big different to operate database between mgo and beedb, they are both based on struct, this is what Go style is.
-
+Podemos ver que no hay un diferente grande para operar la base de datos entre MgO y beedb, ambos están basados ​​en estructura, esto es lo que Go estilo es.
 ## Links
 
 - [Directory](preface.md)

eBook/05.7.md

@@ -1,11 +1,11 @@
 # 5.7 Summary
 
-In this chapter, you first learned the design of `database/sql` interface, and many third-party database drivers for different kinds of database. Then I introduced beedb to you, an ORM for relational databases, also showed some samples for operating database. In the end, I talked about some NoSQL databases, I have to see Go gives very good support for those NoSQL databases.
+En este capítulo, primero aprendió el diseño de `database/sql` interfaz, y muchos conductores de bases de datos de terceros para diferentes tipos de base de datos. Entonces me presenté beedb a usted, un ORM para bases de datos relacionales, también mostró algunas muestras para la base de datos de funcionamiento. Al final, he hablado de algunas bases de datos NoSQL, tengo que ver a Go da muy buen soporte para las bases de datos NoSQL.
 
-After read this chapter, I hope you know how to operate databases in Go. This is the most important part in web development, so I want to you completely understand design ideas of `database/sql` interface.
+Después de leer este capítulo, espero que sepas cómo operar bases de datos en Go. Esta es la parte más importante en el desarrollo web, así que quiero que entienda completamente las ideas de diseño de `database/sql` interfaz.
 
 ## Links
 
 - [Directory](preface.md)
 - Previous section: [NoSQL database](05.6.md)
-- Next section: [Data storage and session](06.0.md)
+- Next section: [Data storage and session](06.0.md)