Make interlace a S3 generic

NAMESPACE

@@ -33,6 +33,7 @@ S3method(get_tables,SQLiteConnection)
 S3method(id,Id)
 S3method(id,character)
 S3method(id,tbl_dbi)
+S3method(interlace,tbl_sql)
 S3method(schema_exists,DBIConnection)
 S3method(schema_exists,SQLiteConnection)
 S3method(schema_exists,default)
@@ -53,7 +54,7 @@ export(get_schema)
 export(get_table)
 export(get_tables)
 export(id)
-export(interlace_sql)
+export(interlace)
 export(is.historical)
 export(nrow)
 export(schema_exists)

NEWS.md

@@ -42,6 +42,8 @@
 
 * The `%notin%` operator has been removed from the package (#??).
 
+* The `interlace_sql()` function is converted to the S3 generic `interlace()` (#113).
+
 ## New features
 
 * The S3 method `as.character.Id()` is added which converts `DBI::Id()` to `character` (#93).

R/interlace_sql.R → R/interlace.R

@@ -1,4 +1,4 @@
-#' Combine any number of SQL queries, where each has their own time axis of
+#' Combine any number of tables, where each has their own time axis of
 #' validity (valid_from and valid_until)
 #'
 #' @description
@@ -15,39 +15,41 @@
 #'                  colnames must be named in same order as as given in tables
 #'                  (i.e. t1, t2, t3, ...).
 #' @examples
-#' conn <- get_connection(drv = RSQLite::SQLite())
+#'   conn <- get_connection(drv = RSQLite::SQLite())
 #'
-#'
-#' if (schema_exists(conn, "test")) {
 #'   t1 <- data.frame(key = c("A", "A", "B"),
-#'                   obs_1   = c(1, 2, 2),
-#'                   valid_from  = as.Date(c("2021-01-01", "2021-02-01", "2021-01-01")),
-#'                   valid_until = as.Date(c("2021-02-01", "2021-03-01", NA)))
-#'   t1 <- dplyr::copy_to(conn, t1, id("test.SCDB_tmp1", conn), overwrite = TRUE, temporary = FALSE)
+#'                    obs_1   = c(1, 2, 2),
+#'                    valid_from  = as.Date(c("2021-01-01", "2021-02-01", "2021-01-01")),
+#'                    valid_until = as.Date(c("2021-02-01", "2021-03-01", NA))) |>
+#'     dplyr::copy_to(conn, df = _, name = "t1")
 #'
 #'   t2 <- data.frame(key = c("A", "B"),
-#'                   obs_2 = c("a", "b"),
-#'                   valid_from  = as.Date(c("2021-01-01", "2021-01-01")),
-#'                   valid_until = as.Date(c("2021-04-01", NA)))
-#'   t2 <- dplyr::copy_to(conn, t2, id("test.SCDB_tmp2", conn), overwrite = TRUE, temporary = FALSE)
+#'                    obs_2 = c("a", "b"),
+#'                    valid_from  = as.Date(c("2021-01-01", "2021-01-01")),
+#'                    valid_until = as.Date(c("2021-04-01", NA))) |>
+#'     dplyr::copy_to(conn, df = _, name = "t2")
 #'
-#'   interlace_sql(list(t1, t2), by = "key")
-#' }
+#'   interlace(list(t1, t2), by = "key")
 #'
-#' close_connection(conn)
+#'   close_connection(conn)
 #' @return          The combination of input queries with a single, interlaced
 #'                  valid_from / valid_until time axis
 #' @importFrom rlang .data
 #' @export
-interlace_sql <- function(tables, by = NULL, colnames = NULL) {
-
+interlace <- function(tables, by = NULL, colnames = NULL) {
   # Check arguments
   checkmate::assert_character(by)
   # TODO: how to checkmate tables and colnames?
 
   # Check edgecase
   if (length(tables) == 1) return(purrr::pluck(tables, 1))
 
+  UseMethod("interlace", tables[[1]])
+}
+
+#' @export
+interlace.tbl_sql <- function(tables, by = NULL, colnames = NULL) {
+
   # Parse inputs for colnames .from / .to columns
   from_cols <- seq_along(tables) |>
     purrr::map_chr(\(t) paste0("t", t, ".from")) |>

tests/testthat/test-interlace_sql.R → tests/testthat/test-interlace.R

@@ -1,4 +1,4 @@
-test_that("interlace_sql() works", {
+test_that("interlace.tbl_sql() works", {
   for (conn in get_test_conns()) {
 
     t1 <- data.frame(key = c("A", "A", "B"),
@@ -34,17 +34,17 @@ test_that("interlace_sql() works", {
     )
 
 
-    expect_identical(interlace_sql(list(t1, t2), by = "key") |> dplyr::collect(),
+    expect_identical(interlace(list(t1, t2), by = "key") |> dplyr::collect(),
                      t_ref |> dplyr::collect())
 
-    expect_mapequal(interlace_sql(list(t1, t2), by = "key") |> dplyr::collect(),
-                    interlace_sql(list(t2, t1), by = "key") |> dplyr::collect())
+    expect_mapequal(interlace(list(t1, t2), by = "key") |> dplyr::collect(),
+                    interlace(list(t2, t1), by = "key") |> dplyr::collect())
 
     connection_clean_up(conn)
   }
 })
 
 
-test_that("interlace_sql returns early if length(table) == 1", {
-  expect_identical(mtcars$mpg, interlace_sql(mtcars["mpg"], by = "mpg"))
+test_that("interlace returns early if length(table) == 1", {
+  expect_identical(mtcars$mpg, interlace(mtcars["mpg"], by = "mpg"))
 })