Merge pull request #1 from detule/fixup/date_time_with_int_storage

date/time: handle r types with integer storage

Author: RasmusSkytte

src/odbc_result.cpp

@@ -106,11 +106,18 @@ void odbc_result::bind_columns(
   case logical_t:
     bind_logical(obj, data, column, start, size, buffers);
     break;
-  case date_t:
-    bind_date(obj, data, column, start, size, buffers);
+  case date_int_t:
+    bind_date<T, int>(obj, data, column, start, size, buffers);
+  case date_double_t:
+    bind_date<T, double>(obj, data, column, start, size, buffers);
     break;
-  case datetime_t:
-    bind_datetime(obj, data, column, start, size, buffers);
+  case datetime_int_t:
+    Rcpp::Rcout << "bindings int datetime";
+    bind_datetime<T, int>(obj, data, column, start, size, buffers);
+    break;
+  case datetime_double_t:
+    Rcpp::Rcout << "bindings double datetime";
+    bind_datetime<T, double>(obj, data, column, start, size, buffers);
     break;
   case double_t:
     bind_double(obj, data, column, start, size, buffers);
@@ -385,7 +392,7 @@ void odbc_result::bind_raw(
       column, buffers.raws_[column], reinterpret_cast<bool*>(buffers.nulls_[column].data()));
 }
 
-template<typename T>
+template<typename T, typename SourceType>
 void odbc_result::bind_datetime(
     T& obj,
     Rcpp::List const& data,
@@ -395,7 +402,7 @@ void odbc_result::bind_datetime(
     param_data& buffers) {
 
   buffers.nulls_[column] = std::vector<uint8_t>(size, false);
-  auto d = REAL(data[column]);
+  auto d = (SourceType*)DATAPTR(data[column]);
 
   nanodbc::timestamp ts;
   short precision = 3;
@@ -426,7 +433,7 @@ void odbc_result::bind_datetime(
       reinterpret_cast<bool*>(buffers.nulls_[column].data()));
 }
 
-template<typename T>
+template<typename T, typename SourceType>
 void odbc_result::bind_date(
     T& obj,
     Rcpp::List const& data,
@@ -436,11 +443,11 @@ void odbc_result::bind_date(
     param_data& buffers) {
 
   buffers.nulls_[column] = std::vector<uint8_t>(size, false);
-  auto d = REAL(data[column]);
+  auto d = (SourceType*)DATAPTR(data[column]);
 
   nanodbc::date dt;
   for (size_t i = 0; i < size; ++i) {
-    auto value = d[start + i] * seconds_in_day_;
+    auto value = (double)d[start + i] * seconds_in_day_;
     if (ISNA(value)) {
       buffers.nulls_[column][i] = true;
     } else {
@@ -635,8 +642,10 @@ Rcpp::List odbc_result::create_dataframe(
       out[j] = Rf_allocVector(INTSXP, n);
       break;
     case integer64_t:
-    case date_t:
-    case datetime_t:
+    case date_int_t:
+    case date_double_t:
+    case datetime_int_t:
+    case datetime_double_t:
     case odbc::time_t:
     case odbc::double_t:
       out[j] = Rf_allocVector(REALSXP, n);
@@ -681,10 +690,12 @@ void odbc_result::add_classes(
     case integer64_t:
       x.attr("class") = Rcpp::CharacterVector::create("integer64");
       break;
-    case date_t:
+    case date_int_t:
+    case date_double_t:
       x.attr("class") = Rcpp::CharacterVector::create("Date");
       break;
-    case datetime_t:
+    case datetime_int_t:
+    case datetime_double_t:
       x.attr("class") = Rcpp::CharacterVector::create("POSIXct", "POSIXt");
       x.attr("tzone") = Rcpp::CharacterVector::create(c_->timezone_out_str());
       break;
@@ -712,19 +723,29 @@ std::vector<r_type> odbc_result::column_types(Rcpp::List const& list) {
       types.push_back(dataframe_t);
       continue;
     }
-    switch (TYPEOF(list[i])) {
+    auto r_type = TYPEOF(list[i]);
+    switch (r_type) {
     case LGLSXP:
       types.push_back(logical_t);
       break;
-    case INTSXP:
-      types.push_back(integer_t);
+    case INTSXP: {
+      Rcpp::RObject x = list[i];
+      if (x.inherits("Date")) {
+        types.push_back(date_int_t);
+      } else if (x.inherits("POSIXct")) {
+        Rcpp::Rcout << "Pushing datetime_int_t";
+        types.push_back(datetime_int_t);
+      } else {
+        types.push_back(integer_t);
+      }
       break;
+    }
     case REALSXP: {
       Rcpp::RObject x = list[i];
       if (x.inherits("Date")) {
-        types.push_back(date_t);
+        types.push_back(date_double_t);
       } else if (x.inherits("POSIXct")) {
-        types.push_back(datetime_t);
+        types.push_back(datetime_double_t);
       } else if (x.inherits("difftime")) {
         types.push_back(odbc::time_t);
       } else {
@@ -797,7 +818,7 @@ std::vector<r_type> odbc_result::column_types(nanodbc::result const& r) {
     // Date
     case SQL_DATE:
     case SQL_TYPE_DATE:
-      types.push_back(date_t);
+      types.push_back(date_double_t);
       break;
     // Time
     case SQL_TIME:
@@ -808,7 +829,7 @@ std::vector<r_type> odbc_result::column_types(nanodbc::result const& r) {
     case SQL_TIMESTAMP:
     case SQL_TYPE_TIMESTAMP:
     case SQL_SS_TIMESTAMPOFFSET:
-      types.push_back(datetime_t);
+      types.push_back(datetime_double_t);
       break;
     case SQL_CHAR:
     case SQL_VARCHAR:
@@ -875,10 +896,12 @@ Rcpp::List odbc_result::result_to_dataframe(nanodbc::result& r, int n_max) {
     }
     for (size_t col = 0; col < types.size(); ++col) {
       switch (types[col]) {
-      case date_t:
+      case date_int_t:
+      case date_double_t:
         assign_date(out, row, col, r);
         break;
-      case datetime_t:
+      case datetime_double_t:
+      case datetime_int_t:
         assign_datetime(out, row, col, r);
         break;
       case odbc::double_t:
@@ -1099,24 +1122,6 @@ size_t odbc_result::get_parameter_rows(Rcpp::List const& x) {
 
 # define R_ODBC_INSTANTIATE_BINDS(type)                                   \
   template void odbc_result::bind_columns(type& obj, r_type,              \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_logical(type& obj,                      \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_integer(type& obj,                      \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_double(type& obj,                       \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_string(type& obj,                       \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_raw(type& obj,                          \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_datetime(type& obj,                     \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_date(type& obj,                         \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_time(type& obj,                         \
-      Rcpp::List const&, short, size_t, size_t, param_data&);             \
-  template void odbc_result::bind_df(type& obj,                           \
       Rcpp::List const&, short, size_t, size_t, param_data&);
 R_ODBC_INSTANTIATE_BINDS(nanodbc::statement);
 R_ODBC_INSTANTIATE_BINDS(nanodbc::table_valued_parameter);

src/odbc_result.h

@@ -152,7 +152,7 @@ class odbc_result {
       size_t size,
       param_data& buffers);
 
-  template<typename T>
+  template<typename T, typename SourceType>
   void bind_datetime(
       T& obj,
       Rcpp::List const& data,
@@ -161,7 +161,7 @@ class odbc_result {
       size_t size,
       param_data& buffers);
 
-  template<typename T>
+  template<typename T, typename SourceType>
   void bind_date(
       T& obj,
       Rcpp::List const& data,

src/r_types.h

@@ -9,8 +9,10 @@ typedef enum {
   integer_t,
   integer64_t,
   double_t,
-  date_t,
-  datetime_t,
+  date_int_t,
+  date_double_t,
+  datetime_int_t,
+  datetime_double_t,
   time_t,
   string_t,
   ustring_t,

tests/testthat/test-driver-sql-server.R

@@ -465,3 +465,28 @@ test_that("Table-valued parameters", {
     params = list(df.param, 100, "Lorem ipsum dolor sit amet"))
   expect_identical(res, expected)
 })
+
+# #952: Binding date types that may have INTSXP OR REALSXP storage
+test_that("Variable date type storage", {
+  con <- test_con("SQLSERVER")
+  tbl_name <- "datevariablestoragetest"
+  # INTSXP storage
+  data <- data.frame(
+       "dates" = seq.Date(from = as.Date("2020-01-01"), to = as.Date("2020-01-02"), by = "1 day"),
+       "dtms" = seq.POSIXt(from = as.POSIXct("2020-01-01", tz = "UTC"), to = as.POSIXct("2020-01-02", tz = "UTC"), length.out = 2L)
+  )
+  # REALSXP storage
+  data_real <- data.frame(
+       "dates" = c(as.Date("2020-01-01"), as.Date("2020-01-02")),
+       "dtms" = c(as.POSIXct("2020-01-01", tz = "UTC"), as.POSIXct("2020-01-02", tz = "UTC"))
+  )
+  # 1. Writing both should succeed
+  # 2. They should both come back with REALSXP storage
+  local_table(con, tbl_name, data)
+  res <- dbReadTable(con, tbl_name)
+  expect_identical(data_real, res)
+
+  DBI::dbWriteTable(con, tbl_name, data_real, overwrite = TRUE)
+  res <- dbReadTable(con, tbl_name)
+  expect_identical(data_real, res)
+})