StoredProcedure: procedimiento almacenado de SQL Server: generador de clases

StoredProcedure: genera un objeto de procedimiento almacenado SQLServer y, opcionalmente, un archivo .sql que contiene una consulta para crear un procedimiento almacenado. StoredProcedure$registrationVec contiene cadenas que representan las consultas necesarias para la creación del procedimiento almacenado.

Uso

  StoredProcedure (func, spName, ..., filePath = NULL ,dbName = NULL,
  connectionString = NULL, batchSeparator = "GO")

Argumentos

func

Una función de R válida o un nombre de cadena de una función de R válida: 1) Todas las variables en las que se basa la función deben definirse dentro de la función o incluirse como parámetros de entrada. Entre los parámetros de entrada puede haber como máximo 1 trama de datos 2) La función debe devolver una trama de datos, una lista con nombre o NULL. Puede haber como máximo una trama de datos dentro de la lista.

spName

Una cadena de caracteres que especifica el nombre del procedimiento almacenado.

...

Parámetros de entrada y salida opcionales para el procedimiento almacenado; deben ser objetos de las clases InputData, InputParameter o outputParameter.

filePath

Cadena de caracteres que especifica una ruta de acceso al directorio en el que se va a crear el archivo .sql. Si es NULL, no se genera el archivo .sql.

dbName

Cadena de caracteres que especifica el nombre de la base de datos que se usará.

connectionString

Cadena de caracteres que especifica la cadena de conexión.

batchSeparator

Separador por lotes SQL deseado (solo pertinente si se define filePath)

Value

Objeto de procedimiento almacenado SQLServer

Ejemplos

 ## Not run:

 ############# Example 1 #############
 # etl1 - reads from and write directly to the database
 etl1 <- function() {
   # The query to get the data
   qq <- "select top 10000 ArrDelay,CRSDepTime,DayOfWeek from AirlineDemoSmall"
   # The connection string
   conStr <- paste("Driver={ODBC Driver 13 for SQL Server};Server=.;Database=RevoTestDB;",
                 "Trusted_Connection=Yes;", sep = "")
   # The data source - retrieves the data from the database
   dsSqls <- RxSqlServerData(sqlQuery=qq, connectionString=conStr)
   # The destination data source
   dsSqls2 <- RxSqlServerData(table ="cleanData",  connectionString = conStr)
   # A transformation function
   transformFunc <- function(data) {
     data$CRSDepHour <- as.integer(trunc(data$CRSDepTime))
     return(data)
   }
   # The transformation variables
   transformVars <- c("CRSDepTime")
   rxDataStep(inData = dsSqls,
              outFile = dsSqls2,
              transformFunc=transformFunc,
              transformVars=transformVars,
              overwrite = TRUE)
   return(NULL)
 }
 # Create a StoredProcedure object
 sp_ds_ds <- StoredProcedure(etl1, "spTest",
                        filePath = ".", dbName ="RevoTestDB")
 # Define a connection string
 conStr <- paste("Driver={ODBC Driver 13 for SQL Server};Server=.;Database=RevoTestDB;",
                 "Trusted_Connection=Yes;", sep = "")
 # register the stored procedure with a database
 registerStoredProcedure(sp_ds_ds, conStr)
 # execute the stored procedure
 executeStoredProcedure(sp_ds_ds, connectionString = conStr)


 ############# Example 2 #############
 # train 1 takes a data frame with clean data and outputs a model
 train1 <- function(in_df) {
   in_df[,"DayOfWeek"] <- factor(in_df[,"DayOfWeek"], levels=c("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"))
   # The model formula
   formula <- ArrDelay ~ CRSDepTime + DayOfWeek + CRSDepHour:DayOfWeek
   # Train the model
   rxSetComputeContext("local")
   mm <- rxLinMod(formula, data=in_df)
   mm <- rxSerializeModel(mm)
   return(list("mm" = mm))
 }
 # create InpuData Object for an input parameter that is a data frame
 # note: if the input parameter is not a data frame use InputParameter object
 id <- InputData(name = "in_df",
                defaultQuery = paste0("select top 10000 ArrDelay,CRSDepTime,",
                                      "DayOfWeek,CRSDepHour from cleanData"))
 # create an OutputParameter object for the variable inside the return list
 # note: if that variable is a data frame use OutputData object
 out <- OutputParameter("mm", "raw")

 # connections string
 conStr <- paste0("Driver={ODBC Driver 13 for SQL Server};Server=.;Database=RevoTestDB;",
                  "Trusted_Connection=Yes;")
 # create the stored procedure object
 sp_df_op <- StoredProcedure("train1", "spTest1", id, out,
                        filePath = ".")
 # register the stored procedure with the database
 registerStoredProcedure(sp_df_op, conStr)

 # get the linear model
 model <- executeStoredProcedure(sp_df_op, connectionString = conStr)
 mm <- rxUnserializeModel(model$params$op1)
## End(Not run)