Merge pull request #39 from tidymodels/test-sql

test on SQLite with RSQLite

DESCRIPTION

@@ -18,6 +18,7 @@ Imports:
     rlang
 Suggests:
     arrow,
+    DBI,
     dbplyr,
     dtplyr,
     embed,
@@ -30,6 +31,7 @@ Suggests:
     R6,
     recipes,
     rmarkdown,
+    RSQLite,
     rstanarm,
     sparklyr,
     testthat (>= 3.0.0),

tests/testthat/_snaps/dt.new.md

@@ -0,0 +1,26 @@
+# dt works
+
+    Code
+      orbital_dt(obj)
+    Output
+      copy(`_DT2`)[, `:=`(c("cyl", "disp", "hp", "drat", "wt", "qsec", 
+          "vs", "am", "gear", "carb", ".pred"), {
+          cyl <- (cyl - 6.1875)/1.785922
+          disp <- (disp - 230.7219)/123.9387
+          hp <- (hp - 146.6875)/68.56287
+          drat <- (drat - 3.596562)/0.5346787
+          wt <- (wt - 3.21725)/0.9784574
+          qsec <- (qsec - 17.84875)/1.786943
+          vs <- (vs - 0.4375)/0.5040161
+          am <- (am - 0.40625)/0.4989909
+          gear <- (gear - 3.6875)/0.7378041
+          carb <- (carb - 2.8125)/1.6152
+          .pred <- 20.09062 + (cyl * -0.199024) + (disp * 
+              1.652752) + (hp * -1.472876) + (drat * 
+              0.4208515) + (wt * -3.635267) + (qsec * 
+              1.467153) + (vs * 0.1601576) + (am * 
+              1.25757) + (gear * 0.4835664) + (carb * 
+              -0.322102)
+          .(cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb, .pred)
+      })]
+

tests/testthat/test-step_adasyn.R

@@ -74,3 +74,30 @@ test_that("spark - step_adasyn works", {
 
   expect_equal(res_spark, res)
 })
+
+test_that("SQLite - step_adasyn works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("themis")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_adasyn <- dplyr::as_tibble(mtcars)
+  mtcars_adasyn$vs <- as.factor(mtcars$vs)
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_adasyn) %>%
+    themis::step_adasyn(vs, skip = TRUE) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars_adasyn, !!!orbital_inline(orbital(rec)))
+  res$vs <- as.character(res$vs)
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_adasyn)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_bin2factor.R

@@ -72,5 +72,26 @@ test_that("spark - step_bin2factor works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQLite - step_bin2factor works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
 
+  mtcars <- dplyr::as_tibble(mtcars)
 
+  rec <- recipes::recipe(mpg ~ ., data = mtcars) %>%
+    recipes::step_bin2factor(vs, am) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars, !!!orbital_inline(orbital(rec)))
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_boxcox.R

@@ -70,5 +70,26 @@ test_that("spark - step_BoxCox works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQLite - step_BoxCox works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
 
+  mtcars <- dplyr::as_tibble(mtcars)
 
+  rec <- recipes::recipe(~ ., data = mtcars) %>%
+    recipes::step_BoxCox(mpg, disp) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars, !!!orbital_inline(orbital(rec)))
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_bsmote.R

@@ -74,3 +74,30 @@ test_that("spark - step_bsmote works", {
 
   expect_equal(res_spark, res)
 })
+
+test_that("SQLite - step_bsmote works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("themis")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_bsmote <- dplyr::as_tibble(mtcars)
+  mtcars_bsmote$vs <- as.factor(mtcars$vs)
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_bsmote) %>%
+    themis::step_bsmote(vs, skip = TRUE) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars_bsmote, !!!orbital_inline(orbital(rec)))
+  res$vs <- as.character(res$vs)
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_bsmote)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_center.R

@@ -69,3 +69,27 @@ test_that("spark - step_center works", {
 
   expect_equal(res_spark, res)
 })
+
+test_that("spark - step_center works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars <- dplyr::as_tibble(mtcars)
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars) %>%
+    recipes::step_center(recipes::all_predictors()) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars, !!!orbital_inline(orbital(rec)))
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_corr.R

@@ -32,4 +32,9 @@ test_that("step_corr works with empty selections", {
 test_that("spark - step_corr works", {
   # Isn't needed as `step_corr()` doesn't produce code
   expect_true(TRUE)
+})
+
+test_that("SQLite - step_corr works", {
+  # Isn't needed as `step_corr()` doesn't produce code
+  expect_true(TRUE)
 })

tests/testthat/test-step_discretize.R

@@ -123,5 +123,29 @@ test_that("spark - step_discretize works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQLite - step_discretize works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_discretize <- dplyr::as_tibble(mtcars)
+  mtcars_discretize[1, ] <- NA
+
+  suppressWarnings(
+    rec <- recipes::recipe(mpg ~ ., data = mtcars_discretize) %>%
+      recipes::step_discretize(mpg, disp, min_unique = 4) %>%
+      recipes::prep()
+  )
+
+  res <- dplyr::mutate(mtcars_discretize, !!!orbital_inline(orbital(rec)))
 
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_discretize)
 
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_downsample.R

@@ -74,3 +74,30 @@ test_that("spark - step_downsample works", {
 
   expect_equal(res_spark, res)
 })
+
+test_that("SQLite - step_downsample works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("themis")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_downsample <- dplyr::as_tibble(mtcars)
+  mtcars_downsample$vs <- as.factor(mtcars$vs)
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_downsample) %>%
+    themis::step_downsample(vs, skip = TRUE) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars_downsample, !!!orbital_inline(orbital(rec)))
+  res$vs <- as.character(res$vs)
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_downsample)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_dummy.R

@@ -99,4 +99,31 @@ test_that("spark - step_dummy works", {
     dplyr::collect()
 
   expect_equal(res_spark, exp)
+})
+
+test_that("SQL - step_dummy works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars1 <- dplyr::as_tibble(mtcars)
+
+  mtcars1$gear <- as.character(mtcars1$gear)
+  mtcars1$carb <- as.character(mtcars1$carb)
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars1) %>%
+    recipes::step_dummy(recipes::all_nominal_predictors()) %>%
+    recipes::prep()
+
+  exp <- dplyr::mutate(mtcars1, !!!orbital_inline(orbital(rec)))
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars1)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, exp)
+
+  DBI::dbDisconnect(con)
 })

tests/testthat/test-step_filter_missing.R

@@ -31,4 +31,9 @@ test_that("step_filter_missing works with empty selections", {
 test_that("spark - step_filter_missing works", {
   # Isn't needed as `step_filter_missing()` doesn't produce code
   expect_true(TRUE)
+})
+
+test_that("SQLite - step_filter_missing works", {
+  # Isn't needed as `step_filter_missing()` doesn't produce code
+  expect_true(TRUE)
 })

tests/testthat/test-step_impute_mean.R

@@ -73,5 +73,27 @@ test_that("spark - step_impute_mean works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQLite - step_impute_mean works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_impute_mean <- dplyr::as_tibble(mtcars)
+  mtcars_impute_mean[2:4, ] <- NA
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_impute_mean) %>%
+    recipes::step_impute_mean(recipes::all_predictors()) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars_impute_mean, !!!orbital_inline(orbital(rec)))
 
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_impute_mean)
 
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_impute_median.R

@@ -74,5 +74,27 @@ test_that("spark - step_impute_median works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQL - step_impute_median works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
+
+  mtcars_impute_median <- dplyr::as_tibble(mtcars)
+  mtcars_impute_median[2:4, ] <- NA
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_impute_median) %>%
+    recipes::step_impute_median(recipes::all_predictors()) %>%
+    recipes::prep()
+
+  res <- dplyr::mutate(mtcars_impute_median, !!!orbital_inline(orbital(rec)))
 
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_impute_median)
 
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})

tests/testthat/test-step_impute_mode.R

@@ -82,5 +82,30 @@ test_that("spark - step_impute_mode works", {
   expect_equal(res_spark, res)
 })
 
+test_that("SQLite - step_impute_mode works", {
+  skip_if_not_installed("recipes")
+  skip_if_not_installed("DBI")
+  skip_if_not_installed("RSQLite")
 
+  mtcars_impute_mode <- dplyr::as_tibble(mtcars)
+  mtcars_impute_mode$gear <- letters[mtcars$gear]
+  mtcars_impute_mode$carb <- letters[mtcars$carb]
+  mtcars_impute_mode[2:4, ] <- NA
+
+  rec <- recipes::recipe(mpg ~ ., data = mtcars_impute_mode) %>%
+    recipes::step_impute_mode(recipes::all_nominal_predictors()) %>%
+    recipes::prep(strings_as_factors = FALSE)
 
+  res <- dplyr::mutate(mtcars_impute_mode, !!!orbital_inline(orbital(rec)))
+
+
+  con <- DBI::dbConnect(RSQLite::SQLite(), path = ":memory:")
+  mtcars_tbl <- dplyr::copy_to(con, mtcars_impute_mode)
+
+  res_sql <- dplyr::mutate(mtcars_tbl, !!!orbital_inline(orbital(rec))) %>%
+    dplyr::collect()
+
+  expect_equal(res_sql, res)
+
+  DBI::dbDisconnect(con)
+})