WIP: Thread utcoffset from connection

src/DbConnection.cpp

@@ -8,10 +8,11 @@
 #endif
 
 DbConnection::DbConnection(std::vector<std::string> keys, std::vector<std::string> values,
-                           bool check_interrupts) :
+                           bool check_interrupts, const int utcoffset) :
   pCurrentResult_(NULL),
   transacting_(false),
-  check_interrupts_(check_interrupts)
+  check_interrupts_(check_interrupts),
+  utcoffset_(utcoffset)
 {
   size_t n = keys.size();
   std::vector<const char*> c_keys(n + 1), c_values(n + 1);

src/DbConnection.h

@@ -17,10 +17,11 @@ class DbConnection : boost::noncopyable {
   const DbResult* pCurrentResult_;
   bool transacting_;
   bool check_interrupts_;
+  const int utcoffset_;
 
 public:
   DbConnection(std::vector<std::string> keys, std::vector<std::string> values,
-    bool check_interrupts);
+    bool check_interrupts, const int utcoffset);
   virtual ~DbConnection();
 
 public:

src/PqColumnDataSource.cpp

@@ -4,10 +4,14 @@
 #include "PqResultSource.h"
 #include "PqUtils.h"
 
-PqColumnDataSource::PqColumnDataSource(PqResultSource* result_source_, const DATA_TYPE dt_, const int j) :
+PqColumnDataSource::PqColumnDataSource(PqResultSource* result_source_,
+                                       const DATA_TYPE dt_,
+                                       const int j,
+                                       const int utcoffset_) :
   DbColumnDataSource(j),
   result_source(result_source_),
-  dt(dt_)
+  dt(dt_),
+  utcoffset(utcoffset_)
 {
 }
 
@@ -89,12 +93,12 @@ double PqColumnDataSource::fetch_date() const {
 
 double PqColumnDataSource::fetch_datetime_local() const {
   LOG_VERBOSE;
-  return convert_datetime(get_result_value(), true);
+  return convert_datetime(get_result_value(), utcoffset);
 }
 
 double PqColumnDataSource::fetch_datetime() const {
   LOG_VERBOSE;
-  return convert_datetime(get_result_value(), false);
+  return convert_datetime(get_result_value(), utcoffset);
 }
 
 double PqColumnDataSource::fetch_time() const {
@@ -110,8 +114,7 @@ double PqColumnDataSource::fetch_time() const {
   return static_cast<double>(hour * 3600 + min * 60) + sec;
 }
 
-double PqColumnDataSource::convert_datetime(const char* val, bool use_local) {
-  char* end;
+double PqColumnDataSource::convert_datetime(const char* val, int utcoffset) {
   struct tm date;
   date.tm_isdst = -1;
   date.tm_year = *val - 0x30;

src/PqColumnDataSource.h

@@ -9,9 +9,10 @@ class PqColumnDataSourceFactory;
 class PqColumnDataSource : public DbColumnDataSource {
   PqResultSource* result_source;
   const DATA_TYPE dt;
+  const int utcoffset;
 
 public:
-  PqColumnDataSource(PqResultSource* result_source_, const DATA_TYPE dt_, const int j);
+  PqColumnDataSource(PqResultSource* result_source_, const DATA_TYPE dt_, const int j, const int utcoffset);
   virtual ~PqColumnDataSource();
 
 public:
@@ -32,7 +33,7 @@ class PqColumnDataSource : public DbColumnDataSource {
   virtual double fetch_time() const;
 
 private:
-  static double convert_datetime(const char* val, bool use_local);
+  static double convert_datetime(const char* val, int utcoffset);
   PGresult* get_result() const;
   const char* get_result_value() const;
 };

src/PqColumnDataSourceFactory.cpp

@@ -2,15 +2,18 @@
 #include "PqColumnDataSourceFactory.h"
 #include "PqColumnDataSource.h"
 
-PqColumnDataSourceFactory::PqColumnDataSourceFactory(PqResultSource* result_source_, const std::vector<DATA_TYPE>& types_) :
+PqColumnDataSourceFactory::PqColumnDataSourceFactory(PqResultSource* result_source_,
+                                                     const std::vector<DATA_TYPE>& types_,
+                                                     const int utcoffset_) :
   result_source(result_source_),
-  types(types_)
+  types(types_),
+  utcoffset(utcoffset_)
 {
 }
 
 PqColumnDataSourceFactory::~PqColumnDataSourceFactory() {
 }
 
 DbColumnDataSource* PqColumnDataSourceFactory::create(const int j) {
-  return new PqColumnDataSource(result_source, types[j], j);
+  return new PqColumnDataSource(result_source, types[j], j, utcoffset);
 }

src/PqColumnDataSourceFactory.h

@@ -9,9 +9,12 @@ class PqResultSource;
 class PqColumnDataSourceFactory : public DbColumnDataSourceFactory {
   PqResultSource* result_source;
   const std::vector<DATA_TYPE> types;
+  const int utcoffset;
 
 public:
-  PqColumnDataSourceFactory(PqResultSource* result_source_, const std::vector<DATA_TYPE>& types_);
+  PqColumnDataSourceFactory(PqResultSource* result_source_,
+                            const std::vector<DATA_TYPE>& types_,
+                            const int utcoffset_);
   virtual ~PqColumnDataSourceFactory();
 
 public:

src/PqDataFrame.cpp

@@ -6,8 +6,9 @@
 PqDataFrame::PqDataFrame(PqResultSource* result_source,
                          const std::vector<std::string>& names,
                          const int n_max_,
-                         const std::vector<DATA_TYPE>& types) :
-  DbDataFrame(new PqColumnDataSourceFactory(result_source, types), names, n_max_, types)
+                         const std::vector<DATA_TYPE>& types,
+                         const int utcoffset) :
+  DbDataFrame(new PqColumnDataSourceFactory(result_source, types, utcoffset), names, n_max_, types)
 {
 }
 

src/PqDataFrame.h

@@ -10,7 +10,8 @@ class PqDataFrame : public DbDataFrame {
   PqDataFrame(PqResultSource* result_source,
               const std::vector<std::string>& names,
               const int n_max_,
-              const std::vector<DATA_TYPE>& types);
+              const std::vector<DATA_TYPE>& types,
+              const int utcoffset);
   ~PqDataFrame();
 };
 

src/PqResult.cpp

@@ -6,17 +6,17 @@
 
 // Construction ////////////////////////////////////////////////////////////////
 
-PqResult::PqResult(const DbConnectionPtr& pConn, const std::string& sql) :
+PqResult::PqResult(const DbConnectionPtr& pConn, const std::string& sql, const int utcoffset) :
   DbResult(pConn)
 {
-  impl.reset(new DbResultImpl(pConn, sql));
+  impl.reset(new DbResultImpl(pConn, sql, utcoffset));
 }
 
 
 // Publics /////////////////////////////////////////////////////////////////////
 
-DbResult* PqResult::create_and_send_query(const DbConnectionPtr& con, const std::string& sql) {
-  return new PqResult(con, sql);
+DbResult* PqResult::create_and_send_query(const DbConnectionPtr& con, const std::string& sql, const int utcoffset) {
+  return new PqResult(con, sql, utcoffset);
 }
 
 

src/PqResult.h

@@ -9,10 +9,12 @@
 
 class PqResult : public DbResult {
 protected:
-  PqResult(const DbConnectionPtr& pConn, const std::string& sql);
+  PqResult(const DbConnectionPtr& pConn, const std::string& sql, const int utcoffset);
 
 public:
-  static DbResult* create_and_send_query(const DbConnectionPtr& con, const std::string& sql);
+  static DbResult* create_and_send_query(const DbConnectionPtr& con,
+                                         const std::string& sql,
+                                         const int utcoffset);
 };
 
 #endif // __RPOSTGRES_PQ_RESULT__

src/PqResultImpl.cpp

@@ -9,7 +9,7 @@
 #include <winsock2.h>
 #endif
 
-PqResultImpl::PqResultImpl(const DbConnectionPtr& pConn, const std::string& sql) :
+PqResultImpl::PqResultImpl(const DbConnectionPtr& pConn, const std::string& sql, const int utcoffset) :
   pConnPtr_(pConn),
   pConn_(pConn->conn()),
   pSpec_(prepare(pConn_, sql)),
@@ -21,7 +21,8 @@ PqResultImpl::PqResultImpl(const DbConnectionPtr& pConn, const std::string& sql)
   rows_affected_(0),
   group_(0),
   groups_(0),
-  pRes_(NULL)
+  pRes_(NULL),
+  utcoffset_(utcoffset)
 {
 
   LOG_DEBUG << sql;
@@ -355,7 +356,7 @@ void PqResultImpl::after_bind(bool params_have_rows) {
 List PqResultImpl::fetch_rows(const int n_max, int& n) {
   n = (n_max < 0) ? 100 : n_max;
 
-  PqDataFrame data(this, cache.names_, n_max, cache.types_);
+  PqDataFrame data(this, cache.names_, n_max, cache.types_, utcoffset_);
 
   if (complete_ && data.get_ncols() == 0) {
     warning("Don't need to call dbFetch() for statements, only for queries");
@@ -440,7 +441,7 @@ bool PqResultImpl::step_done() {
 }
 
 List PqResultImpl::peek_first_row() {
-  PqDataFrame data(this, cache.names_, 1, cache.types_);
+  PqDataFrame data(this, cache.names_, 1, cache.types_, utcoffset_);
 
   if (!complete_)
     data.set_col_values();

src/PqResultImpl.h

@@ -45,8 +45,11 @@ class PqResultImpl : boost::noncopyable, public PqResultSource {
   int group_, groups_;
   PGresult* pRes_;
 
+  // Constant
+  const int utcoffset_;
+
 public:
-  PqResultImpl(const DbConnectionPtr& pConn, const std::string& sql);
+  PqResultImpl(const DbConnectionPtr& pConn, const std::string& sql, const int utcoffset);
   ~PqResultImpl();
 
 private:

src/result.cpp

@@ -7,7 +7,7 @@
 // [[Rcpp::export]]
 XPtr<DbResult> result_create(XPtr<DbConnectionPtr> con, std::string sql) {
   (*con)->check_connection();
-  DbResult* res = PqResult::create_and_send_query(*con, sql);
+  DbResult* res = PqResult::create_and_send_query(*con, sql, (*con)->get_utcoffset());
   return XPtr<DbResult>(res, true);
 }