as_character

CMakeLists.txt

@@ -14,6 +14,7 @@ set(EXTENSION_SOURCES src/rfuns_extension.cpp
                       src/relop.cpp
                       src/is_na.cpp
                       src/as_integer.cpp
+                      src/as_character.cpp
                       src/dispatch.cpp
                       src/sum.cpp
                       src/minmax.cpp)

duckdb-rfuns-r/NAMESPACE

@@ -1,5 +1,6 @@
 # Generated by roxygen2: do not edit by hand
 
+export(rfuns_as.character)
 export(rfuns_as.integer)
 export(rfuns_as.numeric)
 export(rfuns_in)

duckdb-rfuns-r/R/project.R

@@ -25,6 +25,16 @@ rfuns_as.numeric <- function(x) {
   rfuns("as.numeric", tibble(x = x))
 }
 
+#' as.character()
+#'
+#' @param x vector
+#'
+#' @export
+rfuns_as.character <- function(x) {
+  rfuns("as.character", tibble(x = x))
+}
+
+
 #' %in%
 #'
 #' @param x vector

duckdb-rfuns-r/tests/testthat/test-as_character.R

@@ -0,0 +1,33 @@
+test_that("as.character(<BOOLEAN>", {
+  expect_equal(rfuns_as.character(TRUE), "TRUE")
+  expect_equal(rfuns_as.character(FALSE), "FALSE")
+  expect_equal(rfuns_as.character(NA), NA_character_)
+})
+
+test_that("as.character(<INTEGER>", {
+  expect_equal(rfuns_as.character(3L), "3")
+  expect_equal(rfuns_as.character(NA_integer_), NA_character_)
+})
+
+test_that("as.character(<DOUBLE>", {
+  dbl <- 35.123
+  str <- rfuns_as.character(dbl)
+  expect_true(is.character(str))
+  expect_equal(as.numeric(str), dbl)
+
+  expect_equal(rfuns_as.character(NA_real_), NA_character_)
+})
+
+test_that("as.character(<VARCHAR>", {
+  expect_equal(rfuns_as.character("hello"), "hello")
+})
+
+test_that("as.character(<TIMESTAMP>", {
+  time <- as.POSIXct(strptime('2024-02-21 14:00:00', format = '%Y-%m-%d %H:%M:%S', tz = 'UTC'))
+  expect_equal(rfuns_as.character(time), "2024-02-21 14:00:00")
+})
+
+test_that("as.character(<DATE>", {
+  today <- Sys.Date()
+  expect_equal(rfuns_as.character(today), as.character(today))
+})

src/as_character.cpp

@@ -0,0 +1,68 @@
+#include "rfuns_extension.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/common/operator/double_cast_operator.hpp"
+
+#include <math.h>
+#include <climits>
+#include <limits>
+#include <cmath>
+
+namespace duckdb {
+namespace rfuns {
+
+namespace {
+
+template <typename physical_type>
+string_t to_string(physical_type x) {
+	return string_t(std::to_string(x));
+}
+
+template <>
+string_t to_string<bool>(bool x) {
+	return string_t(x ? "TRUE" : "FALSE");
+}
+
+template <>
+string_t to_string<string_t>(string_t x) {
+	return x;
+}
+
+template <>
+string_t to_string<date_t>(date_t x) {
+	return string_t(Date::ToString(x));
+}
+
+template <>
+string_t to_string<timestamp_t>(timestamp_t x) {
+	return string_t(Timestamp::ToString(x));
+}
+
+template <LogicalTypeId TYPE>
+ScalarFunction AsCharacterFunction() {
+	using physical_type = typename physical<TYPE>::type;
+
+	auto fun = [](DataChunk &args, ExpressionState &state, Vector &result) {
+		UnaryExecutor::Execute<physical_type, string_t>(
+			args.data[0], result, args.size(), to_string<physical_type>
+		);
+	};
+	return ScalarFunction({TYPE}, LogicalType::VARCHAR, fun);
+}
+
+}
+
+ScalarFunctionSet base_r_as_character() {
+	ScalarFunctionSet set("r_base::as.character");
+
+	set.AddFunction(AsCharacterFunction<LogicalType::BOOLEAN  >());
+	set.AddFunction(AsCharacterFunction<LogicalType::INTEGER  >());
+	set.AddFunction(AsCharacterFunction<LogicalType::DOUBLE   >());
+	set.AddFunction(AsCharacterFunction<LogicalType::VARCHAR  >());
+	set.AddFunction(AsCharacterFunction<LogicalType::DATE     >());
+	set.AddFunction(AsCharacterFunction<LogicalType::TIMESTAMP>());
+
+	return set;
+}
+
+}
+}

src/include/rfuns_extension.hpp

@@ -62,6 +62,7 @@ ScalarFunctionSet base_r_gte();
 ScalarFunctionSet base_r_is_na();
 ScalarFunctionSet base_r_as_integer();
 ScalarFunctionSet base_r_as_numeric();
+ScalarFunctionSet base_r_as_character();
 
 ScalarFunctionSet base_r_in();
 

src/rfuns_extension.cpp

@@ -36,6 +36,7 @@ static void register_rfuns(DatabaseInstance &instance) {
 	ExtensionUtil::RegisterFunction(instance, base_r_is_na());
 	ExtensionUtil::RegisterFunction(instance, base_r_as_integer());
 	ExtensionUtil::RegisterFunction(instance, base_r_as_numeric());
+	ExtensionUtil::RegisterFunction(instance, base_r_as_character());
 
 	ExtensionUtil::RegisterFunction(instance, base_r_in());