Question

So I loock at sqlite3cpp wiki. And thay have such a nice API:

sqlite3pp::command cmd(db, "INSERT INTO contacts (name, phone) VALUES (:user, :phone)");
cmd.bind(":user", "Mike");
cmd.bind(":phone", "555-1234");
cmd.execute();

I wonder how using boost to create API alike it forregular std::string? meaning something like

std::string str = "INSERT INTO contacts (name, phone) VALUES (:user, :phone)";
bind(str, ":user", "Mike");
bind(str, ":phone", "555-1234");

Is it possible to create such thing with boost and how to do it?

Answer 1

Replacing a string is easy, but to perform something that is type-safe and will convert the SQL nicely, is slightly different. We need a binder class that can bind by the type passed and do any necessary conversions.

Firstly, we need to wrap up std::type_info so that it can be used in a hash map:

class typeInfoWrapper
{
friend bool operator == (const typeInfoWrapper& l, const typeInfoWrapper& r);
private:
    const std::type_info& typeInfo_;

public:
    typeInfoWrapper(const std::type_info& info) : typeInfo_(info) { };

    // hasher
    class hash
    {
    public:
        size_t operator()(const typeInfoWrapper& typeInfo) const
        {
            return typeInfo.typeInfo_.hash_code();
        };
    };  // eo class hash
};  // eo class typeInfoWrapper

bool operator == (const typeInfoWrapper& l, const typeInfoWrapper& r)
{
    return l.typeInfo_.hash_code() == r.typeInfo_.hash_code();
}   // eo operator == 

Next, we need the class itself. I’m using C++11 here, so I’m going to use lambdas. For each type we register, we’ll register a function that takes a string and returns it in a format suitable for SQL. In this example, I register one for a string and one for an int. The string one just replaces ' with '' and returns it in quotes itself. The int one just returns itself, no parsing to do for SQL.

class binder
{
private:
    typedef std::function<std::string(std::string&)> ReplaceFunc;
    typedef std::tr1::unordered_map<typeInfoWrapper, ReplaceFunc, typeInfoWrapper::hash> ReplaceMap;
    typedef std::pair<typeInfoWrapper, ReplaceFunc> ReplacePair;
    ReplaceMap typeMap_;

public:
    binder()
    {
        // add string and int for test purposes
        typeMap_.insert(ReplacePair(typeid(const char*), [](std::string& data) -> std::string
        {
            // escape the "'" to prevent SQL injection
            boost::replace_all(data, "'", "''");
            return "'" + data + "'";
        }));

        typeMap_.insert(ReplacePair(typeid(int), [](std::string& data) -> std::string
        {
            // for sql, this is easy, just return the value as is
            return data;
        }));
    };


    // func
    template<class T>
    void bind(std::string& input, const std::string& expr, T data)
    {
        ReplaceMap::const_iterator cit(typeMap_.find(typeid(T)));
        if(cit != typeMap_.end())
            boost::replace_all(input, expr, cit->second(boost::lexical_cast<std::string>(data)));
    };  // eo bind
};  // eo class bind

And as you can see, we have the bind function.

Now we can bind in a type-safe way!

binder b;
std::string data = "SELECT * FROM table WHERE _user = :user AND _id = :id";
b.bind(data, ":user", "Moo-Juice");
b.bind(data, ":id", 32);

EDIT: fixed some errors.