select.cc

This examples expects a SQL select statement as well as the number of columns returned from that statement as argument and will fetch and print the result of the select statement to stdout. Since we need to fetch more then one row we must implement a SQLFetcher derivation. The PrintFetcher class from the example does so. It basically implements a process() which prints out the record's columns delimted by '|'.

The main method itself looks very similar to the one shown in the selectrow.cc example. The only difference is the additional command line parameter and the PrintFetcher class.

You can compile this example with the following command:

c++ -I../ -L../.libs -lResourcePool -lrt -o select select.cc 

in the examples directory of the distribution (after building the library).

To gain a better understanding what is happening in the background, you may choose to enable all logging:

export FATALMIND_DEFAULT_LOGEVENTS=ALL 

Unfortunately this example shows also a limitation:

• Since there is currently no way to retrieve metadata for a SQL statement, the user must supply the number of columns. If a wrong number is specified, an exception will be thrown during execution.

#include <iostream>
#include <iomanip>
#include <sstream>
#include <iterator>
#include "ResourcePool/ResourcePoolStreamLogger.hh"
#include "ResourcePool/SQL/ResourcePool.hh"
                                          /* define the resource type to use */
typedef fatalmind::ResourcePool<fatalmind::ResourceType::SQL> RP;

using fatalmind::ResourcePoolOptions;
using fatalmind::ResourcePoolStreamLogger;

int parseString(char*);

class PrintFetcher: public fatalmind::SQL::SQLFetcher {
    struct columnDescriptor {
        std::string value;
        bool        isnull;
        int         width;
        columnDescriptor() 
        : value()
        , isnull(false)
        , width(0)
        {
        }
    };

    public:
        PrintFetcher(int c) 
        : columns(c)
        , row(columns)
        {
            /* calls the string's default c-tor n-times */
            row.resize(columns);
        };

        void bindout(fatalmind::SQL::BindOutInterface& cmd) {
            for (int i = 0; i < columns; ++i) {
                columnDescriptor& c = row[i];
                cmd.bindout(i, c.value, c.isnull);
            }
        }

        bool process(int rownum) {
            std::cout << "|  ";
            row_t::const_iterator e = row.end();    
            for (row_t::iterator i = row.begin(); i != e; ++i) {
                columnDescriptor& c = *i;
                if (! c.isnull) {
                    int len = c.value.length();
                    c.width = std::max(len, c.width);
                    std::cout << std::setw(c.width) << c.value << "  |  ";
                } else {
                    std::cout << "|  ";
                }
            }
            std::cout << std::endl;
            return true;
        }

        void done(bool more, int fetched) {
            std::cout << std::endl << (more ? "": "all ") << fetched << " row" << (fetched != 1 ? "s":"") << " fetched." <<std::endl << std::endl;
        }
    private:
        int columns;
        typedef std::vector<columnDescriptor> row_t;
        row_t row;
};

int main(int argc, char* argv[]) {
    try {
        if (argc < 4) {                   /* just some minimalistic checking */
            throw fatalmind::Exception("arguments missing: driver:logon no-columns SQL");
        }
        ResourcePoolStreamLogger logger(std::cerr); /* log events to std::cerr */
        RP::Factory f(argv[1], logger);           /* pass the arguments to the factory */
        RP p(f, ResourcePoolOptions::defaultOptions);  /* create a resource pool */
                          /* Use the default options, but a custom logger */
                          /* Initialize a PrintFetcher for the specified number of columns */
        PrintFetcher fetch(parseString(argv[2]));
                          /* pass the SQL and the Fetcher to the SQLSelect class */ 
        RP::Commands::SQLSelect select(p, argv[3], fetch);
        fetch.bindout(select);            /* let the PrintFetcher bind the output parameters */
    
        p.execute(select);                /* execute the SQL */
    } catch (fatalmind::Exception e) {    /* if you provide missing/wrong data */
        std::cout << "An error happend: " << e.message() << std::endl;
    }
}

int parseString(char* param) {
    std::istringstream is(param);
    int rv;
    is >> rv;
    if (is.fail() || rv < 1) {
        throw fatalmind::Exception("Illegal argument (need numeric number of columns)");
    }
    return rv;
}

---