From e2ccfcb042098a0f553c35cc835319a709013f7b Mon Sep 17 00:00:00 2001
From: Jamie Gilbert <JGilber2@its.jnj.com>
Date: Wed, 12 Jan 2022 12:23:38 -0800
Subject: [PATCH 1/8] Made commented sqlite test for old code work

---
 R/GetDefaultCovariates.R                   | 181 +++++++++------------
 tests/testthat/test-GetDefaultCovariates.R |  30 ++--
 2 files changed, 90 insertions(+), 121 deletions(-)

diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index 12ca90af..6a871f58 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -54,10 +54,7 @@ getDbDefaultCovariateData <- function(connection,
   if (cdmVersion == "4") {
     stop("Common Data Model version 4 is not supported")
   }
-  if (!missing(targetCovariateTable) && !is.null(targetCovariateTable) && aggregated) {
-    stop("Writing aggregated results to database is currently not supported")
-  }
-  
+
   settings <- .toJson(covariateSettings)
   rJava::J("org.ohdsi.featureExtraction.FeatureExtraction")$init(system.file("", package = "FeatureExtraction"))
   json <- rJava::J("org.ohdsi.featureExtraction.FeatureExtraction")$createSql(settings, aggregated, cohortTable, rowIdField, rJava::.jarray(as.character(cohortId)), cdmDatabaseSchema)
@@ -74,123 +71,95 @@ getDbDefaultCovariateData <- function(connection,
                                      oracleTempSchema = oracleTempSchema)
     }
   }
-  
+
   ParallelLogger::logInfo("Constructing features on server")
-  
+
   sql <- SqlRender::translate(sql = todo$sqlConstruction,
                               targetDialect = attr(connection, "dbms"),
                               oracleTempSchema = oracleTempSchema)
   profile <- (!is.null(getOption("dbProfile")) && getOption("dbProfile") == TRUE)
   DatabaseConnector::executeSql(connection, sql, profile = profile)
-  
-  if (missing(targetCovariateTable) || is.null(targetCovariateTable)) {
-    ParallelLogger::logInfo("Fetching data from server")
-    start <- Sys.time()
-    # Binary or non-aggregated features
+
+
+  if (missing(targetCovariateTable) | is.null(targetCovariateTable)) {
     covariateData <- Andromeda::andromeda()
-    if (!is.null(todo$sqlQueryFeatures)) {
-      sql <- SqlRender::translate(sql = todo$sqlQueryFeatures,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      
-      DatabaseConnector::querySqlToAndromeda(connection = connection, 
-                                             sql = sql, 
-                                             andromeda = covariateData, 
-                                             andromedaTableName = "covariates",
-                                             snakeCaseToCamelCase = TRUE)
-    } 
-    
-    # Continuous aggregated features
-    if (!is.null(todo$sqlQueryContinuousFeatures)) {
-      sql <- SqlRender::translate(sql = todo$sqlQueryContinuousFeatures,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::querySqlToAndromeda(connection = connection, 
-                                             sql = sql, 
-                                             andromeda = covariateData, 
-                                             andromedaTableName = "covariatesContinuous",
-                                             snakeCaseToCamelCase = TRUE)
-    }
-    
-    # Covariate reference
-    sql <- SqlRender::translate(sql = todo$sqlQueryFeatureRef,
-                                targetDialect = attr(connection, "dbms"),
-                                oracleTempSchema = oracleTempSchema)
-    
-    DatabaseConnector::querySqlToAndromeda(connection = connection, 
-                                           sql = sql, 
-                                           andromeda = covariateData, 
-                                           andromedaTableName = "covariateRef",
-                                           snakeCaseToCamelCase = TRUE)
-    
-    # Analysis reference
-    sql <- SqlRender::translate(sql = todo$sqlQueryAnalysisRef,
-                                targetDialect = attr(connection, "dbms"),
-                                oracleTempSchema = oracleTempSchema)
-    DatabaseConnector::querySqlToAndromeda(connection = connection, 
-                                           sql = sql, 
-                                           andromeda = covariateData, 
-                                           andromedaTableName = "analysisRef",
-                                           snakeCaseToCamelCase = TRUE)
-    
-    # Time reference
-    if (!is.null(todo$sqlQueryTimeRef)) {
-      sql <- SqlRender::translate(sql = todo$sqlQueryTimeRef,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::querySqlToAndromeda(connection = connection, 
-                                             sql = sql, 
-                                             andromeda = covariateData, 
-                                             andromedaTableName = "timeRef",
+
+    queryFunction <- function(sql, tableName) {
+      DatabaseConnector::querySqlToAndromeda(connection = connection,
+                                             sql = sql,
+                                             andromeda = covariateData,
+                                             andromedaTableName = tableName,
                                              snakeCaseToCamelCase = TRUE)
     }
-    
-    
-    delta <- Sys.time() - start
-    ParallelLogger::logInfo("Fetching data took ", signif(delta, 3), " ", attr(delta, "units"))
+
   } else {
-    # Don't fetch to R , but create on server instead
-    ParallelLogger::logInfo("Writing data to table")
-    start <- Sys.time()
+
     convertQuery <- function(sql, databaseSchema, table) {
-      if (missing(databaseSchema) || is.null(databaseSchema)) {
-        tableName <- table
-      } else {
-        tableName <- paste(databaseSchema, table, sep = ".")
-      }
-      return(sub("FROM", paste("INTO", tableName, "FROM"), sql))
-    }
-    
-    # Covariates
-    if (!is.null(todo$sqlQueryFeatures)) {
-      sql <- convertQuery(todo$sqlQueryFeatures, targetDatabaseSchema, targetCovariateTable)
-      sql <- SqlRender::translate(sql = sql,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::executeSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
-    }
-    
-    # Covariate reference
-    if (!missing(targetCovariateRefTable) && !is.null(targetCovariateRefTable)) {
-      sql <- convertQuery(todo$sqlQueryFeatureRef, targetDatabaseSchema, targetCovariateRefTable)
-      sql <- SqlRender::translate(sql = sql,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::executeSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
+      outerSql <- "
+      IF OBJECT_ID('@database_schema.@table', 'U') IS NOT NULL
+	        DROP TABLE @database_schema.@table;
+
+      CREATE TABLE @database_schema.@table AS
+      @sub_query;"
+      SqlRender::render(outerSql,
+                        sub_query = gsub(";", "", sql),
+                        database_schema = databaseSchema,
+                        table = SqlRender::snakeCaseToCamelCase(table))
+
     }
-    
-    # Analysis reference
-    if (!missing(targetAnalysisRefTable) && !is.null(targetAnalysisRefTable)) {
-      sql <- convertQuery(todo$sqlQueryAnalysisRef, targetDatabaseSchema, targetAnalysisRefTable)
+
+    queryFunction <- function(sql, tableName) {
+      sql <- convertQuery(todo$sqlQueryFeatures, targetDatabaseSchema, tableName)
       sql <- SqlRender::translate(sql = sql,
                                   targetDialect = attr(connection, "dbms"),
                                   oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::executeSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
+      DatabaseConnector::renderTranslateExecuteSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
     }
-    delta <- Sys.time() - start
-    ParallelLogger::logInfo("Writing data took", signif(delta, 3), " ", attr(delta, "units"))
-    
+
+  }
+
+  ParallelLogger::logInfo("Fetching data from server")
+  start <- Sys.time()
+  # Binary or non-aggregated features
+  if (!is.null(todo$sqlQueryFeatures)) {
+    sql <- SqlRender::translate(sql = todo$sqlQueryFeatures,
+                                targetDialect = attr(connection, "dbms"),
+                                oracleTempSchema = oracleTempSchema)
+    queryFunction(sql, "covariates")
+  }
+
+  # Continuous aggregated features
+  if (!is.null(todo$sqlQueryContinuousFeatures)) {
+    sql <- SqlRender::translate(sql = todo$sqlQueryContinuousFeatures,
+                                targetDialect = attr(connection, "dbms"),
+                                oracleTempSchema = oracleTempSchema)
+    queryFunction(sql, "covariatesContinuous")
   }
+
+  # Covariate reference
+  sql <- SqlRender::translate(sql = todo$sqlQueryFeatureRef,
+                              targetDialect = attr(connection, "dbms"),
+                              oracleTempSchema = oracleTempSchema)
+
+  queryFunction(sql, "covariateRef")
+
+  # Analysis reference
+  sql <- SqlRender::translate(sql = todo$sqlQueryAnalysisRef,
+                              targetDialect = attr(connection, "dbms"),
+                              oracleTempSchema = oracleTempSchema)
+  queryFunction(sql, "analysisRef")
+
+  # Time reference
+  if (!is.null(todo$sqlQueryTimeRef)) {
+    sql <- SqlRender::translate(sql = todo$sqlQueryTimeRef,
+                                targetDialect = attr(connection, "dbms"),
+                                oracleTempSchema = oracleTempSchema)
+    queryFunction(sql, "timeRef")
+  }
+
+  delta <- Sys.time() - start
+  ParallelLogger::logInfo("Fetching data took ", signif(delta, 3), " ", attr(delta, "units"))
+
   # Drop temp tables
   sql <- SqlRender::translate(sql = todo$sqlCleanup,
                               targetDialect = attr(connection, "dbms"),
@@ -206,8 +175,8 @@ getDbDefaultCovariateData <- function(connection,
       DatabaseConnector::executeSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
     }
   }
-  
-  if (missing(targetCovariateTable) || is.null(targetCovariateTable)) {
+
+  if (missing(targetCovariateTable) | is.null(targetCovariateTable)) {
     attr(covariateData, "metaData") <- list()
     if (is.null(covariateData$covariates) && is.null(covariateData$covariatesContinuous)) {
       warning("No data found, probably because no covariates were specified.")
diff --git a/tests/testthat/test-GetDefaultCovariates.R b/tests/testthat/test-GetDefaultCovariates.R
index f8e299b0..814ccfc3 100644
--- a/tests/testthat/test-GetDefaultCovariates.R
+++ b/tests/testthat/test-GetDefaultCovariates.R
@@ -39,20 +39,20 @@ test_that("Test exit conditions", {
 })
 
 # AGS - This test fails and is likely due to a bug when using SqlLite
-# test_that("Test target table", {
-#   connection <- DatabaseConnector::connect(connectionDetails)
-#   Eunomia::createCohorts(connectionDetails)
-#   
-#   results <- getDbDefaultCovariateData(connection = connection,
-#                                        cdmDatabaseSchema = "main",
-#                                        cohortTable = "cohort",
-#                                        covariateSettings = createDefaultCovariateSettings(),
-#                                        targetDatabaseSchema = "main",
-#                                        targetCovariateTable = "ut_cov",
-#                                        targetCovariateRefTable = "ut_cov_ref",
-#                                        targetAnalysisRefTable = "ut_cov_analysis_ref")
-# 
-#   on.exit(DatabaseConnector::disconnect(connection))  
-# })
+test_that("Test target table", {
+  connection <- DatabaseConnector::connect(connectionDetails)
+  Eunomia::createCohorts(connectionDetails)
+
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       targetDatabaseSchema = "main",
+                                       targetCovariateTable = "ut_cov",
+                                       targetCovariateRefTable = "ut_cov_ref",
+                                       targetAnalysisRefTable = "ut_cov_analysis_ref")
+
+  DatabaseConnector::disconnect(connection)
+})
 
 unlink(connectionDetails$server())
\ No newline at end of file

From 235a74a426272e439be97ac46ad08b949bb3c8ae Mon Sep 17 00:00:00 2001
From: Jamie Gilbert <JGilber2@its.jnj.com>
Date: Wed, 12 Jan 2022 14:37:34 -0800
Subject: [PATCH 2/8] Changes to interface of getDefaultCovariates

---
 R/GetDefaultCovariates.R                   | 71 ++++++++++++++--------
 man/getDbDefaultCovariateData.Rd           | 20 +++---
 tests/testthat/test-GetDefaultCovariates.R | 52 +++++++++-------
 3 files changed, 82 insertions(+), 61 deletions(-)

diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index 6a871f58..57ca78b6 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -24,14 +24,13 @@
 #' @param covariateSettings      Either an object of type \code{covariateSettings} as created using one
 #'                               of the createCovariate functions, or a list of such objects.
 #' @param targetDatabaseSchema   (Optional) The name of the database schema where the resulting covariates
-#'                               should be stored.
-#' @param targetCovariateTable  (Optional) The name of the table where the resulting covariates will
-#'                               be stored. If not provided, results will be fetched to R. The table can be 
-#'                               a permanent table in the \code{targetDatabaseSchema} or a temp table. If 
-#'                               it is a temp table, do not specify \code{targetDatabaseSchema}.
-#' @param targetCovariateRefTable (Optional) The name of the table where the covariate reference will be stored.
-#' @param targetAnalysisRefTable (Optional) The name of the table where the analysis reference will be stored.
-#'
+#'                               should be stored.  If not provided, results will be fetched to R.
+#' @param targetTables           (Optional) list of mappings for table names.
+#'                               The names of the table where the resulting covariates will be if
+#'                               \code{targetDatabaseSchema} is specified. The tables will be created in permanent
+#'                               table in the \code{targetDatabaseSchema}.
+#' @param dropExistingTables     If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
+#'                               into existing table data.
 #' @template GetCovarParams
 #'
 #' @export
@@ -44,9 +43,8 @@ getDbDefaultCovariateData <- function(connection,
                                       rowIdField = "subject_id",
                                       covariateSettings,
                                       targetDatabaseSchema,
-                                      targetCovariateTable,
-                                      targetCovariateRefTable,
-                                      targetAnalysisRefTable,
+                                      targetTables = list(),
+                                      dropExistingTables = FALSE,
                                       aggregated = FALSE) {
   if (!is(covariateSettings, "covariateSettings")) {
     stop("Covariate settings object not of type covariateSettings")
@@ -80,8 +78,8 @@ getDbDefaultCovariateData <- function(connection,
   profile <- (!is.null(getOption("dbProfile")) && getOption("dbProfile") == TRUE)
   DatabaseConnector::executeSql(connection, sql, profile = profile)
 
-
-  if (missing(targetCovariateTable) | is.null(targetCovariateTable)) {
+  if (missing(targetDatabaseSchema) | is.null(targetDatabaseSchema)) {
+    # Save to Andromeda
     covariateData <- Andromeda::andromeda()
 
     queryFunction <- function(sql, tableName) {
@@ -91,34 +89,53 @@ getDbDefaultCovariateData <- function(connection,
                                              andromedaTableName = tableName,
                                              snakeCaseToCamelCase = TRUE)
     }
-
+    ParallelLogger::logInfo("Fetching data from server")
   } else {
+    # Save to DB
+    ParallelLogger::logInfo("Creating tables on server")
+    existingTables <- DatabaseConnector::getTableNames(connection, targetDatabaseSchema)
+
+    convertQuery <- function(sql, targetDatabaseSchema, table) {
+      mappedTable <- targetTables[[table]]
+      if (is.null(mappedTable)) {
+        mappedTable <- SqlRender::camelCaseToSnakeCase(table)
+      }
+      tableExists <- mappedTable %in% existingTables
+
+      if (!dropExistingTables & tableExists) {
+        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
+      } else {
+        ParallelLogger::logInfo("Creating table ", mappedTable, "for ", table)
+      }
 
-    convertQuery <- function(sql, databaseSchema, table) {
       outerSql <- "
+      {@create} ? {
       IF OBJECT_ID('@database_schema.@table', 'U') IS NOT NULL
 	        DROP TABLE @database_schema.@table;
 
-      CREATE TABLE @database_schema.@table AS
-      @sub_query;"
+      SELECT * INTO @database_schema.@table FROM ( @sub_query ) sq;
+      } : {
+      INSERT INTO @database_schema.@table @sub_query;
+      }
+      "
       SqlRender::render(outerSql,
                         sub_query = gsub(";", "", sql),
-                        database_schema = databaseSchema,
-                        table = SqlRender::snakeCaseToCamelCase(table))
-
+                        database_schema = targetDatabaseSchema,
+                        create = dropExistingTables | !tableExists,
+                        table = mappedTable)
     }
 
     queryFunction <- function(sql, tableName) {
-      sql <- convertQuery(todo$sqlQueryFeatures, targetDatabaseSchema, tableName)
-      sql <- SqlRender::translate(sql = sql,
-                                  targetDialect = attr(connection, "dbms"),
-                                  oracleTempSchema = oracleTempSchema)
-      DatabaseConnector::renderTranslateExecuteSql(connection, sql, progressBar = FALSE, reportOverallTime = FALSE)
+      sql <- convertQuery(sql, targetDatabaseSchema, tableName)
+      DatabaseConnector::renderTranslateExecuteSql(connection,
+                                                   sql,
+                                                   tempEmulationSchema = oracleTempSchema,
+                                                   progressBar = FALSE,
+                                                   reportOverallTime = FALSE)
     }
 
   }
 
-  ParallelLogger::logInfo("Fetching data from server")
   start <- Sys.time()
   # Binary or non-aggregated features
   if (!is.null(todo$sqlQueryFeatures)) {
@@ -176,7 +193,7 @@ getDbDefaultCovariateData <- function(connection,
     }
   }
 
-  if (missing(targetCovariateTable) | is.null(targetCovariateTable)) {
+  if (missing(targetTables) | is.null(targetTables)) {
     attr(covariateData, "metaData") <- list()
     if (is.null(covariateData$covariates) && is.null(covariateData$covariatesContinuous)) {
       warning("No data found, probably because no covariates were specified.")
diff --git a/man/getDbDefaultCovariateData.Rd b/man/getDbDefaultCovariateData.Rd
index 1628d2ca..bf5c1b45 100644
--- a/man/getDbDefaultCovariateData.Rd
+++ b/man/getDbDefaultCovariateData.Rd
@@ -14,9 +14,8 @@ getDbDefaultCovariateData(
   rowIdField = "subject_id",
   covariateSettings,
   targetDatabaseSchema,
-  targetCovariateTable,
-  targetCovariateRefTable,
-  targetAnalysisRefTable,
+  targetTables = list(),
+  dropExistingTables = FALSE,
   aggregated = FALSE
 )
 }
@@ -51,16 +50,15 @@ is more than one period per person.}
 of the createCovariate functions, or a list of such objects.}
 
 \item{targetDatabaseSchema}{(Optional) The name of the database schema where the resulting covariates
-should be stored.}
+should be stored.  If not provided, results will be fetched to R.}
 
-\item{targetCovariateTable}{(Optional) The name of the table where the resulting covariates will
-be stored. If not provided, results will be fetched to R. The table can be 
-a permanent table in the \code{targetDatabaseSchema} or a temp table. If 
-it is a temp table, do not specify \code{targetDatabaseSchema}.}
+\item{targetTables}{(Optional) list of mappings for table names.
+The names of the table where the resulting covariates will be if
+\code{targetDatabaseSchema} is specified. The tables will be created in permanent
+table in the \code{targetDatabaseSchema}.}
 
-\item{targetCovariateRefTable}{(Optional) The name of the table where the covariate reference will be stored.}
-
-\item{targetAnalysisRefTable}{(Optional) The name of the table where the analysis reference will be stored.}
+\item{dropExistingTables}{If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
+into existing table data.}
 
 \item{aggregated}{Should aggregate statistics be computed instead of covariates per
 cohort entry?}
diff --git a/tests/testthat/test-GetDefaultCovariates.R b/tests/testthat/test-GetDefaultCovariates.R
index 814ccfc3..bd3d9096 100644
--- a/tests/testthat/test-GetDefaultCovariates.R
+++ b/tests/testthat/test-GetDefaultCovariates.R
@@ -6,39 +6,27 @@ connectionDetails <- Eunomia::getEunomiaConnectionDetails()
 
 test_that("Test exit conditions", {
   connection <- DatabaseConnector::connect(connectionDetails)
-  
+
   # covariateSettings object type
   expect_error(getDbDefaultCovariateData(connection = connection,
                                          cdmDatabaseSchema = "main",
                                          covariateSettings = list(),
                                          targetDatabaseSchema = "main",
-                                         targetCovariateTable = "cov",
-                                         targetCovariateRefTable = "cov_ref",
-                                         targetAnalysisRefTable = "cov_analysis_ref"))
+                                         targetTables = list(covariates = "cov",
+                                                             covariateRef = "cov_ref",
+                                                             analysisRef = "cov_analysis_ref")))
   # CDM 4 not supported
   expect_error(getDbDefaultCovariateData(connection = connection,
                                          cdmDatabaseSchema = "main",
                                          cdmVersion = "4",
                                          covariateSettings = createDefaultCovariateSettings(),
                                          targetDatabaseSchema = "main",
-                                         targetCovariateTable = "cov",
-                                         targetCovariateRefTable = "cov_ref",
-                                         targetAnalysisRefTable = "cov_analysis_ref"))
-  
-  # targetCovariateTable and aggregated not supported
-  expect_error(getDbDefaultCovariateData(connection = connection,
-                                         cdmDatabaseSchema = "main",
-                                         covariateSettings = createDefaultCovariateSettings(),
-                                         targetDatabaseSchema = "main",
-                                         targetCovariateTable = "cov",
-                                         targetCovariateRefTable = "cov_ref",
-                                         targetAnalysisRefTable = "cov_analysis_ref",
-                                         aggregated = TRUE))
-  
-  on.exit(DatabaseConnector::disconnect(connection))  
+                                         targetTables = list(covariates = "cov",
+                                                             covariateRef = "cov_ref",
+                                                             analysisRef = "cov_analysis_ref")))
+  on.exit(DatabaseConnector::disconnect(connection))
 })
 
-# AGS - This test fails and is likely due to a bug when using SqlLite
 test_that("Test target table", {
   connection <- DatabaseConnector::connect(connectionDetails)
   Eunomia::createCohorts(connectionDetails)
@@ -48,9 +36,27 @@ test_that("Test target table", {
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
                                        targetDatabaseSchema = "main",
-                                       targetCovariateTable = "ut_cov",
-                                       targetCovariateRefTable = "ut_cov_ref",
-                                       targetAnalysisRefTable = "ut_cov_analysis_ref")
+                                       targetTables = list(covariates = "ut_cov",
+                                                           covariateRef = "ut_cov_ref",
+                                                           analysisRef = "ut_cov_analysis_ref"))
+
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_ref")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref")[1], 1)
+
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       targetDatabaseSchema = "main",
+                                       aggregated = TRUE,
+                                       targetTables = list(covariates = "ut_cov_agg",
+                                                           covariateRef = "ut_cov_ref_agg",
+                                                           analysisRef = "ut_cov_analysis_ref_agg"))
+
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref_agg")[1], 1)
 
   DatabaseConnector::disconnect(connection)
 })

From 4ecc262debf33daaa269ea2a4321b8c1bd29879d Mon Sep 17 00:00:00 2001
From: Jamie Gilbert <JGilber2@its.jnj.com>
Date: Thu, 13 Jan 2022 09:33:36 -0800
Subject: [PATCH 3/8] Fixes, restoration of old parameters and adaptation to
 use temp tables

---
 .Rbuildignore                              |  2 +
 DESCRIPTION                                |  2 +-
 R/GetDefaultCovariates.R                   | 81 ++++++++++++++--------
 man/getDbDefaultCovariateData.Rd           | 24 ++++++-
 tests/testthat/test-GetDefaultCovariates.R | 30 +++++++-
 5 files changed, 105 insertions(+), 34 deletions(-)

diff --git a/.Rbuildignore b/.Rbuildignore
index 12007bba..2daec274 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -1,3 +1,5 @@
+^renv$
+^renv\.lock$
 pom.xml
 extras
 docs
diff --git a/DESCRIPTION b/DESCRIPTION
index 576a8b36..348766b5 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -42,5 +42,5 @@ Suggests:
 Remotes:
   ohdsi/Eunomia
 NeedsCompilation: no
-RoxygenNote: 7.1.1
+RoxygenNote: 7.1.2
 Encoding: UTF-8
diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index 57ca78b6..a6a63519 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -28,7 +28,18 @@
 #' @param targetTables           (Optional) list of mappings for table names.
 #'                               The names of the table where the resulting covariates will be if
 #'                               \code{targetDatabaseSchema} is specified. The tables will be created in permanent
-#'                               table in the \code{targetDatabaseSchema}.
+#'                               table in the \code{targetDatabaseSchema} or as temporary tables. Tables that can be
+#'                               included in this list: covariates, covariateRef, analysisRef, covariatesContinuous,
+#'                               timeRef
+#' @param targetCovariateTable  (Optional) The name of the table where the resulting covariates will
+#'                               be stored. If not provided, results will be fetched to R. The table can be
+#'                               a permanent table in the \code{targetDatabaseSchema} or a temp table. If
+#'                               it is a temp table, do not specify \code{targetDatabaseSchema}.
+#'                               Superseded by \code{targetTables}
+#' @param targetCovariateRefTable (Optional) The name of the table where the covariate reference will be stored.
+#'                               Superseded by \code{targetTables}
+#' @param targetAnalysisRefTable (Optional) The name of the table where the analysis reference will be stored.
+#'                               Superseded by \code{targetTables}
 #' @param dropExistingTables     If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
 #'                               into existing table data.
 #' @template GetCovarParams
@@ -42,8 +53,15 @@ getDbDefaultCovariateData <- function(connection,
                                       cdmVersion = "5",
                                       rowIdField = "subject_id",
                                       covariateSettings,
-                                      targetDatabaseSchema,
-                                      targetTables = list(),
+                                      targetDatabaseSchema = NULL,
+                                      targetCovariateTable = NULL,
+                                      targetCovariateRefTable = NULL,
+                                      targetAnalysisRefTable = NULL,
+                                      targetTables = list(
+                                        covariates = targetCovariateTable,
+                                        covariateRef = targetCovariateRefTable,
+                                        analysisRef = targetAnalysisRefTable
+                                      ),
                                       dropExistingTables = FALSE,
                                       aggregated = FALSE) {
   if (!is(covariateSettings, "covariateSettings")) {
@@ -77,8 +95,9 @@ getDbDefaultCovariateData <- function(connection,
                               oracleTempSchema = oracleTempSchema)
   profile <- (!is.null(getOption("dbProfile")) && getOption("dbProfile") == TRUE)
   DatabaseConnector::executeSql(connection, sql, profile = profile)
-
-  if (missing(targetDatabaseSchema) | is.null(targetDatabaseSchema)) {
+  # Is the target schema missing or are all the specified tables temp
+  allTempTables <- all(substr(targetTables,1,1) == "#")
+  if ((missing(targetDatabaseSchema) | is.null(targetDatabaseSchema)) & !allTempTables) {
     # Save to Andromeda
     covariateData <- Andromeda::andromeda()
 
@@ -95,38 +114,46 @@ getDbDefaultCovariateData <- function(connection,
     ParallelLogger::logInfo("Creating tables on server")
     existingTables <- DatabaseConnector::getTableNames(connection, targetDatabaseSchema)
 
-    convertQuery <- function(sql, targetDatabaseSchema, table) {
-      mappedTable <- targetTables[[table]]
-      if (is.null(mappedTable)) {
-        mappedTable <- SqlRender::camelCaseToSnakeCase(table)
-      }
-      tableExists <- mappedTable %in% existingTables
-
-      if (!dropExistingTables & tableExists) {
-        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
-      } else {
-        ParallelLogger::logInfo("Creating table ", mappedTable, "for ", table)
-      }
-
+    convertQuery <- function(sql, table, tableExists) {
       outerSql <- "
       {@create} ? {
-      IF OBJECT_ID('@database_schema.@table', 'U') IS NOT NULL
-	        DROP TABLE @database_schema.@table;
+      IF OBJECT_ID('@table', 'U') IS NOT NULL
+          DROP TABLE @table;
 
-      SELECT * INTO @database_schema.@table FROM ( @sub_query ) sq;
+      SELECT * INTO @table FROM ( @sub_query ) sq;
       } : {
-      INSERT INTO @database_schema.@table @sub_query;
+      INSERT INTO @table @sub_query;
       }
       "
       SqlRender::render(outerSql,
                         sub_query = gsub(";", "", sql),
-                        database_schema = targetDatabaseSchema,
                         create = dropExistingTables | !tableExists,
-                        table = mappedTable)
+                        table = table)
     }
 
-    queryFunction <- function(sql, tableName) {
-      sql <- convertQuery(sql, targetDatabaseSchema, tableName)
+    queryFunction <- function(sql, table) {
+      mappedTable <- targetTables[[table]]
+      if (is.null(mappedTable)) {
+        if (allTempTables) {
+          # Only bother storing specified temp tables
+          ParallelLogger::logInfo("Skipping", table, " other mapped tables are temp")
+          return(NULL)
+        }
+        mappedTable <- SqlRender::camelCaseToSnakeCase(table)
+      }
+      tableExists <- mappedTable %in% existingTables
+
+      if (substr(mappedTable, 1, 1) != "#") {
+        mappedTable <- paste0(targetDatabaseSchema, ".", mappedTable)
+      }
+
+      if (!dropExistingTables & tableExists) {
+        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
+      } else {
+        ParallelLogger::logInfo("Creating table ", mappedTable, " for ", table)
+      }
+
+      sql <- convertQuery(sql, mappedTable, tableExists)
       DatabaseConnector::renderTranslateExecuteSql(connection,
                                                    sql,
                                                    tempEmulationSchema = oracleTempSchema,
@@ -193,7 +220,7 @@ getDbDefaultCovariateData <- function(connection,
     }
   }
 
-  if (missing(targetTables) | is.null(targetTables)) {
+  if ((missing(targetDatabaseSchema) | is.null(targetDatabaseSchema)) & !allTempTables) {
     attr(covariateData, "metaData") <- list()
     if (is.null(covariateData$covariates) && is.null(covariateData$covariatesContinuous)) {
       warning("No data found, probably because no covariates were specified.")
diff --git a/man/getDbDefaultCovariateData.Rd b/man/getDbDefaultCovariateData.Rd
index bf5c1b45..c1ad6a80 100644
--- a/man/getDbDefaultCovariateData.Rd
+++ b/man/getDbDefaultCovariateData.Rd
@@ -13,8 +13,12 @@ getDbDefaultCovariateData(
   cdmVersion = "5",
   rowIdField = "subject_id",
   covariateSettings,
-  targetDatabaseSchema,
-  targetTables = list(),
+  targetDatabaseSchema = NULL,
+  targetCovariateTable = NULL,
+  targetCovariateRefTable = NULL,
+  targetAnalysisRefTable = NULL,
+  targetTables = list(covariates = targetCovariateTable, covariateRef =
+    targetCovariateRefTable, analysisRef = targetAnalysisRefTable),
   dropExistingTables = FALSE,
   aggregated = FALSE
 )
@@ -52,10 +56,24 @@ of the createCovariate functions, or a list of such objects.}
 \item{targetDatabaseSchema}{(Optional) The name of the database schema where the resulting covariates
 should be stored.  If not provided, results will be fetched to R.}
 
+\item{targetCovariateTable}{(Optional) The name of the table where the resulting covariates will
+be stored. If not provided, results will be fetched to R. The table can be
+a permanent table in the \code{targetDatabaseSchema} or a temp table. If
+it is a temp table, do not specify \code{targetDatabaseSchema}.
+Superseded by \code{targetTables}}
+
+\item{targetCovariateRefTable}{(Optional) The name of the table where the covariate reference will be stored.
+Superseded by \code{targetTables}}
+
+\item{targetAnalysisRefTable}{(Optional) The name of the table where the analysis reference will be stored.
+Superseded by \code{targetTables}}
+
 \item{targetTables}{(Optional) list of mappings for table names.
 The names of the table where the resulting covariates will be if
 \code{targetDatabaseSchema} is specified. The tables will be created in permanent
-table in the \code{targetDatabaseSchema}.}
+table in the \code{targetDatabaseSchema} or as temporary tables. Tables that can be
+included in this list: covariates, covariateRef, analysisRef, covariatesContinuous,
+timeRef}
 
 \item{dropExistingTables}{If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
 into existing table data.}
diff --git a/tests/testthat/test-GetDefaultCovariates.R b/tests/testthat/test-GetDefaultCovariates.R
index bd3d9096..61eca2d3 100644
--- a/tests/testthat/test-GetDefaultCovariates.R
+++ b/tests/testthat/test-GetDefaultCovariates.R
@@ -6,7 +6,7 @@ connectionDetails <- Eunomia::getEunomiaConnectionDetails()
 
 test_that("Test exit conditions", {
   connection <- DatabaseConnector::connect(connectionDetails)
-
+  on.exit(DatabaseConnector::disconnect(connection))
   # covariateSettings object type
   expect_error(getDbDefaultCovariateData(connection = connection,
                                          cdmDatabaseSchema = "main",
@@ -24,11 +24,11 @@ test_that("Test exit conditions", {
                                          targetTables = list(covariates = "cov",
                                                              covariateRef = "cov_ref",
                                                              analysisRef = "cov_analysis_ref")))
-  on.exit(DatabaseConnector::disconnect(connection))
 })
 
 test_that("Test target table", {
   connection <- DatabaseConnector::connect(connectionDetails)
+  on.exit(DatabaseConnector::disconnect(connection))
   Eunomia::createCohorts(connectionDetails)
 
   results <- getDbDefaultCovariateData(connection = connection,
@@ -58,7 +58,31 @@ test_that("Test target table", {
   expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_ref_agg")[1], 1)
   expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref_agg")[1], 1)
 
-  DatabaseConnector::disconnect(connection)
+  # Temp tables with old prototype
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       aggregated = TRUE,
+                                       targetCovariateTable = "#ut_cov_agg",
+                                       targetAnalysisRefTable = "#ut_cov_ref_agg",
+                                       targetCovariateRefTable = "#ut_cov_anal_ref_agg")
+
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_anal_ref_agg")[1], 1)
+
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       targetCovariateTable = "#ut_cov",
+                                       targetAnalysisRefTable = "#ut_cov_ref",
+                                       targetCovariateRefTable = "#ut_cov_analysis_ref")
+
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], 1)
 })
 
 unlink(connectionDetails$server())
\ No newline at end of file

From e29ff8d7576fe3b549be5b1e82197c8170d18083 Mon Sep 17 00:00:00 2001
From: Jamie Gilbert <JGilber2@its.jnj.com>
Date: Thu, 13 Jan 2022 14:05:56 -0800
Subject: [PATCH 4/8] Creating/dropping or appending results checked. Added
 details to news

---
 NEWS.md                                    | 12 +++++++
 R/GetDefaultCovariates.R                   | 35 ++++++++++---------
 man/getDbDefaultCovariateData.Rd           |  9 +++--
 tests/testthat/test-GetDefaultCovariates.R | 39 ++++++++++++++++++++--
 4 files changed, 74 insertions(+), 21 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 0fd1669a..bd008137 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,15 @@
+FeatureExtraction 3.2.1
+=======================
+
+New Features:
+
+- Added ability to store aggregate results from `getDbDefaultCovariateData` in the database and added
+ability to control all target tables with new `targetTables` list parameter
+
+Bugfixes:
+
+- Fixed tests and made sure storage of covariates with `getDbDefaultCovariateData` works and is consistent
+
 FeatureExtraction 3.2.0
 =======================
 
diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index a6a63519..53f3283a 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -40,8 +40,9 @@
 #'                               Superseded by \code{targetTables}
 #' @param targetAnalysisRefTable (Optional) The name of the table where the analysis reference will be stored.
 #'                               Superseded by \code{targetTables}
-#' @param dropExistingTables     If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
-#'                               into existing table data.
+#' @param dropTableIfExists      If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
+#'                               into existing table data. Overides createTable.
+#' @param createTable            Run sql to create table? Code does not check if table exists.
 #' @template GetCovarParams
 #'
 #' @export
@@ -62,7 +63,8 @@ getDbDefaultCovariateData <- function(connection,
                                         covariateRef = targetCovariateRefTable,
                                         analysisRef = targetAnalysisRefTable
                                       ),
-                                      dropExistingTables = FALSE,
+                                      dropTableIfExists = FALSE,
+                                      createTable = TRUE,
                                       aggregated = FALSE) {
   if (!is(covariateSettings, "covariateSettings")) {
     stop("Covariate settings object not of type covariateSettings")
@@ -110,16 +112,19 @@ getDbDefaultCovariateData <- function(connection,
     }
     ParallelLogger::logInfo("Fetching data from server")
   } else {
+
+    if (dropTableIfExists) {
+      createTable <- TRUE
+    }
     # Save to DB
     ParallelLogger::logInfo("Creating tables on server")
-    existingTables <- DatabaseConnector::getTableNames(connection, targetDatabaseSchema)
-
-    convertQuery <- function(sql, table, tableExists) {
+    convertQuery <- function(sql, table) {
       outerSql <- "
-      {@create} ? {
-      IF OBJECT_ID('@table', 'U') IS NOT NULL
+      {@drop} ? {
+        IF OBJECT_ID('@table', 'U') IS NOT NULL
           DROP TABLE @table;
-
+      }
+      {@create} ? {
       SELECT * INTO @table FROM ( @sub_query ) sq;
       } : {
       INSERT INTO @table @sub_query;
@@ -127,7 +132,8 @@ getDbDefaultCovariateData <- function(connection,
       "
       SqlRender::render(outerSql,
                         sub_query = gsub(";", "", sql),
-                        create = dropExistingTables | !tableExists,
+                        create = createTable,
+                        drop = dropTableIfExists,
                         table = table)
     }
 
@@ -141,19 +147,18 @@ getDbDefaultCovariateData <- function(connection,
         }
         mappedTable <- SqlRender::camelCaseToSnakeCase(table)
       }
-      tableExists <- mappedTable %in% existingTables
 
       if (substr(mappedTable, 1, 1) != "#") {
         mappedTable <- paste0(targetDatabaseSchema, ".", mappedTable)
       }
 
-      if (!dropExistingTables & tableExists) {
-        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
-      } else {
+      if (createTable) {
         ParallelLogger::logInfo("Creating table ", mappedTable, " for ", table)
+      } else {
+        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
       }
 
-      sql <- convertQuery(sql, mappedTable, tableExists)
+      sql <- convertQuery(sql, mappedTable)
       DatabaseConnector::renderTranslateExecuteSql(connection,
                                                    sql,
                                                    tempEmulationSchema = oracleTempSchema,
diff --git a/man/getDbDefaultCovariateData.Rd b/man/getDbDefaultCovariateData.Rd
index c1ad6a80..a69f99a8 100644
--- a/man/getDbDefaultCovariateData.Rd
+++ b/man/getDbDefaultCovariateData.Rd
@@ -19,7 +19,8 @@ getDbDefaultCovariateData(
   targetAnalysisRefTable = NULL,
   targetTables = list(covariates = targetCovariateTable, covariateRef =
     targetCovariateRefTable, analysisRef = targetAnalysisRefTable),
-  dropExistingTables = FALSE,
+  dropTableIfExists = FALSE,
+  createTable = TRUE,
   aggregated = FALSE
 )
 }
@@ -75,8 +76,10 @@ table in the \code{targetDatabaseSchema} or as temporary tables. Tables that can
 included in this list: covariates, covariateRef, analysisRef, covariatesContinuous,
 timeRef}
 
-\item{dropExistingTables}{If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
-into existing table data.}
+\item{dropTableIfExists}{If targetDatabaseSchema, drop any existing tables. Otherwise, results are merged
+into existing table data. Overides createTable.}
+
+\item{createTable}{Run sql to create table? Code does not check if table exists.}
 
 \item{aggregated}{Should aggregate statistics be computed instead of covariates per
 cohort entry?}
diff --git a/tests/testthat/test-GetDefaultCovariates.R b/tests/testthat/test-GetDefaultCovariates.R
index 61eca2d3..45508430 100644
--- a/tests/testthat/test-GetDefaultCovariates.R
+++ b/tests/testthat/test-GetDefaultCovariates.R
@@ -80,9 +80,42 @@ test_that("Test target table", {
                                        targetAnalysisRefTable = "#ut_cov_ref",
                                        targetCovariateRefTable = "#ut_cov_analysis_ref")
 
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], 1)
+  covCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1]
+  expect_gt(covCt, 1)
+  covRefCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1]
+  expect_gt(covRefCt, 1)
+  anlRefCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1]
+  expect_gt(anlRefCt, 1)
+
+  # append results rather than deleting the tables
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       createTable = FALSE,
+                                       dropTableIfExists = FALSE,
+                                       targetCovariateTable = "#ut_cov",
+                                       targetAnalysisRefTable = "#ut_cov_ref",
+                                       targetCovariateRefTable = "#ut_cov_analysis_ref")
+
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt * 2)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt * 2)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt * 2)
+
+  # Recreate tables (and check create override works)
+  results <- getDbDefaultCovariateData(connection = connection,
+                                       cdmDatabaseSchema = "main",
+                                       cohortTable = "cohort",
+                                       covariateSettings = createDefaultCovariateSettings(),
+                                       createTable = FALSE,
+                                       dropTableIfExists = TRUE,
+                                       targetCovariateTable = "#ut_cov",
+                                       targetAnalysisRefTable = "#ut_cov_ref",
+                                       targetCovariateRefTable = "#ut_cov_analysis_ref")
+
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt)
 })
 
 unlink(connectionDetails$server())
\ No newline at end of file

From 40cae543b94320e8a18c5f66972cb0f9d8f7e6dc Mon Sep 17 00:00:00 2001
From: Jamie Gilbert <JGilber2@its.jnj.com>
Date: Fri, 14 Jan 2022 08:25:49 -0800
Subject: [PATCH 5/8] whitespace

---
 R/GetDefaultCovariates.R                   | 2 +-
 vignettes/UsingFeatureExtractionKorean.Rmd | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index 53f3283a..170aaecd 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -155,7 +155,7 @@ getDbDefaultCovariateData <- function(connection,
       if (createTable) {
         ParallelLogger::logInfo("Creating table ", mappedTable, " for ", table)
       } else {
-        ParallelLogger::logInfo("Appending", table, " results to table ", mappedTable)
+        ParallelLogger::logInfo("Appending ", table, " results to table ", mappedTable)
       }
 
       sql <- convertQuery(sql, mappedTable)
diff --git a/vignettes/UsingFeatureExtractionKorean.Rmd b/vignettes/UsingFeatureExtractionKorean.Rmd
index 5bd5a3b4..3dfaa4ef 100644
--- a/vignettes/UsingFeatureExtractionKorean.Rmd
+++ b/vignettes/UsingFeatureExtractionKorean.Rmd
@@ -409,8 +409,7 @@ aggregated = TRUE로 지정했다. 또한 더 이상 personId 데이터를 받
 ### 집계 공변량 출력 형식
 
 집합 된 covariateData 객체의 두 가지 주요 구성 요소는 각각 이진 및 연속 공변량에 대한 공변량 및 공변 연속이다.
-
- ```{r eval=FALSE}
+```{r eval=FALSE}
 covariateData2$covariates
 ```
 ```{r echo=FALSE,message=FALSE}

From e118c5dced7bfcc137bfc44b6a037b6166f324fe Mon Sep 17 00:00:00 2001
From: Anthony Sena <asena5@its.jnj.com>
Date: Thu, 29 Jan 2026 14:39:10 -0500
Subject: [PATCH 6/8] Fix merge problems

---
 DESCRIPTION                                |  2 +-
 R/GetDefaultCovariates.R                   |  3 +-
 man/getDbDefaultCovariateData.Rd           |  9 ++--
 tests/testthat/setup.R                     |  1 +
 tests/testthat/test-GetDefaultCovariates.R | 57 ++++++++++------------
 5 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 4c1e6a34..8092ca01 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -46,6 +46,6 @@ VignetteBuilder: knitr
 URL: https://github.com/OHDSI/FeatureExtraction
 BugReports: https://github.com/OHDSI/FeatureExtraction/issues
 NeedsCompilation: no
-RoxygenNote: 7.3.2
+RoxygenNote: 7.3.3
 Encoding: UTF-8
 Language: en-US
diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index b8833c00..be70da92 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -280,8 +280,7 @@ getDbDefaultCovariateData <- function(connection,
     }
   }
 
-  if (missing(targetCovariateTable) || is.null(targetCovariateTable)) {
-  if ((missing(targetDatabaseSchema) | is.null(targetDatabaseSchema)) & !allTempTables) {
+  if ((missing(targetDatabaseSchema) || is.null(targetDatabaseSchema)) & !allTempTables) {
     attr(covariateData, "metaData") <- list()
     if (is.null(covariateData$covariates) && is.null(covariateData$covariatesContinuous)) {
       warning("No data found, probably because no covariates were specified.")
diff --git a/man/getDbDefaultCovariateData.Rd b/man/getDbDefaultCovariateData.Rd
index df01e238..65187c73 100644
--- a/man/getDbDefaultCovariateData.Rd
+++ b/man/getDbDefaultCovariateData.Rd
@@ -73,8 +73,7 @@ Superseded by \code{targetTables}}
 \item{targetCovariateRefTable}{(Optional) The name of the table where the covariate reference will be stored.
 Superseded by \code{targetTables}}
 
-\item{targetAnalysisRefTable}{(Optional) The name of the table where the analysis reference will be stored.
-Superseded by \code{targetTables}}
+\item{targetAnalysisRefTable}{(Optional) The name of the table where the analysis reference will be stored.}
 
 \item{targetTables}{(Optional) list of mappings for table names.
 The names of the table where the resulting covariates will be if
@@ -92,8 +91,10 @@ into existing table data. Overides createTable.}
 cohort entry?}
 
 \item{minCharacterizationMean}{The minimum mean value for binary characterization output. Values below this will be cut off from output. This
-will help reduce the file size of the characterization output, but will remove information
-on covariates that have very low values. The default is 0.}
+                               will help reduce the file size of the characterization output, but will remove information
+                               on covariates that have very low values. The default is 0.
+
+                              Superseded by \code{targetTables}}
 
 \item{tempEmulationSchema}{Some database platforms like Oracle and Impala do not truly support
 temp tables. To emulate temp tables, provide a schema with write
diff --git a/tests/testthat/setup.R b/tests/testthat/setup.R
index dd59bcfa..03bc7ece 100644
--- a/tests/testthat/setup.R
+++ b/tests/testthat/setup.R
@@ -217,6 +217,7 @@ if (dbms == "sql server") {
 # eunomia
 if (dbms == "sqlite") {
   if (!is.null(checkRemoteFileAvailable("https://raw.githubusercontent.com/OHDSI/EunomiaDatasets/main/datasets/GiBleed/GiBleed_5.3.zip"))) {
+    print('got here')
     eunomiaConnectionDetails <- Eunomia::getEunomiaConnectionDetails(databaseFile = "testEunomia.sqlite")
     eunomiaCdmDatabaseSchema <- "main"
     eunomiaOhdsiDatabaseSchema <- "main"
diff --git a/tests/testthat/test-GetDefaultCovariates.R b/tests/testthat/test-GetDefaultCovariates.R
index 1a01233c..8c674acd 100644
--- a/tests/testthat/test-GetDefaultCovariates.R
+++ b/tests/testthat/test-GetDefaultCovariates.R
@@ -43,11 +43,10 @@ test_that("Test exit conditions", {
 })
 
 test_that("Test target table", {
-  connection <- DatabaseConnector::connect(connectionDetails)
-  on.exit(DatabaseConnector::disconnect(connection))
-  Eunomia::createCohorts(connectionDetails)
-
-  results <- getDbDefaultCovariateData(connection = connection,
+  skip_on_cran()
+  skip_if_not(dbms == "sqlite" && exists("eunomiaConnection"))
+  
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -56,11 +55,11 @@ test_that("Test target table", {
                                                            covariateRef = "ut_cov_ref",
                                                            analysisRef = "ut_cov_analysis_ref"))
 
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_ref")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov_ref")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref")[1], 1)
 
-  results <- getDbDefaultCovariateData(connection = connection,
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -70,12 +69,12 @@ test_that("Test target table", {
                                                            covariateRef = "ut_cov_ref_agg",
                                                            analysisRef = "ut_cov_analysis_ref_agg"))
 
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_agg")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_ref_agg")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM main.ut_cov_analysis_ref_agg")[1], 1)
 
   # Temp tables with old prototype
-  results <- getDbDefaultCovariateData(connection = connection,
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -84,11 +83,11 @@ test_that("Test target table", {
                                        targetAnalysisRefTable = "#ut_cov_ref_agg",
                                        targetCovariateRefTable = "#ut_cov_anal_ref_agg")
 
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_agg")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref_agg")[1], 1)
-  expect_gt(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_anal_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_ref_agg")[1], 1)
+  expect_gt(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_anal_ref_agg")[1], 1)
 
-  results <- getDbDefaultCovariateData(connection = connection,
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -96,15 +95,15 @@ test_that("Test target table", {
                                        targetAnalysisRefTable = "#ut_cov_ref",
                                        targetCovariateRefTable = "#ut_cov_analysis_ref")
 
-  covCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1]
+  covCt <- DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov")[1]
   expect_gt(covCt, 1)
-  covRefCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1]
+  covRefCt <- DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_ref")[1]
   expect_gt(covRefCt, 1)
-  anlRefCt <- DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1]
+  anlRefCt <- DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1]
   expect_gt(anlRefCt, 1)
 
   # append results rather than deleting the tables
-  results <- getDbDefaultCovariateData(connection = connection,
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -114,12 +113,12 @@ test_that("Test target table", {
                                        targetAnalysisRefTable = "#ut_cov_ref",
                                        targetCovariateRefTable = "#ut_cov_analysis_ref")
 
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt * 2)
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt * 2)
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt * 2)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt * 2)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt * 2)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt * 2)
 
   # Recreate tables (and check create override works)
-  results <- getDbDefaultCovariateData(connection = connection,
+  results <- getDbDefaultCovariateData(connection = eunomiaConnection,
                                        cdmDatabaseSchema = "main",
                                        cohortTable = "cohort",
                                        covariateSettings = createDefaultCovariateSettings(),
@@ -129,9 +128,7 @@ test_that("Test target table", {
                                        targetAnalysisRefTable = "#ut_cov_ref",
                                        targetCovariateRefTable = "#ut_cov_analysis_ref")
 
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt)
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt)
-  expect_equal(DatabaseConnector::renderTranslateQuerySql(connection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov")[1], covCt)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_ref")[1], covRefCt)
+  expect_equal(DatabaseConnector::renderTranslateQuerySql(eunomiaConnection, "SELECT COUNT(*) FROM #ut_cov_analysis_ref")[1], anlRefCt)
 })
-
-unlink(connectionDetails$server())
\ No newline at end of file

From 2f29e94e566df5b27adabfe74b6a1a49311ff0cd Mon Sep 17 00:00:00 2001
From: Anthony Sena <asena5@its.jnj.com>
Date: Thu, 29 Jan 2026 15:56:41 -0500
Subject: [PATCH 7/8] Remove debugging message

---
 tests/testthat/setup.R | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/testthat/setup.R b/tests/testthat/setup.R
index 03bc7ece..dd59bcfa 100644
--- a/tests/testthat/setup.R
+++ b/tests/testthat/setup.R
@@ -217,7 +217,6 @@ if (dbms == "sql server") {
 # eunomia
 if (dbms == "sqlite") {
   if (!is.null(checkRemoteFileAvailable("https://raw.githubusercontent.com/OHDSI/EunomiaDatasets/main/datasets/GiBleed/GiBleed_5.3.zip"))) {
-    print('got here')
     eunomiaConnectionDetails <- Eunomia::getEunomiaConnectionDetails(databaseFile = "testEunomia.sqlite")
     eunomiaCdmDatabaseSchema <- "main"
     eunomiaOhdsiDatabaseSchema <- "main"

From 56c8d0630db2511175d57735894599891c321bc7 Mon Sep 17 00:00:00 2001
From: Anthony Sena <asena5@its.jnj.com>
Date: Thu, 29 Jan 2026 16:53:19 -0500
Subject: [PATCH 8/8] Restore warning for post-coordinated concept collision

---
 R/GetDefaultCovariates.R | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/R/GetDefaultCovariates.R b/R/GetDefaultCovariates.R
index be70da92..cd1554aa 100644
--- a/R/GetDefaultCovariates.R
+++ b/R/GetDefaultCovariates.R
@@ -152,13 +152,24 @@ getDbDefaultCovariateData <- function(connection,
     # Save to Andromeda
     covariateData <- Andromeda::andromeda()
 
-
     queryFunction <- function(sql, tableName) {
       DatabaseConnector::querySqlToAndromeda(connection = connection,
                                              sql = sql,
                                              andromeda = covariateData,
                                              andromedaTableName = tableName,
                                              snakeCaseToCamelCase = TRUE)
+      
+      if (tableName == "covariateRef") {
+        collisions <- covariateData$covariateRef %>%
+          dplyr::filter(collisions > 0) %>%
+          dplyr::collect()
+        if (nrow(collisions) > 0) {
+          warning(sprintf(
+            "Collisions in covariate IDs detected for post-coordinated concepts with covariate IDs %s",
+            paste(collisions$covariateId, paste = ", ")
+          ))
+        }      
+      }
     }
 
     ParallelLogger::logInfo("Fetching data from server")
@@ -167,6 +178,7 @@ getDbDefaultCovariateData <- function(connection,
     if (dropTableIfExists) {
       createTable <- TRUE
     }
+    
     # Save to DB
     ParallelLogger::logInfo("Creating tables on server")
     convertQuery <- function(sql, table) {