re-added index

Author: arnehormann

_includes/leftnav.html

@@ -1,7 +1,14 @@
 <div class="leftnav">
   <ul class="nav nav-list">
 {% for group in page.nav %}
-    <li class="nav-header">{{ group.name }}</li>
+  {% capture group_url %}/{{ page.name }}/{{ group.url }}{% endcapture %}
+  <li class="nav-header{% if page.url == node_url %} active{% endif %}">
+    {% if page.url %}
+      <a href="{{group.url}}">{{group.name}}</a>
+    {% else %}
+      {{group.name}}
+    {% endif %}
+  </li>
   {% for node in group.articles %}
     {% capture node_url %}/{{ page.name }}/{{ node.url }}{% endcapture %}
     {% if page.url == node_url %}

_layouts/article.html

@@ -4,6 +4,7 @@
 nav:
 -
   name: Overview
+  url: index.html
   articles:
   -
     title: Overview of Go's database/sql Package

importing.md

@@ -15,8 +15,8 @@ changes. It also forces you to use the Go idioms instead of ad-hoc idioms that a
 particular driver author may have provided.
 
 In this documentation, we'll use the excellent [MySQL
-drivers](https://github.com/go-sql-driver/mysql) from @arnehormann and
-@julienschmidt for examples.
+drivers](https://github.com/go-sql-driver/mysql) from @julienschmidt and @arnehormann
+ for examples.
 
 Add the following to the top of your Go source file:
 

index.md

@@ -1,32 +1,17 @@
 ---
 layout: article
-title: Overview
+title: Go database/sql tutorial
 ---
 
-To access databases in Go, you use a `sql.DB`. You use this type to create
-statements and transactions, execute queries, and fetch results.
+The idiomatic way to use a SQL, or SQL-like, database in Go is through the
+[database/sql package](http://golang.org/pkg/database/sql/).  It provides a
+lightweight interface to a row-oriented database. This website is a
+reference for the most common aspects of how to use it.
 
-The first thing you should know is that **a `sql.DB` isn't a database
-connection**. It also doesn't map to any particular database software's notion
-of a "database" or "schema." It's an abstraction of the interface and existence
-of a database, which might be as varied as a local file, accessed through a network
-connection, or in-memory and in-process.
+Why is this needed? The package's documentation tells you what everything does,
+but it doesn't tell you how to use the package. Many of us find ourselves
+wishing for a quick-reference and a "getting started" orientation that tells
+stories instead of listing facts. Contributions are welcome; please send pull
+requests [here](https://github.com/VividCortex/go-database-sql-tutorial).
 
-The `sql.DB` performs some important tasks for you behind the scenes:
-
-* It opens and closes connections to the actual underlying database, via the driver.
-* It manages a pool of connections as needed, which may be a variety of things as mentioned.
-
-The `sql.DB` abstraction is designed to keep you from worrying about how to
-manage concurrent access to the underlying datastore.  A connection is marked
-in-use when you use it to perform a task, and then returned to the available
-pool when it's not in use anymore. One consequence of this is that **if you fail
-to release connections back to the pool, you can cause `db.SQL` to open a lot of
-connections**, potentially running out of resources (too many connections, too
-many open file handles, lack of available network ports, etc). We'll discuss
-more about this later.
-
-After creating a `sql.DB`, you can use it to query the database that it
-represents, as well as creating statements and transactions.
-
-**Next: [Importing a Database Driver](importing.html)**
+**Start: [Overview of Go's database/sql Package](overview.html)**

overview.md

@@ -0,0 +1,32 @@
+---
+layout: article
+title: Overview
+---
+
+To access databases in Go, you use a `sql.DB`. You use this type to create
+statements and transactions, execute queries, and fetch results.
+
+The first thing you should know is that **a `sql.DB` isn't a database
+connection**. It also doesn't map to any particular database software's notion
+of a "database" or "schema." It's an abstraction of the interface and existence
+of a database, which might be as varied as a local file, accessed through a network
+connection, or in-memory and in-process.
+
+The `sql.DB` performs some important tasks for you behind the scenes:
+
+* It opens and closes connections to the actual underlying database, via the driver.
+* It manages a pool of connections as needed, which may be a variety of things as mentioned.
+
+The `sql.DB` abstraction is designed to keep you from worrying about how to
+manage concurrent access to the underlying datastore.  A connection is marked
+in-use when you use it to perform a task, and then returned to the available
+pool when it's not in use anymore. One consequence of this is that **if you fail
+to release connections back to the pool, you can cause `db.SQL` to open a lot of
+connections**, potentially running out of resources (too many connections, too
+many open file handles, lack of available network ports, etc). We'll discuss
+more about this later.
+
+After creating a `sql.DB`, you can use it to query the database that it
+represents, as well as creating statements and transactions.
+
+**Next: [Importing a Database Driver](importing.html)**