update files 2019年 5月17日 星期五 18时17分33秒 CST

Author: hopher

Diff for: errors.md

@@ -153,6 +153,8 @@ The mechanism to do this varies between drivers, however, because this isn't
 part of `database/sql` itself. In the MySQL driver that this tutorial focuses
 on, you could write the following code:
 
+但是，执行此操作的机制因驱动程序而异，因为这不是 `database/sql` 本身的一部分。在本教程重点介绍的MySQL驱动程序中，您可以编写以下代码：
+
 <pre class="prettyprint lang-go">
 if driverErr, ok := err.(*mysql.MySQLError); ok { // Now the error number is accessible directly
 	if driverErr.Number == 1045 {
@@ -166,6 +168,8 @@ Again, the `MySQLError` type here is provided by this specific driver, and the
 is taken from MySQL's error message, and is therefore database specific, not
 driver specific.
 
+同样，此处的MySQLError类型由此特定驱动程序提供，并且.Number字段可能因驱动程序而异。但是，数字的值取自MySQL的错误消息，因此是特定于数据库的，而不是特定于驱动程序的。
+
 This code is still ugly. Comparing to 1045, a magic number, is a code smell.
 Some drivers (though not the MySQL one, for reasons that are off-topic here)
 provide a list of error identifiers. The Postgres `pq` driver does, for example, in
@@ -187,18 +191,24 @@ Handling Connection Errors
 
 What if your connection to the database is dropped, killed, or has an error?
 
+如果您的数据库连接被丢弃，被杀或有错误怎么办？
+
 You don't need to implement any logic to retry failed statements when this
 happens. As part of the [connection pooling](connection-pool.html) in
 `database/sql`, handling failed connections is built-in. If you execute a query
 or other statement and the underlying connection has a failure, Go will reopen a
 new connection (or just get another from the connection pool) and retry, up to
 10 times.
 
+发生这种情况时，您不需要实现任何逻辑来重试失败的语句。作为 `database/sql` 中连接池的一部分，内置处理失败的连接。如果您执行查询或其他语句并且底层连接出现故障，Go将重新打开一个新连接（或者从连接池中获取另一个连接）并重试最多10次。
+
 There can be some unintended consequences, however. Some types of errors may be
 retried when other error conditions happen. This might also be driver-specific.
 One example that has occurred with the MySQL driver is that using `KILL` to
 cancel an undesired statement (such as a long-running query) results in the
 statement being retried up to 10 times.
 
+但是，可能会产生一些意想不到的后果。当发生其他错误情况时，可能会重试某些类型的错误。这可能也是特定于驱动程序的。 MySQL驱动程序发生的一个例子是使用 `KILL` 取消不需要的语句（例如长时间运行的查询）会导致语句被重试最多10次。
+
 **Previous: [Using Prepared Statements](prepared.html)**
 **Next: [Working with NULLs](nulls.html)**

Diff for: nulls.md

@@ -7,9 +7,13 @@ Nullable columns are annoying and lead to a lot of ugly code. If you can, avoid
 them. If not, then you'll need to use special types from the `database/sql`
 package to handle them, or define your own.
 
+可空列很烦人，导致很多丑陋的代码。如果可以，请避免使用它们。如果没有，那么你需要使用 `database/sql` 包中的特殊类型来处理它们，或者定义你自己的类型。
+
 There are types for nullable booleans, strings, integers, and floats. Here's how
 you use them:
 
+有可空的布尔值，字符串，整数和浮点数的类型。这是你如何使用它们：
+
 <pre class="prettyprint lang-go">
 for rows.Next() {
 	var s sql.NullString
@@ -26,18 +30,28 @@ for rows.Next() {
 Limitations of the nullable types, and reasons to avoid nullable columns in case
 you need more convincing:
 
+可空类型的限制，以及在需要更有说服力的情况下避免可空列的原因：
+
 1. There's no `sql.NullUint64` or `sql.NullYourFavoriteType`. You'd need to
-	define your own for this.
-1. Nullability can be tricky, and not future-proof. If you think something won't
+	define your own for this.  
+   没有 `sql.NullUint64` 或 `sql.NullYourFavoriteType`。你需要为此定义自己的。	
+2. Nullability can be tricky, and not future-proof. If you think something won't
 	be null, but you're wrong, your program will crash, perhaps rarely enough
-	that you won't catch errors before you ship them.
-1. One of the nice things about Go is having a useful default zero-value for
-	every variable. This isn't the way nullable things work.
+	that you won't catch errors before you ship them.  
+   可空性可能很棘手，而且不会出现面向未来的问题。如果您认为某些内容不会为空，但是您错了，那么您的程序将崩溃，或许很少，以至于在发送之前您不会发现错误。
+3. One of the nice things about Go is having a useful default zero-value for
+	every variable. This isn't the way nullable things work.  
+   关于Go的一个好处是为每个变量提供了一个有用的默认零值。这不是可以为空的东西工作的方式。
 
 If you need to define your own types to handle NULLs, you can copy the design of
 `sql.NullString` to achieve that.
 
+如果需要定义自己的类型来处理NULL，可以复制sql.NullString的设计来实现它。
+
 If you can't avoid having NULL values in your database, there is another work around that most database systems support, namely `COALESCE()`. Something like the following might be something that you can use, without introducing a myriad of `sql.Null*` types.
+
+如果您无法避免在数据库中使用NULL值，那么大多数数据库系统都支持另一种解决方法，即 `COALESCE()`。像下面这样的东西可能是你可以使用的东西，而不会引入无数的 `sql.Null*` 类型。
+
 <pre class="prettyprint lang-go">
 rows, err := db.Query(`
 	SELECT