sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

- aligned coding style in sqlite plugin

Browse source
This commit is contained in:
kunitoki 2011-10-22 14:50:24 +02:00
parent f1460b78cd
commit c0273234b6
5 changed files with 178 additions and 192 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

126
plugins/input/sqlite/sqlite_datasource.cpp
View file

@ -2,7 +2,7 @@
* *
* This file is part of Mapnik (c++ mapping toolkit) * This file is part of Mapnik (c++ mapping toolkit)
* *
* Copyright (C) 2010 Artem Pavlenko * Copyright (C) 2011 Artem Pavlenko
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
*****************************************************************************/ *****************************************************************************/
// $Id$
#include "sqlite_datasource.hpp" #include "sqlite_datasource.hpp"
#include "sqlite_featureset.hpp" #include "sqlite_featureset.hpp"
@ -27,9 +26,7 @@
// mapnik // mapnik
#include <mapnik/ptree_helpers.hpp> #include <mapnik/ptree_helpers.hpp>
#include <mapnik/sql_utils.hpp> #include <mapnik/sql_utils.hpp>
#include <mapnik/feature_factory.hpp> // to enable extent fallback hack
// to enable extent fallback hack
#include <mapnik/feature_factory.hpp>
// boost // boost
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
@ -39,15 +36,9 @@
#include <boost/filesystem/operations.hpp> #include <boost/filesystem/operations.hpp>
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
using boost::lexical_cast; using boost::lexical_cast;
using boost::bad_lexical_cast; using boost::bad_lexical_cast;
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(sqlite_datasource)
using mapnik::box2d; using mapnik::box2d;
using mapnik::coord2d; using mapnik::coord2d;
using mapnik::query; using mapnik::query;
@ -55,31 +46,34 @@ using mapnik::featureset_ptr;
using mapnik::layer_descriptor; using mapnik::layer_descriptor;
using mapnik::attribute_descriptor; using mapnik::attribute_descriptor;
using mapnik::datasource_exception; using mapnik::datasource_exception;
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(sqlite_datasource)
sqlite_datasource::sqlite_datasource(parameters const& params, bool bind) sqlite_datasource::sqlite_datasource(parameters const& params, bool bind)
: datasource(params), : datasource(params),
extent_(), extent_(),
extent_initialized_(false), extent_initialized_(false),
type_(datasource::Vector), type_(datasource::Vector),
table_(*params_.get<std::string>("table","")), table_(*params_.get<std::string>("table", "")),
fields_(*params_.get<std::string>("fields","*")), fields_(*params_.get<std::string>("fields", "*")),
metadata_(*params_.get<std::string>("metadata","")), metadata_(*params_.get<std::string>("metadata", "")),
geometry_table_(*params_.get<std::string>("geometry_table","")), geometry_table_(*params_.get<std::string>("geometry_table", "")),
geometry_field_(*params_.get<std::string>("geometry_field","")), geometry_field_(*params_.get<std::string>("geometry_field", "")),
index_table_(*params_.get<std::string>("index_table","")), index_table_(*params_.get<std::string>("index_table", "")),
key_field_(*params_.get<std::string>("key_field","")), key_field_(*params_.get<std::string>("key_field", "")),
row_offset_(*params_.get<int>("row_offset",0)), row_offset_(*params_.get<int>("row_offset", 0)),
row_limit_(*params_.get<int>("row_limit",0)), row_limit_(*params_.get<int>("row_limit", 0)),
desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding","utf-8")), desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
format_(mapnik::wkbAuto) format_(mapnik::wkbAuto)
{ {
// TODO // TODO
// - change param from 'file' to 'dbname' // - change param from 'file' to 'dbname'
// - ensure that the supplied key_field is a valid "integer primary key" // - ensure that the supplied key_field is a valid "integer primary key"
boost::optional<std::string> file = params_.get<std::string>("file"); boost::optional<std::string> file = params_.get<std::string>("file");
if (!file) throw datasource_exception("Sqlite Plugin: missing <file> parameter"); if (! file) throw datasource_exception("Sqlite Plugin: missing <file> parameter");
if (table_.empty()) if (table_.empty())
{ {
@ -144,27 +138,27 @@ void sqlite_datasource::bind() const
boost::optional<std::string> attachdb = params_.get<std::string>("attachdb"); boost::optional<std::string> attachdb = params_.get<std::string>("attachdb");
if (attachdb) if (attachdb)
{ {
parse_attachdb(*attachdb); parse_attachdb(*attachdb);
} }
boost::optional<std::string> initdb = params_.get<std::string>("initdb"); boost::optional<std::string> initdb = params_.get<std::string>("initdb");
if (initdb) if (initdb)
{ {
init_statements_.push_back(*initdb); init_statements_.push_back(*initdb);
} }
if (!boost::filesystem::exists(dataset_name_)) if (!boost::filesystem::exists(dataset_name_))
throw datasource_exception("Sqlite Plugin: " + dataset_name_ + " does not exist"); throw datasource_exception("Sqlite Plugin: " + dataset_name_ + " does not exist");
dataset_ = new sqlite_connection (dataset_name_); dataset_ = new sqlite_connection(dataset_name_);
// Execute init_statements_ // Execute init_statements_
for (std::vector<std::string>::const_iterator iter = init_statements_.begin(); for (std::vector<std::string>::const_iterator iter = init_statements_.begin();
iter != init_statements_.end(); ++iter) iter != init_statements_.end(); ++iter)
{ {
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: Execute init sql: " << *iter << std::endl; std::clog << "Sqlite Plugin: Execute init sql: " << *iter << std::endl;
#endif #endif
dataset_->execute(*iter); dataset_->execute(*iter);
} }
@ -197,10 +191,10 @@ void sqlite_datasource::bind() const
boost::scoped_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str())); boost::scoped_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
if (rs->is_valid() && rs->step_next()) if (rs->is_valid() && rs->step_next())
{ {
for (int i = 0; i < rs->column_count (); ++i) for (int i = 0; i < rs->column_count(); ++i)
{ {
const int type_oid = rs->column_type (i); const int type_oid = rs->column_type(i);
const char* fld_name = rs->column_name (i); const char* fld_name = rs->column_name(i);
switch (type_oid) switch (type_oid)
{ {
case SQLITE_INTEGER: case SQLITE_INTEGER:
@ -233,9 +227,9 @@ void sqlite_datasource::bind() const
break; break;
default: default:
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: unknown type_oid=" << type_oid << std::endl; std::clog << "Sqlite Plugin: unknown type_oid=" << type_oid << std::endl;
#endif #endif
break; break;
} }
} }
@ -252,13 +246,15 @@ void sqlite_datasource::bind() const
if (key_field_.empty()) if (key_field_.empty())
{ {
use_pragma_table_info = true; use_pragma_table_info = true;
} }
else else
{ {
// TODO - we can't trust so much the rowid here // TODO - we can't trust so much the rowid here
if (key_field_ == "rowid") if (key_field_ == "rowid")
desc_.add_descriptor(attribute_descriptor("rowid", mapnik::Integer)); {
desc_.add_descriptor(attribute_descriptor("rowid", mapnik::Integer));
}
} }
if (use_pragma_table_info) if (use_pragma_table_info)
@ -325,7 +321,7 @@ void sqlite_datasource::bind() const
desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String)); desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String));
} }
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
else else
{ {
// "Column Affinity" says default to "Numeric" but for now we pass.. // "Column Affinity" says default to "Numeric" but for now we pass..
@ -338,7 +334,7 @@ void sqlite_datasource::bind() const
<< "' unhandled due to unknown type: " << "' unhandled due to unknown type: "
<< fld_type << std::endl; << fld_type << std::endl;
} }
#endif #endif
} }
if (! found_table) if (! found_table)
@ -377,12 +373,12 @@ void sqlite_datasource::bind() const
{ {
has_spatial_index_ = true; has_spatial_index_ = true;
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
else else
{ {
std::clog << "SQLite Plugin: rtree index lookup did not succeed: '" << sqlite3_errmsg(*(*dataset_)) << "'\n"; std::clog << "SQLite Plugin: rtree index lookup did not succeed: '" << sqlite3_errmsg(*(*dataset_)) << "'\n";
} }
#endif #endif
} }
if (! metadata_.empty() && ! extent_initialized_) if (! metadata_.empty() && ! extent_initialized_)
@ -399,7 +395,7 @@ void sqlite_datasource::bind() const
double xmax = rs->column_double (2); double xmax = rs->column_double (2);
double ymax = rs->column_double (3); double ymax = rs->column_double (3);
extent_.init (xmin,ymin,xmax,ymax); extent_.init (xmin, ymin, xmax, ymax);
extent_initialized_ = true; extent_initialized_ = true;
} }
} }
@ -421,10 +417,10 @@ void sqlite_datasource::bind() const
double ymin = lexical_cast<double>(rs->column_double(1)); double ymin = lexical_cast<double>(rs->column_double(1));
double xmax = lexical_cast<double>(rs->column_double(2)); double xmax = lexical_cast<double>(rs->column_double(2));
double ymax = lexical_cast<double>(rs->column_double(3)); double ymax = lexical_cast<double>(rs->column_double(3));
extent_.init (xmin,ymin,xmax,ymax); extent_.init(xmin, ymin, xmax, ymax);
extent_initialized_ = true; extent_initialized_ = true;
} }
catch (bad_lexical_cast &ex) catch (bad_lexical_cast& ex)
{ {
std::clog << boost::format("SQLite Plugin: warning: could not determine extent from query: %s\nError was: '%s'\n") % s.str() % ex.what() << std::endl; std::clog << boost::format("SQLite Plugin: warning: could not determine extent from query: %s\nError was: '%s'\n") % s.str() % ex.what() << std::endl;
} }
@ -503,7 +499,7 @@ void sqlite_datasource::bind() const
while (rs->is_valid() && rs->step_next()) while (rs->is_valid() && rs->step_next())
{ {
int size; int size;
const char* data = (const char *) rs->column_blob (0, size); const char* data = (const char*) rs->column_blob(0, size);
if (data) if (data)
{ {
// create a tmp feature to be able to parse geometry // create a tmp feature to be able to parse geometry
@ -534,8 +530,8 @@ void sqlite_datasource::bind() const
{ {
std::ostringstream type_error; std::ostringstream type_error;
type_error << "Sqlite Plugin: invalid type for key field '" type_error << "Sqlite Plugin: invalid type for key field '"
<< key_field_ << "' when creating index '" << index_table_ << key_field_ << "' when creating index '" << index_table_
<< "' type was: " << type_oid << ""; << "' type was: " << type_oid << "";
throw datasource_exception(type_error.str()); throw datasource_exception(type_error.str());
} }
@ -680,24 +676,24 @@ int sqlite_datasource::type() const
box2d<double> sqlite_datasource::envelope() const box2d<double> sqlite_datasource::envelope() const
{ {
if (!is_bound_) bind(); if (! is_bound_) bind();
return extent_; return extent_;
} }
layer_descriptor sqlite_datasource::get_descriptor() const layer_descriptor sqlite_datasource::get_descriptor() const
{ {
if (!is_bound_) bind(); if (! is_bound_) bind();
return desc_; return desc_;
} }
featureset_ptr sqlite_datasource::features(query const& q) const featureset_ptr sqlite_datasource::features(query const& q) const
{ {
if (!is_bound_) bind(); if (! is_bound_) bind();
if (dataset_) if (dataset_)
{ {
mapnik::box2d<double> const& e = q.get_bbox(); mapnik::box2d<double> const& e = q.get_bbox();
std::ostringstream s; std::ostringstream s;
@ -752,10 +748,10 @@ featureset_ptr sqlite_datasource::features(query const& q) const
s << " OFFSET " << row_offset_; s << " OFFSET " << row_offset_;
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: table: " << table_ << "\n\n"; std::clog << "Sqlite Plugin: table: " << table_ << "\n\n";
std::clog << "Sqlite Plugin: query:" << s.str() << "\n\n"; std::clog << "Sqlite Plugin: query:" << s.str() << "\n\n";
#endif #endif
boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str())); boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
@ -771,12 +767,12 @@ featureset_ptr sqlite_datasource::features(query const& q) const
featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
{ {
if (!is_bound_) bind(); if (! is_bound_) bind();
if (dataset_) if (dataset_)
{ {
// TODO - need tolerance // TODO - need tolerance
mapnik::box2d<double> const e(pt.x,pt.y,pt.x,pt.y); mapnik::box2d<double> const e(pt.x, pt.y, pt.x, pt.y);
std::ostringstream s; std::ostringstream s;
s << "SELECT " << geometry_field_ << "," << key_field_; s << "SELECT " << geometry_field_ << "," << key_field_;
@ -795,7 +791,7 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
s << " FROM "; s << " FROM ";
std::string query (table_); std::string query(table_);
if (has_spatial_index_) if (has_spatial_index_)
{ {
@ -826,9 +822,9 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
s << " OFFSET " << row_offset_; s << " OFFSET " << row_offset_;
} }
#ifdef MAPNIK_DEBUG #ifdef MAPNIK_DEBUG
std::clog << "Sqlite Plugin: " << s.str() << std::endl; std::clog << "Sqlite Plugin: " << s.str() << std::endl;
#endif #endif
boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str())); boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));

77
plugins/input/sqlite/sqlite_datasource.hpp
View file

@ -2,7 +2,7 @@
* *
* This file is part of Mapnik (c++ mapping toolkit) * This file is part of Mapnik (c++ mapping toolkit)
* *
* Copyright (C) 2007 Artem Pavlenko * Copyright (C) 2011 Artem Pavlenko
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
*****************************************************************************/ *****************************************************************************/
//$Id$
#ifndef SQLITE_DATASOURCE_HPP #ifndef SQLITE_DATASOURCE_HPP
#define SQLITE_DATASOURCE_HPP #define SQLITE_DATASOURCE_HPP
@ -38,47 +37,45 @@
#include "sqlite_types.hpp" #include "sqlite_types.hpp"
//==============================================================================
class sqlite_datasource : public mapnik::datasource class sqlite_datasource : public mapnik::datasource
{ {
public: public:
sqlite_datasource(mapnik::parameters const& params, bool bind=true); sqlite_datasource(mapnik::parameters const& params, bool bind = true);
virtual ~sqlite_datasource (); virtual ~sqlite_datasource ();
int type() const; int type() const;
static std::string name(); static std::string name();
mapnik::featureset_ptr features(mapnik::query const& q) const; mapnik::featureset_ptr features(mapnik::query const& q) const;
mapnik::featureset_ptr features_at_point(mapnik::coord2d const& pt) const; mapnik::featureset_ptr features_at_point(mapnik::coord2d const& pt) const;
mapnik::box2d<double> envelope() const; mapnik::box2d<double> envelope() const;
mapnik::layer_descriptor get_descriptor() const; mapnik::layer_descriptor get_descriptor() const;
void bind() const; void bind() const;
private:
mutable mapnik::box2d<double> extent_;
mutable bool extent_initialized_;
int type_;
mutable std::string dataset_name_;
mutable sqlite_connection* dataset_;
std::string table_;
std::string fields_;
std::string metadata_;
mutable std::string geometry_table_;
mutable std::string geometry_field_;
mutable std::string index_table_;
mutable std::string key_field_;
mutable int row_offset_;
mutable int row_limit_;
mutable mapnik::layer_descriptor desc_;
mutable mapnik::wkbFormat format_;
mutable bool multiple_geometries_;
mutable bool use_spatial_index_;
mutable bool has_spatial_index_;
mutable bool using_subquery_;
mutable std::vector<std::string> init_statements_;
// Fill init_statements with any statements private:
// needed to attach auxillary databases mutable mapnik::box2d<double> extent_;
void parse_attachdb(std::string const& attachdb) const; mutable bool extent_initialized_;
int type_;
mutable std::string dataset_name_;
mutable sqlite_connection* dataset_;
std::string table_;
std::string fields_;
std::string metadata_;
mutable std::string geometry_table_;
mutable std::string geometry_field_;
mutable std::string index_table_;
mutable std::string key_field_;
mutable int row_offset_;
mutable int row_limit_;
mutable mapnik::layer_descriptor desc_;
mutable mapnik::wkbFormat format_;
mutable bool multiple_geometries_;
mutable bool use_spatial_index_;
mutable bool has_spatial_index_;
mutable bool using_subquery_;
mutable std::vector<std::string> init_statements_;
// Fill init_statements with any statements
// needed to attach auxillary databases
void parse_attachdb(std::string const& attachdb) const;
}; };
#endif // SQLITE_DATASOURCE_HPP #endif // SQLITE_DATASOURCE_HPP

29
plugins/input/sqlite/sqlite_featureset.cpp
View file

@ -2,7 +2,7 @@
* *
* This file is part of Mapnik (c++ mapping toolkit) * This file is part of Mapnik (c++ mapping toolkit)
* *
* Copyright (C) 2007 Artem Pavlenko * Copyright (C) 2011 Artem Pavlenko
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
*****************************************************************************/ *****************************************************************************/
//$Id$
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
@ -49,35 +48,37 @@ sqlite_featureset::sqlite_featureset(boost::shared_ptr<sqlite_resultset> rs,
mapnik::wkbFormat format, mapnik::wkbFormat format,
bool multiple_geometries, bool multiple_geometries,
bool using_subquery) bool using_subquery)
: rs_(rs), : rs_(rs),
tr_(new transcoder(encoding)), tr_(new transcoder(encoding)),
format_(format), format_(format),
multiple_geometries_(multiple_geometries), multiple_geometries_(multiple_geometries),
using_subquery_(using_subquery) using_subquery_(using_subquery)
{ {
} }
sqlite_featureset::~sqlite_featureset() {} sqlite_featureset::~sqlite_featureset()
{
}
feature_ptr sqlite_featureset::next() feature_ptr sqlite_featureset::next()
{ {
if (rs_->is_valid () && rs_->step_next ()) if (rs_->is_valid () && rs_->step_next ())
{ {
int size; int size;
const char* data = (const char *) rs_->column_blob (0, size); const char* data = (const char*) rs_->column_blob(0, size);
if (! data) if (! data)
{ {
return feature_ptr(); return feature_ptr();
} }
int feature_id = rs_->column_integer (1); int feature_id = rs_->column_integer(1);
feature_ptr feature(feature_factory::create(feature_id)); feature_ptr feature(feature_factory::create(feature_id));
geometry_utils::from_wkb(feature->paths(), data, size, multiple_geometries_, format_); geometry_utils::from_wkb(feature->paths(), data, size, multiple_geometries_, format_);
for (int i = 2; i < rs_->column_count (); ++i) for (int i = 2; i < rs_->column_count(); ++i)
{ {
const int type_oid = rs_->column_type (i); const int type_oid = rs_->column_type(i);
const char* fld_name = rs_->column_name(i); const char* fld_name = rs_->column_name(i);
if (! fld_name) if (! fld_name)
@ -95,13 +96,13 @@ feature_ptr sqlite_featureset::next()
{ {
case SQLITE_INTEGER: case SQLITE_INTEGER:
{ {
boost::put(*feature, fld_name_str, rs_->column_integer (i)); boost::put(*feature, fld_name_str, rs_->column_integer(i));
break; break;
} }
case SQLITE_FLOAT: case SQLITE_FLOAT:
{ {
boost::put(*feature, fld_name_str, rs_->column_double (i)); boost::put(*feature, fld_name_str, rs_->column_double(i));
break; break;
} }

35
plugins/input/sqlite/sqlite_featureset.hpp
View file

@ -2,7 +2,7 @@
* *
* This file is part of Mapnik (c++ mapping toolkit) * This file is part of Mapnik (c++ mapping toolkit)
* *
* Copyright (C) 2007 Artem Pavlenko * Copyright (C) 2011 Artem Pavlenko
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -19,7 +19,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
*****************************************************************************/ *****************************************************************************/
//$Id$
#ifndef SQLITE_FEATURESET_HPP #ifndef SQLITE_FEATURESET_HPP
#define SQLITE_FEATURESET_HPP #define SQLITE_FEATURESET_HPP
@ -37,25 +36,23 @@
#include "sqlite_types.hpp" #include "sqlite_types.hpp"
//==============================================================================
class sqlite_featureset : public mapnik::Featureset class sqlite_featureset : public mapnik::Featureset
{ {
public: public:
sqlite_featureset(boost::shared_ptr<sqlite_resultset> rs, sqlite_featureset(boost::shared_ptr<sqlite_resultset> rs,
std::string const& encoding, std::string const& encoding,
mapnik::wkbFormat format, mapnik::wkbFormat format,
bool multiple_geometries, bool multiple_geometries,
bool using_subquery); bool using_subquery);
virtual ~sqlite_featureset(); virtual ~sqlite_featureset();
mapnik::feature_ptr next(); mapnik::feature_ptr next();
private:
boost::shared_ptr<sqlite_resultset> rs_; private:
boost::scoped_ptr<mapnik::transcoder> tr_; boost::shared_ptr<sqlite_resultset> rs_;
mapnik::wkbFormat format_; boost::scoped_ptr<mapnik::transcoder> tr_;
bool multiple_geometries_; mapnik::wkbFormat format_;
bool using_subquery_; bool multiple_geometries_;
bool using_subquery_;
}; };
#endif // SQLITE_FEATURESET_HPP #endif // SQLITE_FEATURESET_HPP

101
plugins/input/sqlite/sqlite_types.hpp
View file

@ -2,7 +2,7 @@
* *
* This file is part of Mapnik (c++ mapping toolkit) * This file is part of Mapnik (c++ mapping toolkit)
* *
* Copyright (C) 2007 Artem Pavlenko * Copyright (C) 2011 Artem Pavlenko
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -19,13 +19,12 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
*****************************************************************************/ *****************************************************************************/
//$Id$
#ifndef SQLITE_TYPES_HPP #ifndef SQLITE_TYPES_HPP
#define SQLITE_TYPES_HPP #define SQLITE_TYPES_HPP
// stdc++ // stl
#include <string.h> #include <cstring>
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
@ -40,32 +39,25 @@ extern "C" {
} }
//==============================================================================
class sqlite_utils class sqlite_utils
{ {
public: public:
static void dequote(std::string& z)
static void dequote(std::string & z)
{ {
boost::algorithm::trim_if(z,boost::algorithm::is_any_of("[]'\"`")); boost::algorithm::trim_if(z, boost::algorithm::is_any_of("[]'\"`"));
} }
}; };
//==============================================================================
class sqlite_resultset class sqlite_resultset
{ {
public: public:
sqlite_resultset(sqlite3_stmt* stmt)
sqlite_resultset (sqlite3_stmt* stmt)
: stmt_(stmt) : stmt_(stmt)
{ {
} }
~sqlite_resultset () virtual ~sqlite_resultset()
{ {
if (stmt_) if (stmt_)
{ {
@ -73,14 +65,14 @@ public:
} }
} }
bool is_valid () bool is_valid()
{ {
return stmt_ != 0; return stmt_ != 0;
} }
bool step_next () bool step_next()
{ {
const int status = sqlite3_step (stmt_); const int status = sqlite3_step(stmt_);
if (status != SQLITE_ROW && status != SQLITE_DONE) if (status != SQLITE_ROW && status != SQLITE_DONE)
{ {
std::ostringstream s; std::ostringstream s;
@ -97,56 +89,56 @@ public:
return status == SQLITE_ROW; return status == SQLITE_ROW;
} }
int column_count () int column_count()
{ {
return sqlite3_column_count (stmt_); return sqlite3_column_count(stmt_);
} }
int column_type (int col) int column_type(int col)
{ {
return sqlite3_column_type (stmt_, col); return sqlite3_column_type(stmt_, col);
} }
const char* column_name (int col) const char* column_name(int col)
{ {
return sqlite3_column_name (stmt_, col); return sqlite3_column_name(stmt_, col);
} }
bool column_isnull (int col) bool column_isnull(int col)
{ {
return sqlite3_column_type (stmt_, col) == SQLITE_NULL; return sqlite3_column_type(stmt_, col) == SQLITE_NULL;
} }
int column_integer (int col) int column_integer(int col)
{ {
return sqlite3_column_int (stmt_, col); return sqlite3_column_int(stmt_, col);
} }
int column_integer64 (int col) int column_integer64(int col)
{ {
return sqlite3_column_int64 (stmt_, col); return sqlite3_column_int64(stmt_, col);
} }
double column_double (int col) double column_double(int col)
{ {
return sqlite3_column_double (stmt_, col); return sqlite3_column_double(stmt_, col);
} }
const char* column_text (int col, int& len) const char* column_text(int col, int& len)
{ {
len = sqlite3_column_bytes (stmt_, col); len = sqlite3_column_bytes(stmt_, col);
return (const char*) sqlite3_column_text (stmt_, col); return (const char*) sqlite3_column_text(stmt_, col);
} }
const char* column_text (int col) const char* column_text(int col)
{ {
return (const char*) sqlite3_column_text (stmt_, col); return (const char*) sqlite3_column_text(stmt_, col);
} }
const void* column_blob (int col, int& bytes) const void* column_blob(int col, int& bytes)
{ {
bytes = sqlite3_column_bytes (stmt_, col); bytes = sqlite3_column_bytes(stmt_, col);
return (const char*) sqlite3_column_blob (stmt_, col); return (const char*) sqlite3_column_blob(stmt_, col);
} }
sqlite3_stmt* get_statement() sqlite3_stmt* get_statement()
@ -160,13 +152,11 @@ private:
}; };
//==============================================================================
class sqlite_connection class sqlite_connection
{ {
public: public:
sqlite_connection (const std::string& file) sqlite_connection(const std::string& file)
: db_(0) : db_(0)
{ {
// sqlite3_open_v2 is available earlier but // sqlite3_open_v2 is available earlier but
@ -175,28 +165,28 @@ public:
const int rc = sqlite3_enable_shared_cache(1); const int rc = sqlite3_enable_shared_cache(1);
if (rc != SQLITE_OK) if (rc != SQLITE_OK)
{ {
throw mapnik::datasource_exception (sqlite3_errmsg (db_)); throw mapnik::datasource_exception(sqlite3_errmsg (db_));
} }
int mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE; int mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE;
if (sqlite3_open_v2 (file.c_str(), &db_, mode, NULL)) if (sqlite3_open_v2(file.c_str(), &db_, mode, NULL))
#else #else
#warning "Mapnik's sqlite plugin is compiling against a version of sqlite older than 3.6.18 which may make rendering slow..." #warning "Mapnik's sqlite plugin is compiling against a version of sqlite older than 3.6.18 which may make rendering slow..."
if (sqlite3_open (file.c_str(), &db_)) if (sqlite3_open(file.c_str(), &db_))
#endif #endif
{ {
std::ostringstream s; std::ostringstream s;
s << "Sqlite Plugin: " << sqlite3_errmsg (db_); s << "Sqlite Plugin: " << sqlite3_errmsg(db_);
throw mapnik::datasource_exception (s.str()); throw mapnik::datasource_exception(s.str());
} }
} }
virtual ~sqlite_connection () virtual ~sqlite_connection()
{ {
if (db_) if (db_)
{ {
sqlite3_close (db_); sqlite3_close(db_);
} }
} }
@ -204,10 +194,16 @@ public:
{ {
std::ostringstream s; std::ostringstream s;
s << "Sqlite Plugin: "; s << "Sqlite Plugin: ";
if (db_) if (db_)
{
s << "'" << sqlite3_errmsg(db_) << "'"; s << "'" << sqlite3_errmsg(db_) << "'";
}
else else
{
s << "unknown error, lost connection"; s << "unknown error, lost connection";
}
s << "\nFull sql was: '" << sql << "'\n"; s << "\nFull sql was: '" << sql << "'\n";
throw mapnik::datasource_exception (s.str()); throw mapnik::datasource_exception (s.str());
@ -217,7 +213,7 @@ public:
{ {
sqlite3_stmt* stmt = 0; sqlite3_stmt* stmt = 0;
const int rc = sqlite3_prepare_v2 (db_, sql.c_str(), -1, &stmt, 0); const int rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, 0);
if (rc != SQLITE_OK) if (rc != SQLITE_OK)
{ {
throw_sqlite_error(sql); throw_sqlite_error(sql);
@ -251,5 +247,4 @@ private:
sqlite3* db_; sqlite3* db_;
}; };
#endif // SQLITE_TYPES_HPP
#endif //SQLITE_TYPES_HPP