Migrate to csv crate rewrite.0.12.0

This commit resists the urge to refactor/rewrite xsv and ports it over
to the new CSV API. It made a lot of things cleaner and even improved
the performance of core commands like `count`, `sample`, `search`,
`select` and `slice`.

This also removes the last remaining (dubious) uses of `unsafe` within
xsv.

Benchmarks before/after:

    benchmark               before                      after
    count                   0.26s   175.05  MB/sec      0.11   413.76  MB/sec
    flatten                 4.53s   10.04   MB/sec      4.54   10.02   MB/sec
    flatten_condensed       4.72s   9.64    MB/sec      4.45   10.22   MB/sec
    frequency               1.91s   23.82   MB/sec      1.82   25.00   MB/sec
    index                   0.28s   162.54  MB/sec      0.12   379.28  MB/sec
    sample_10               0.43s   105.84  MB/sec      0.18   252.85  MB/sec
    sample_1000             0.44s   103.44  MB/sec      0.18   252.85  MB/sec
    sample_100000           0.50s   91.02   MB/sec      0.29   156.94  MB/sec
    search                  0.59s   77.14   MB/sec      0.27   168.56  MB/sec
    select                  0.41s   111.00  MB/sec      0.14   325.09  MB/sec
    sort                    2.59s   17.57   MB/sec      2.18   20.87   MB/sec
    slice_one_middle        0.22s   206.88  MB/sec      0.08   568.92  MB/sec
    slice_one_middle_index  0.01s   4551.36 MB/sec      0.01   4551.36 MB/sec
    stats                   1.26s   36.12   MB/sec      1.09   41.75   MB/sec
    stats_index             0.19s   239.54  MB/sec      0.15   303.42  MB/sec
    stats_everything        2.13s   21.36   MB/sec      1.94   23.46   MB/sec
    stats_everything_index  1.00s   45.51   MB/sec      0.93   48.93   MB/sec

1 files changed, 19 insertions, 26 deletions

diff --git a/src/cmd/cat.rs b/src/cmd/cat.rs
index d9f3bd8..7e7c1f3 100644
--- a/src/cmd/cat.rs
+++ b/src/cmd/cat.rs
@@ -1,5 +1,3 @@
-use std::iter::repeat;
-
 use csv;
 
 use CliResult;
@@ -52,8 +50,7 @@ struct Args {
 }
 
 pub fn run(argv: &[&str]) -> CliResult<()> {
-    let args: Args = try!(util::get_args(USAGE, argv));
-
+    let args: Args = util::get_args(USAGE, argv)?;
     if args.cmd_rows {
         args.cat_rows()
     } else if args.cmd_columns {
@@ -72,57 +69,53 @@ impl Args {
     }
 
     fn cat_rows(&self) -> CliResult<()> {
-        let mut wtr = try!(Config::new(&self.flag_output).writer());
-        for (i, conf) in try!(self.configs()).into_iter().enumerate() {
-            let mut rdr = try!(conf.reader());
+        let mut wtr = Config::new(&self.flag_output).writer()?;
+        for (i, conf) in self.configs()?.into_iter().enumerate() {
+            let mut rdr = conf.reader()?;
             if i == 0 {
-                try!(conf.write_headers(&mut rdr, &mut wtr));
+                conf.write_headers(&mut rdr, &mut wtr)?;
             }
             for r in rdr.byte_records() {
-                try!(wtr.write(try!(r).into_iter()));
+                wtr.write_record(&r?)?;
             }
         }
         wtr.flush().map_err(From::from)
     }
 
     fn cat_columns(&self) -> CliResult<()> {
-        let mut wtr = try!(Config::new(&self.flag_output).writer());
-        let mut rdrs = try!(try!(self.configs())
-                                .into_iter()
-                                .map(|conf| conf.no_headers(true).reader())
-                                .collect::<Result<Vec<_>, _>>());
+        let mut wtr = Config::new(&self.flag_output).writer()?;
+        let mut rdrs = self.configs()?
+            .into_iter()
+            .map(|conf| conf.no_headers(true).reader())
+            .collect::<Result<Vec<_>, _>>()?;
 
         // Find the lengths of each record. If a length varies, then an error
         // will occur so we can rely on the first length being the correct one.
-        let mut lengths = vec!();
+        let mut lengths = vec![];
         for rdr in &mut rdrs {
-            lengths.push(try!(rdr.byte_headers()).len());
+            lengths.push(rdr.byte_headers()?.len());
         }
 
         let mut iters = rdrs.iter_mut()
                             .map(|rdr| rdr.byte_records())
                             .collect::<Vec<_>>();
         'OUTER: loop {
-            let mut records: Vec<Vec<csv::ByteString>> = vec!();
+            let mut record = csv::ByteRecord::new();
             let mut num_done = 0;
             for (iter, &len) in iters.iter_mut().zip(lengths.iter()) {
                 match iter.next() {
                     None => {
                         num_done += 1;
                         if self.flag_pad {
-                            // This can probably be optimized by
-                            // pre-allocating. It would avoid the intermediate
-                            // `Vec`.
-                            records.push(
-                                repeat(util::empty_field())
-                                .take(len)
-                                .collect());
+                            for _ in 0..len {
+                                record.push_field(b"");
+                            }
                         } else {
                             break 'OUTER;
                         }
                     }
                     Some(Err(err)) => return fail!(err),
-                    Some(Ok(next)) => records.push(next),
+                    Some(Ok(next)) => record.extend(&next),
                 }
             }
             // Only needed when `--pad` is set.
@@ -131,7 +124,7 @@ impl Args {
             if num_done >= iters.len() {
                 break 'OUTER;
             }
-            try!(wtr.write(records.concat().into_iter()));
+            wtr.write_record(&record)?;
         }
         wtr.flush().map_err(From::from)
     }