mapnik/utils/pgsql2sqlite/sqlite.hpp

/*****************************************************************************
 * 
 * This file is part of Mapnik (c++ mapping toolkit)
 *
 * Copyright (C) 2009 Artem Pavlenko
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *****************************************************************************/
//$Id$

// boost
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <boost/variant.hpp>
//sqlite3
#include <sqlite3.h>

//stl
//#ifdef MAPNIK_DEBUG
#include <iostream>         
//#endif
#include <string>
#include <vector>

namespace mapnik {  namespace sqlite {

      class database : private boost::noncopyable
      {
         friend class prepared_statement;
         
         struct database_closer
         {
            void operator () (sqlite3 * db)
            {
#ifdef MAPNIK_DEBUG
               std::cerr << "close database " << db << "\n";
#endif
               sqlite3_close(db);
            }
         };
         
         typedef boost::shared_ptr<sqlite3> sqlite_db;    
         sqlite_db db_;
         
      public:
         database(std::string const& name);
         ~database();
         bool execute(std::string const& sql);
      };

      struct null_type {};
      struct blob 
      {
         blob(const char* buf, unsigned size)
            : buf_(buf), size_(size) {}
         
         const char * buf_;
         unsigned size_;
      };

      typedef boost::variant<int,double,std::string, blob,null_type> value_type;
      typedef std::vector<value_type> record_type;
      
      class prepared_statement : boost::noncopyable 
      {
         struct binder : public boost::static_visitor<bool>
         {
            binder(sqlite3_stmt * stmt, unsigned index)
               : stmt_(stmt), index_(index) {}
  
	    bool operator() (null_type )
	    {
	       if (sqlite3_bind_null(stmt_, index_) != SQLITE_OK)
               {
                  std::cerr << "cannot bind NULL\n";
                  return false;
               }
               return true;
	    }
	    
            bool operator() (int val)
            {
               if (sqlite3_bind_int(stmt_, index_ , val ) != SQLITE_OK)
               {
                  std::cerr << "cannot bind " << val << "\n";
                  return false;
               }
               return true;
            }
            
            bool operator() (double val)
            {
               if (sqlite3_bind_double(stmt_, index_ , val ) != SQLITE_OK)
               {
                  std::cerr << "cannot bind " << val << "\n";
                  return false;
               }
               return true;
            }
            
            bool operator() (std::string const& val)
            {
               if (sqlite3_bind_text(stmt_, index_, val.c_str(), val.length(), SQLITE_STATIC) != SQLITE_OK)
               {
                 std::cerr << "cannot bind " << val << "\n";
                 return false;
               }
               return true;
            }
            
            bool operator() (blob const& val)
            {
               if (sqlite3_bind_blob(stmt_, index_, val.buf_, val.size_, SQLITE_STATIC) != SQLITE_OK)
               {
                 std::cerr << "cannot bind BLOB\n";
                 return false;
               }
               return true;
            }
            
            sqlite3_stmt * stmt_;
            unsigned index_;
         };
      public:
         prepared_statement(database & db, std::string const& sql)
            : db_(db.db_.get()), stmt_(0)
         {
            const char * tail;
            //char * err_msg;
            int res = sqlite3_prepare_v2(db_, sql.c_str(),-1, &stmt_,&tail);
            if (res != SQLITE_OK)
            {
               std::cerr << "ERR:"<< res << "\n";   
               throw;
            }
         }
         
         ~prepared_statement()
         {
	    int res = sqlite3_finalize(stmt_);
            if (res != SQLITE_OK)
            {
               std::cerr << "ERR:" << res << "\n";     
            }
         }
         
         bool insert_record(record_type const& rec) const
         {  
#ifdef MAPNIK_DEBUG
            assert( unsigned(sqlite3_bind_parameter_count(stmt_)) == rec.size());
#endif
            record_type::const_iterator itr = rec.begin();
            record_type::const_iterator end = rec.end();
            int count = 1;
            for (; itr!=end;++itr)
            {
               binder op(stmt_,count++);
               if (!boost::apply_visitor(op,*itr))
               {
                  return false;
               }
            }
            
            sqlite3_step(stmt_);
            sqlite3_reset(stmt_);

            return true;
         }

      private:
         sqlite3 * db_;
         sqlite3_stmt * stmt_;
      };
   }
}