Add comments for sample.{bson,db}

tests/command_open_tests.rs

@@ -30,6 +30,31 @@ fn recognizes_csv() {
     })
 }
 
+// sample.bson has the following format:
+// ━━━━━━━━━━┯━━━━━━━━━━━
+//  _id      │ root
+// ──────────┼───────────
+//  [object] │ [9 items]
+// ━━━━━━━━━━┷━━━━━━━━━━━
+//
+// the root value is:
+// ━━━┯━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━
+//  # │ _id               │ a                       │ b        │ c
+// ───┼───────────────────┼─────────────────────────┼──────────┼──────────
+//  0 │ [object]          │       1.000000000000000 │ hello    │ [2 items]
+//  1 │ [object]          │       42.00000000000000 │ whel     │ hello
+//  2 │ [object]          │ [object]                │          │
+//  3 │ [object]          │                         │ [object] │
+//  4 │ [object]          │                         │          │ [object]
+//  5 │ [object]          │                         │          │ [object]
+//  6 │ [object]          │ [object]                │ [object] │
+//  7 │ [object]          │ <date value>            │ [object] │
+//  8 │ 1.000000          │ <decimal value>         │ [object] │
+//
+// The decimal value is supposed to be π, but is currently wrong due to
+// what appears to be an issue in the bson library that is under investigation.
+//
+
 #[test]
 fn open_can_parse_bson_1() {
     let actual = nu!(
@@ -57,6 +82,55 @@ fn open_can_parse_bson_2() {
     assert_eq!(actual, "function");
 }
 
+// sample.db has the following format:
+//
+// ━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━━━
+//  # │ table_name │ table_values
+// ───┼────────────┼──────────────
+//  0 │ strings    │ [6 items]
+//  1 │ ints       │ [5 items]
+//  2 │ floats     │ [4 items]
+// ━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━━━
+//
+// In this case, this represents a sqlite database
+// with three tables named `strings`, `ints`, and `floats`.
+// The table_values represent the values for the tables:
+//
+// ━━━━┯━━━━━━━┯━━━━━━━━━━┯━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+//  #  │ x     │ y        │ z    │ f
+// ────┼───────┼──────────┼──────┼──────────────────────────────────────────────────────────────────────
+//   0 │ hello │ <binary> │      │
+//   1 │ hello │ <binary> │      │
+//   2 │ hello │ <binary> │      │
+//   3 │ hello │ <binary> │      │
+//   4 │ world │ <binary> │      │
+//   5 │ world │ <binary> │      │
+//   6 │       │          │    1 │
+//   7 │       │          │   42 │
+//   8 │       │          │  425 │
+//   9 │       │          │ 4253 │
+//  10 │       │          │      │
+//  11 │       │          │      │                                                    3.400000000000000
+//  12 │       │          │      │                                                    3.141592650000000
+//  13 │       │          │      │                                                    23.00000000000000
+//  14 │       │          │      │ this string that doesn't really belong here but sqlite is what it is
+// ━━━━┷━━━━━━━┷━━━━━━━━━━┷━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+//
+// We can see here that each table has different columns. `strings` has `x` and `y`, while
+// `ints` has just `z`, and `floats` has only the column `f`. This means, in general, when working
+// with sqlite, one will want to select a single table, e.g.:
+//
+// open sample.db | nth 1 | get table_values
+// ━━━┯━━━━━━
+//  # │ z
+// ───┼──────
+//  0 │    1
+//  1 │   42
+//  2 │  425
+//  3 │ 4253
+//  4 │
+// ━━━┷━━━━━━
+
 #[test]
 fn open_can_parse_sqlite() {
     let actual = nu!(

tests/commands_test.rs

@@ -67,6 +67,9 @@ fn save_can_write_out_csv() {
     })
 }
 
+// This text is more tricky since we are checking for binary output. The output rendered in ASCII is (roughly):
+// <20>authors+0Yehuda Katz <wycats@gmail.com>descriptionA shell for the GitHub eraedition2018licenseISCnamenuversion0.2.0
+// It is not valid utf-8, so this is just an approximation.
 #[test]
 fn save_can_write_out_bson() {
     Playground::setup("save_test_3", |dirs, _| {