SqlDatabase.h

#ifndef ROSE_SqlDatabase_H
#define ROSE_SqlDatabase_H

#include <Rose/FormatRestorer.h>
#include "Rose/Exception.h"
#include <Rose/StringUtility.h>
#include "rose_override.h"

#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>

#include <cassert>
#include <iomanip>
#include <stdexcept>
#include <stdint.h>
#include <string>
#include <sstream>
#include <vector>

namespace SqlDatabase {

enum Driver {
    NO_DRIVER,                  
    SQLITE3,                    
    POSTGRESQL                  
};


/*******************************************************************************************************************************
 *                                      Forwards and types
 *******************************************************************************************************************************/

class Connection;
class ConnectionImpl;
class Transaction;
class TransactionImpl;
class Statement;
class StatementImpl;

typedef boost::shared_ptr<Connection> ConnectionPtr;

typedef boost::shared_ptr<Transaction> TransactionPtr;

typedef boost::shared_ptr<Statement> StatementPtr;

// Data type used in templates to indicate lack of a column
class NoColumn {};

/*******************************************************************************************************************************
 *                                      Exceptions
 *******************************************************************************************************************************/

class Exception: public Rose::Exception {
public:
    explicit Exception(const char *mesg): Rose::Exception(mesg) {}
    explicit Exception(const std::string &mesg): Rose::Exception(mesg) {}
    explicit Exception(const std::string &mesg, const ConnectionPtr &conn, const TransactionPtr &tx,
                       const StatementPtr &stmt)
        : Rose::Exception(mesg), connection(conn), transaction(tx), statement(stmt) {}

    virtual ~Exception() throw() {}
    virtual const char *what() const throw() ROSE_OVERRIDE;
    void print(std::ostream&) const;
    ConnectionPtr connection;
    TransactionPtr transaction;
    StatementPtr statement;
private:
    mutable std::string what_str;       // backing store for what()
};


/*******************************************************************************************************************************
 *                                      Connections
 *******************************************************************************************************************************/

class Connection: public boost::enable_shared_from_this<Connection> {
    friend class TransactionImpl;
    friend class Transaction;
    friend class StatementImpl;
public:
    typedef std::pair<std::string /*name*/, std::string /*value*/> Parameter;

    struct ParsedUrl {
        Driver driver;                                  // database low-level driver
        std::string dbName;                             // main part of URL -- database name or maybe a file name
        std::vector<Parameter> params;                  // stuff after the last "?"
        std::string error;                              // error message if there was a problem parsing

        ParsedUrl()
            : driver(NO_DRIVER) {}
    };
    
    static ConnectionPtr create(const std::string &open_spec, Driver driver=NO_DRIVER) {
        if (NO_DRIVER==driver) {
            if (NO_DRIVER==(driver = guess_driver(open_spec)))
                throw Exception("no suitable driver for \""+open_spec+"\"");
        }
        return ConnectionPtr(new Connection(open_spec, driver));
    }

    TransactionPtr transaction();

    static Driver guess_driver(const std::string &open_spec);

    Driver driver() const;

    std::string openspec() const;

    void set_debug(FILE *f);
    FILE *get_debug() const;
    void print(std::ostream&) const;

    // Only called by boost::shared_ptr
    ~Connection() { finish(); }

    static std::string connectionSpecification(const std::string &uri, Driver driver = NO_DRIVER);

    static ParsedUrl parseUrl(std::string url);

protected:
    // Protected because you should be using create() to get a smart pointer.  Database driver-level connections are typically
    // not copyable object anyway.
    Connection(const std::string &open_spec, Driver driver): impl(NULL) { init(open_spec, driver); }

private:
    void init(const std::string &open_spec, Driver driver);
    void finish();

private:
    ConnectionImpl *impl;
};

/*******************************************************************************************************************************
 *                                      Transactions
 *******************************************************************************************************************************/

class Transaction: public boost::enable_shared_from_this<Transaction> {
    friend class ConnectionImpl;
    friend class Statement;
    friend class StatementImpl;
public:
    static TransactionPtr create(const ConnectionPtr &conn);

    void rollback();

    void commit();

    bool is_terminated() const;

    StatementPtr statement(const std::string &sql);

    void execute(const std::string &sql);

    void bulk_load(const std::string &tablename, std::istream&);

    Driver driver() const;

    ConnectionPtr connection() const;

    void set_debug(FILE *f);
    FILE *get_debug() const;
    void print(std::ostream&) const;

    // Only called by boost::shared_ptr
    ~Transaction() { finish(); }

protected:
    explicit Transaction(const ConnectionPtr &conn, size_t drv_conn): impl(NULL) { init(conn, drv_conn); }

private:
    void init(const ConnectionPtr &conn, size_t drv_conn);
    void finish();

private:
    TransactionImpl *impl;
};


/*******************************************************************************************************************************
 *                                      Statements
 *******************************************************************************************************************************/

class Statement: public boost::enable_shared_from_this<Statement> {
public:

    static StatementPtr create(const TransactionPtr &tranx, const std::string &sql) {
        return StatementPtr(new Statement(tranx, sql));
    }

    class iterator {
    public:
        iterator(): execution_seq(0), row_num(0) { init(); } // an end iterator
        iterator(const StatementPtr &stmt, size_t execution_seq)
            : stmt(stmt), execution_seq(execution_seq), row_num(0) { init(); }
        template<typename T> T get(size_t idx);
        int32_t get_i32(size_t idx);
        int64_t get_i64(size_t idx);
        uint32_t get_u32(size_t idx);
        uint64_t get_u64(size_t idx);
        double get_dbl(size_t idx);
        std::string get_str(size_t idx);
        std::vector<uint8_t> get_blob(size_t idx);
        iterator& operator++();
        bool at_eof() const;
        bool operator==(const iterator &other) const;
        bool operator!=(const iterator &other) const { return !(*this==other); }
    private:
        void init();
        void check() const;                     // check that this iterator is not stale
    private:
        StatementPtr stmt;                      // statement whose results we are iterating over
        size_t execution_seq;                   // statement execution counter
        size_t row_num;                         // row number
    };

    StatementPtr bind(size_t idx, int32_t val);
    StatementPtr bind(size_t idx, int64_t val);
    StatementPtr bind(size_t idx, uint32_t val);
    StatementPtr bind(size_t idx, uint64_t val);
    StatementPtr bind(size_t idx, double val);
    StatementPtr bind(size_t idx, const std::string &val);
    StatementPtr bind(size_t idx, const std::vector<uint8_t> &val);
    StatementPtr bind_null(size_t idx);
    iterator begin();

    iterator end() { return iterator(); }

    void execute();

    int execute_int();

    double execute_double();

    std::string execute_string();
    
    std::vector<uint8_t> execute_blob();

    Driver driver() const;

    TransactionPtr transaction() const;

    void set_debug(FILE *f);
    FILE *get_debug() const;
    void print(std::ostream&) const;

public:
    // Called only by boost::shared_ptr
    ~Statement() { finish(); }

protected:
    Statement(const TransactionPtr &tranx, const std::string &sql): impl(NULL) { init(tranx, sql); }

private:
    void init(const TransactionPtr &tranx, const std::string &sql);
    void finish();

private:
    StatementImpl *impl;
};

template<> NoColumn Statement::iterator::get<NoColumn>(size_t idx);
template<> int64_t Statement::iterator::get<int64_t>(size_t idx);
template<> uint64_t Statement::iterator::get<uint64_t>(size_t idx);
template<> int32_t Statement::iterator::get<int32_t>(size_t idx);
template<> uint32_t Statement::iterator::get<uint32_t>(size_t idx);
template<> float Statement::iterator::get<float>(size_t idx);
template<> double Statement::iterator::get<double>(size_t idx);
template<> std::string Statement::iterator::get<std::string>(size_t idx);

/*******************************************************************************************************************************
 *                                      Miscellaneous functions
 *******************************************************************************************************************************/

std::string uriDocumentation();

std::vector<std::string> split_sql(const std::string &sql);

std::string escape(const std::string&, Driver, bool do_quote=true);

std::string hexSequence(const std::vector<uint8_t> &v, Driver driver);

bool is_valid_table_name(const std::string &name);

template<class Container>
std::string in(const Container &values)
{
    std::ostringstream retval;
    retval <<"in (";
    unsigned nvals = 0;
    for (typename Container::const_iterator vi=values.begin(); vi!=values.end(); ++vi, ++nvals)
        retval <<(nvals?", ":"") <<*vi;
    retval <<")";
    return retval.str();
}

template<class Container, class Stringifier>
std::string in_numbers(const Container &values, Stringifier &stringifier)
{
    return "in (" + Rose::StringUtility::join(", ", Rose::StringUtility::toStrings(values, stringifier)) + ")";
}

template<class Container>
std::string in_strings(const Container &values, Driver driver)
{
    std::vector<std::string> strings;
    for (typename Container::const_iterator vi=values.begin(); vi!=values.end(); ++vi)
        strings.push_back(escape(*vi, driver));
    return in(strings);
}

std::ostream& operator<<(std::ostream&, const NoColumn&);
std::ostream& operator<<(std::ostream&, const Exception&);
std::ostream& operator<<(std::ostream&, const Connection&);
std::ostream& operator<<(std::ostream&, const Transaction&);
std::ostream& operator<<(std::ostream&, const Statement&);

/*******************************************************************************************************************************
 *                                      Tables
 *******************************************************************************************************************************/

// The things here that don't have doxygen comments are not intended to be used directly by users.

template<typename> struct ColumnTraits {
    enum { valid_column = 1 };
};
template<> struct ColumnTraits<NoColumn> {
    enum { valid_column = 0 };
};

template<typename T>
class Renderer {
public:
    virtual ~Renderer() {}

    virtual std::string operator()(const T &value, size_t width) const {
        std::ostringstream ss;
        ss <<value;
        return ss.str();
    }
};

// Specialized for string-valued columns in order to left-justify the string by padding it on the right with an
// appropriate number of SPC characters.
template<>
class Renderer<std::string> {
public:
    virtual ~Renderer() {}
    virtual std::string operator()(const std::string &value, size_t width) const {
        return value + std::string(width, ' ');
    }
};

struct AddrRenderer: Renderer<uint64_t> {
    size_t nbits; // number of bits in addresses; higher addresses will result in more digits
    explicit AddrRenderer(size_t nbits=32): nbits(nbits) {}
    virtual std::string operator()(const uint64_t &value, size_t width) const ROSE_OVERRIDE {
        return Rose::StringUtility::addrToString(value, nbits);
    }
};
extern AddrRenderer addr8Renderer;              
extern AddrRenderer addr16Renderer;             
extern AddrRenderer addr32Renderer;             
extern AddrRenderer addr64Renderer;             
struct TimeRenderer: Renderer<time_t> {
    bool local_tz;              
    std::string format;         
    TimeRenderer(): local_tz(true), format("%F %T %z") {}
    explicit TimeRenderer(const std::string &format, bool local_tz=true): local_tz(local_tz), format(format) {}
    virtual std::string operator()(const time_t &value, size_t width) const ROSE_OVERRIDE;
};
extern TimeRenderer timeRenderer;               
extern TimeRenderer dateRenderer;               
extern TimeRenderer humanTimeRenderer;          
template<typename Table>
class PrePostRow {
public:
    virtual ~PrePostRow() {}
    virtual void operator()(std::ostream &out, const Table *table, size_t rownum, const std::vector<size_t> &widths) {}
};

// Prints a header
template<typename T>
class Header {
public:
    void operator()(std::ostream &out, const std::string &prefix, const std::string &hdr, size_t width) {
        FormatRestorer fr(out);
        out <<prefix <<std::setw(width) <<hdr;
    }
};
template<>
class Header<std::string> {
public:
    void operator()(std::ostream &out, const std::string &prefix, const std::string &hdr, size_t width) {
        FormatRestorer fr(out);
        out <<prefix <<std::setw(width) <<std::left <<hdr;
    }
};
template<>
class Header<NoColumn> {
public:
    void operator()(std::ostream &out, const std::string &prefix, const std::string &hdr, size_t width) {}
};

// Prints a row separator for a single column
template<typename T>
class RowSeparator {
public:
    void operator()(std::ostream &out, const std::string &prefix, size_t width) {
        out <<prefix <<std::string(width, '-');
    }
};
template<>
class RowSeparator<NoColumn> {
public:
    void operator()(std::ostream &out, const std::string &prefix, size_t width) {}
};

template<typename T00,          typename T01=NoColumn, typename T02=NoColumn, typename T03=NoColumn,
         typename T04=NoColumn, typename T05=NoColumn, typename T06=NoColumn, typename T07=NoColumn,
         typename T08=NoColumn, typename T09=NoColumn, typename T10=NoColumn, typename T11=NoColumn,
         typename T12=NoColumn, typename T13=NoColumn, typename T14=NoColumn, typename T15=NoColumn>
class Table {
public:
    enum {
        MAXCOLS=16,             
    };

    struct Tuple { // We could use boost::tuple, but it has a 10-member limit.
        explicit Tuple(const T00 &v0,        const T01 &v1 =T01(), const T02 &v2 =T02(), const T03 &v3 =T03(),
                       const T04 &v4 =T04(), const T05 &v5 =T05(), const T06 &v6 =T06(), const T07 &v7 =T07(),
                       const T08 &v8 =T08(), const T09 &v9 =T09(), const T10 &v10=T10(), const T11 &v11=T11(),
                       const T12 &v12=T12(), const T13 &v13=T13(), const T14 &v14=T14(), const T15 &v15=T15())
            : v0(v0), v1(v1), v2(v2),   v3(v3),   v4(v4),   v5(v5),   v6(v6),   v7(v7),
              v8(v8), v9(v9), v10(v10), v11(v11), v12(v12), v13(v13), v14(v14), v15(v15) {}
        T00 v0; T01 v1; T02 v2;  T03 v3;  T04 v4;  T05 v5;  T06 v6;  T07 v7;
        T08 v8; T09 v9; T10 v10; T11 v11; T12 v12; T13 v13; T14 v14; T15 v15;
    };

    struct Renderers { // We could use boost::tuple, but it has a 10-member limit.
        explicit Renderers(const Renderer<T00> *r0 =NULL, const Renderer<T01> *r1 =NULL,
                           const Renderer<T02> *r2 =NULL, const Renderer<T03> *r3 =NULL,
                           const Renderer<T04> *r4 =NULL, const Renderer<T05> *r5 =NULL,
                           const Renderer<T06> *r6 =NULL, const Renderer<T07> *r7 =NULL,
                           const Renderer<T08> *r8 =NULL, const Renderer<T09> *r9 =NULL,
                           const Renderer<T10> *r10=NULL, const Renderer<T11> *r11=NULL,
                           const Renderer<T12> *r12=NULL, const Renderer<T13> *r13=NULL,
                           const Renderer<T14> *r14=NULL, const Renderer<T15> *r15=NULL)
            : r0(r0), r1(r1), r2(r2),   r3(r3),   r4(r4),   r5(r5),   r6(r6),   r7(r7),
              r8(r8), r9(r9), r10(r10), r11(r11), r12(r12), r13(r13), r14(r14), r15(r15) {}
        const Renderer<T00> *r0;  const Renderer<T01> *r1;  const Renderer<T02> *r2;  const Renderer<T03> *r3;
        const Renderer<T04> *r4;  const Renderer<T05> *r5;  const Renderer<T06> *r6;  const Renderer<T07> *r7;
        const Renderer<T08> *r8;  const Renderer<T09> *r9;  const Renderer<T10> *r10; const Renderer<T11> *r11;
        const Renderer<T12> *r12; const Renderer<T13> *r13; const Renderer<T14> *r14; const Renderer<T15> *r15;
    };

    typedef std::vector<Tuple> Rows;

    Table(): headers_(MAXCOLS), colsep_(" | "), pre_row_(NULL), post_row_(NULL), reprint_headers_(0) {}

    explicit Table(const StatementPtr &stmt)
        : headers_(MAXCOLS), colsep_(" | "), pre_row_(NULL), post_row_(NULL), reprint_headers_(0) {
        insert(stmt);
    }

    void header(int colnum, const std::string &hdr) {
        assert(colnum<headers_.size());
        headers_[colnum] = hdr;
    }
    const std::string& header(int colnum) const {
        assert(colnum<headers_.size());
        return headers_[colnum];
    }
    void headers(const std::string &h0,     const std::string &h1="",  const std::string &h2="",  const std::string &h3="",
                 const std::string &h4="",  const std::string &h5="",  const std::string &h6="",  const std::string &h7="",
                 const std::string &h8="",  const std::string &h9="",  const std::string &h10="", const std::string &h11="",
                 const std::string &h12="", const std::string &h13="", const std::string &h14="", const std::string &h15="") {
        headers_[ 0] = h0;  headers_[ 1] = h1;  headers_[ 2] = h2;  headers_[ 3] = h3;
        headers_[ 4] = h4;  headers_[ 5] = h5;  headers_[ 6] = h6;  headers_[ 7] = h7;
        headers_[ 8] = h8;  headers_[ 9] = h9;  headers_[10] = h10; headers_[11] = h11;
        headers_[12] = h12; headers_[13] = h13; headers_[14] = h14; headers_[15] = h15;
    }
    void reprint_headers(size_t nrows) { reprint_headers_ = nrows; }
    size_t reprint_headers() const { return reprint_headers_; }
    Renderers& renderers() { return render_; }
    const Renderers& renderers() const { return render_; }
    void prepost(PrePostRow<Table> *pre, PrePostRow<Table> *post) {
        pre_row_ = pre;
        post_row_ = post;
    }
    std::pair<PrePostRow<Table>*, PrePostRow<Table>*> prepost() const {
        return std::make_pair(pre_row_, post_row_);
    }
    size_t size() const { return rows_.size(); }

    bool empty() const { return rows_.empty(); }

    void clear() { rows_.clear(); }

    Tuple& operator[](size_t i) { assert(i<rows_.size()); return rows_[i]; }
    const Tuple& operator[](size_t i) const { assert(i<rows_.size()); return rows_[i]; }
    void insert(const Tuple &tuple) { rows_.push_back(tuple); }
    void insert(const T00 &v00,       const T01 &v01=T01(), const T02 &v02=T02(), const T03 &v03=T03(),
                const T04 &v04=T04(), const T05 &v05=T05(), const T06 &v06=T06(), const T07 &v07=T07(),
                const T08 &v08=T08(), const T09 &v09=T09(), const T10 &v10=T10(), const T11 &v11=T11(),
                const T12 &v12=T12(), const T13 &v13=T13(), const T14 &v14=T14(), const T15 &v15=T15()) {
        rows_.push_back(Tuple(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15));
    }
    void insert(const StatementPtr &stmt) {
        for (Statement::iterator row=stmt->begin(); row!=stmt->end(); ++row) {
            rows_.push_back(Tuple(row.get<T00>( 0), row.get<T01>( 1), row.get<T02>( 2), row.get<T03>( 3),
                                  row.get<T04>( 4), row.get<T05>( 5), row.get<T06>( 6), row.get<T07>( 7),
                                  row.get<T08>( 8), row.get<T09>( 9), row.get<T10>(10), row.get<T11>(11),
                                  row.get<T12>(12), row.get<T13>(13), row.get<T14>(14), row.get<T15>(15)));
        }
    }

    void line_prefix(const std::string &s) { prefix_ = s; }
    const std::string& line_prefix() const { return prefix_; }
    template<typename T>
    std::string render(const Renderer<T> *r, const T &value, size_t width=0) const {
        Renderer<T> r_;
        if (NULL==r)
            r = &r_;
        std::string s = (*r)(value, width);
        if (width!=0)
            s = s.substr(0, width);
        return s;
    }

    std::vector<size_t> colsizes() const {
        std::vector<size_t> widths(MAXCOLS, 0);
        for (typename Rows::const_iterator ri=rows_.begin(); ri!=rows_.end(); ++ri) {
            widths[ 0] = std::max(widths[ 0], render(render_.r0,  ri->v0 ).size());
            widths[ 1] = std::max(widths[ 1], render(render_.r1,  ri->v1 ).size());
            widths[ 2] = std::max(widths[ 2], render(render_.r2,  ri->v2 ).size());
            widths[ 3] = std::max(widths[ 3], render(render_.r3,  ri->v3 ).size());
            widths[ 4] = std::max(widths[ 4], render(render_.r4,  ri->v4 ).size());
            widths[ 5] = std::max(widths[ 5], render(render_.r5,  ri->v5 ).size());
            widths[ 6] = std::max(widths[ 6], render(render_.r6,  ri->v6 ).size());
            widths[ 7] = std::max(widths[ 7], render(render_.r7,  ri->v7 ).size());
            widths[ 8] = std::max(widths[ 8], render(render_.r8,  ri->v8 ).size());
            widths[ 9] = std::max(widths[ 9], render(render_.r9,  ri->v9 ).size());
            widths[10] = std::max(widths[10], render(render_.r10, ri->v10).size());
            widths[11] = std::max(widths[11], render(render_.r11, ri->v11).size());
            widths[12] = std::max(widths[12], render(render_.r12, ri->v12).size());
            widths[13] = std::max(widths[13], render(render_.r13, ri->v13).size());
            widths[14] = std::max(widths[14], render(render_.r14, ri->v14).size());
            widths[15] = std::max(widths[15], render(render_.r15, ri->v15).size());
        }
        return widths;
    }

    void print_headers(std::ostream &out, const std::vector<size_t> &widths) const {
        Header<T00>()(out, prefix_, headers_[ 0], widths[ 0]);
        Header<T01>()(out, colsep_, headers_[ 1], widths[ 1]);
        Header<T02>()(out, colsep_, headers_[ 2], widths[ 2]);
        Header<T03>()(out, colsep_, headers_[ 3], widths[ 3]);
        Header<T04>()(out, colsep_, headers_[ 4], widths[ 4]);
        Header<T05>()(out, colsep_, headers_[ 5], widths[ 5]);
        Header<T06>()(out, colsep_, headers_[ 6], widths[ 6]);
        Header<T07>()(out, colsep_, headers_[ 7], widths[ 7]);
        Header<T08>()(out, colsep_, headers_[ 8], widths[ 8]);
        Header<T09>()(out, colsep_, headers_[ 9], widths[ 9]);
        Header<T10>()(out, colsep_, headers_[10], widths[10]);
        Header<T11>()(out, colsep_, headers_[11], widths[11]);
        Header<T12>()(out, colsep_, headers_[12], widths[12]);
        Header<T13>()(out, colsep_, headers_[13], widths[13]);
        Header<T14>()(out, colsep_, headers_[14], widths[14]);
        Header<T15>()(out, colsep_, headers_[15], widths[15]);
        out <<"\n";
    }

    void print_rowsep(std::ostream &out, const std::vector<size_t> &widths) const {
        std::string colsep = colsep_;
        for (size_t i=0; i<colsep.size(); ++i) {
            if (isspace(colsep[i])) {
                colsep[i] = '-';
            } else if ('|'==colsep[i]) {
                colsep[i] = '+';
            }
        }
        RowSeparator<T00>()(out, prefix_, widths[ 0]);
        RowSeparator<T01>()(out, colsep,  widths[ 1]);
        RowSeparator<T02>()(out, colsep,  widths[ 2]);
        RowSeparator<T03>()(out, colsep,  widths[ 3]);
        RowSeparator<T04>()(out, colsep,  widths[ 4]);
        RowSeparator<T05>()(out, colsep,  widths[ 5]);
        RowSeparator<T06>()(out, colsep,  widths[ 6]);
        RowSeparator<T07>()(out, colsep,  widths[ 7]);
        RowSeparator<T08>()(out, colsep,  widths[ 8]);
        RowSeparator<T09>()(out, colsep,  widths[ 9]);
        RowSeparator<T10>()(out, colsep,  widths[10]);
        RowSeparator<T11>()(out, colsep,  widths[11]);
        RowSeparator<T12>()(out, colsep,  widths[12]);
        RowSeparator<T13>()(out, colsep,  widths[13]);
        RowSeparator<T14>()(out, colsep,  widths[14]);
        RowSeparator<T15>()(out, colsep,  widths[15]);
        out <<"\n";
    }

    void
    print_row(std::ostream &out, const Tuple &t, const std::vector<size_t> &widths) const {
        FormatRestorer fr(out);
        out <<                                   prefix_       <<std::setw(widths[ 0]) <<render(render_.r0,  t.v0,  widths[ 0])
            <<(ColumnTraits<T01>::valid_column ? colsep_ : "") <<std::setw(widths[ 1]) <<render(render_.r1,  t.v1,  widths[ 1])
            <<(ColumnTraits<T02>::valid_column ? colsep_ : "") <<std::setw(widths[ 2]) <<render(render_.r2,  t.v2,  widths[ 2])
            <<(ColumnTraits<T03>::valid_column ? colsep_ : "") <<std::setw(widths[ 3]) <<render(render_.r3,  t.v3,  widths[ 3])
            <<(ColumnTraits<T04>::valid_column ? colsep_ : "") <<std::setw(widths[ 4]) <<render(render_.r4,  t.v4,  widths[ 4])
            <<(ColumnTraits<T05>::valid_column ? colsep_ : "") <<std::setw(widths[ 5]) <<render(render_.r5,  t.v5,  widths[ 5])
            <<(ColumnTraits<T06>::valid_column ? colsep_ : "") <<std::setw(widths[ 6]) <<render(render_.r6,  t.v6,  widths[ 6])
            <<(ColumnTraits<T07>::valid_column ? colsep_ : "") <<std::setw(widths[ 7]) <<render(render_.r7,  t.v7,  widths[ 7])
            <<(ColumnTraits<T08>::valid_column ? colsep_ : "") <<std::setw(widths[ 8]) <<render(render_.r8,  t.v8,  widths[ 8])
            <<(ColumnTraits<T09>::valid_column ? colsep_ : "") <<std::setw(widths[ 9]) <<render(render_.r9,  t.v9,  widths[ 9])
            <<(ColumnTraits<T10>::valid_column ? colsep_ : "") <<std::setw(widths[10]) <<render(render_.r10, t.v10, widths[10])
            <<(ColumnTraits<T11>::valid_column ? colsep_ : "") <<std::setw(widths[11]) <<render(render_.r11, t.v11, widths[11])
            <<(ColumnTraits<T12>::valid_column ? colsep_ : "") <<std::setw(widths[12]) <<render(render_.r12, t.v12, widths[12])
            <<(ColumnTraits<T13>::valid_column ? colsep_ : "") <<std::setw(widths[13]) <<render(render_.r13, t.v13, widths[13])
            <<(ColumnTraits<T14>::valid_column ? colsep_ : "") <<std::setw(widths[14]) <<render(render_.r14, t.v14, widths[14])
            <<(ColumnTraits<T15>::valid_column ? colsep_ : "") <<std::setw(widths[15]) <<render(render_.r15, t.v15, widths[15])
            <<"\n";
    }

    void print(std::ostream &out) const {
        std::vector<size_t> widths = colsizes();

        // Headers
        bool has_headers = false;
        for (size_t i=0; i<MAXCOLS; ++i) {
            widths[i] = std::max(widths[i], headers_[i].size());
            if (!headers_[i].empty())
                has_headers = true;
        }
        if (has_headers) {
            print_headers(out, widths);
            print_rowsep(out, widths);
        }

        // Body
        if (rows_.empty()) {
            out <<prefix_ <<"(0 rows)\n\n";
        } else {
            for (size_t i=0; i<rows_.size(); ++i) {
                if (i>0 && has_headers && reprint_headers_>0 && 0==i%reprint_headers_) {
                    print_rowsep(out, widths);
                    print_headers(out, widths);
                    print_rowsep(out, widths);
                }
                if (pre_row_)
                    (*pre_row_)(out, this, i, widths);
                print_row(out, rows_[i], widths);
                if (post_row_)
                    (*post_row_)(out, this, i, widths);
            }
        }

        // Epilogue
        if (has_headers && !rows_.empty())
            print_rowsep(out, widths);
    }

private:
    std::vector<std::string> headers_;
    Renderers render_;
    Rows rows_;
    std::string colsep_;
    PrePostRow<Table> *pre_row_, *post_row_;
    size_t reprint_headers_;
    std::string prefix_;                        // string printed before every line of output
};

} // namespace
#endif