Как повторить заявление об ошибке?

Question

Как я могу просто сказать R повторить оператор несколько раз, если он ошибается? Например, я надеялся сделать что-то вроде:

tryCatch(dbGetQuery(...),           # Query database
    error = function(e) {
        if (is.locking.error(e))    # If database is momentarily locked
            retry(times = 3)        # retry dbGetQuery(...) 3 more times
        else {
            # Handle other errors
        }
    }
)

Answer 1

Я обычно ставлю try заблокировать в цикле и выйти из цикла, если он больше не дает сбоя или достигнуто максимальное количество попыток.

some_function_that_may_fail <- function() {
  if( runif(1) < .5 ) stop()
  return(1)
}

r <- NULL
attempt <- 1
while( is.null(r) && attempt <= 3 ) {
  attempt <- attempt + 1
  try(
    r <- some_function_that_may_fail()
  )
} 

Answer 2

Я написал быструю функцию, которая позволяет вам легко повторить попытку работы настраиваемое число раз с настраиваемым ожиданием между попытками:

library(futile.logger)
library(utils)

retry <- function(expr, isError=function(x) "try-error" %in% class(x), maxErrors=5, sleep=0) {
  attempts = 0
  retval = try(eval(expr))
  while (isError(retval)) {
    attempts = attempts + 1
    if (attempts >= maxErrors) {
      msg = sprintf("retry: too many retries [[%s]]", capture.output(str(retval)))
      flog.fatal(msg)
      stop(msg)
    } else {
      msg = sprintf("retry: error in attempt %i/%i [[%s]]", attempts, maxErrors, 
                    capture.output(str(retval)))
      flog.error(msg)
      warning(msg)
    }
    if (sleep > 0) Sys.sleep(sleep)
    retval = try(eval(expr))
  }
  return(retval)
}

Так что вы можете просто написать val = retry(func_that_might_fail(param1, param2), maxErrors=10, sleep=2) повторить вызов этой функции с этими параметрами, отказаться после 10 ошибок и поспать 2 секунды между попытками.

Кроме того, вы можете переопределить значение ошибки, передав в качестве параметра другую функцию isError, который по умолчанию будет ловить ошибку, сообщенную stop, Это полезно, если вызываемая функция делает что-то еще в случае ошибки, например, возвращает FALSE или же NULL,

Это альтернатива, которую я нашел до сих пор, которая приводит к более ясному и читабельному коду.

Надеюсь это поможет.

Answer 3

Решение без предварительного присвоения значений и использования for вместо while:

some_function_that_may_fail <- function(i) {
  if( runif(1) < .5 ) stop()
  return(i)
}

for(i in 1:10){
  try({
    r <- some_function_that_may_fail(i)
    break #break/exit the for-loop
  }, silent = FALSE)
}

r будет равно количеству попыток, которые были необходимы. Если вы не хотите вывод ошибок silent в TRUE

Answer 4

Вот функция для генерации пользовательского условия для ответа на

locked <- function(message="occurred", ...) {
    cond <- simpleCondition(message, ...)
    class(cond) <- c("locked", class(cond))
    cond
}

и реализована функция, позволяющая (бесконечное число) перезапусков

f <- function() {
    cnt <- 0L
    repeat {
        again <- FALSE
        cnt <- cnt + 1L
        withRestarts({
            ## do work here, and if needed...
            signalCondition(locked())
        }, retry=function() {
            again <<- TRUE
        })
        if (!again) break
    }
    cnt
}

и использование withCallingHandlers (чтобы сохранить контекст, где условие было сигнализировано активным в отличие от tryCatch) чтобы справиться с locked состояние

withCallingHandlers({
    n_tries <- 0L
    f()
}, locked=function(e) {
    n_tries <<- n_tries + 1L
    if (n_retries < 3)
        invokeRestart("retry")
})

Answer 5

Я собрал код и упаковал его: повторить попытку

f <- function(x) {
    if (runif(1) < 0.9) {
        stop("random error")
    }
    x + 1
}

# keep retring when there is a random error
retry::retry(f(1), when = "random error")
#> [1] 2
# keep retring until a requirement is satisified.
retry::retry(f(1), until = function(val, cnd) val == 2)
#> [1] 2
# or using one sided formula
retry::retry(f(1), until = ~ . == 2, max_tries = 10)
#> [1] 2

Answer 6

Мне нравится устанавливать свой объект как ошибку с самого начала, также иногда полезно добавить некоторое время сна, если у вас проблемы с подключением:

res <- simpleError("Fake error to start")
counter <- 1
max_tries <- 10 
while(inherits(res, "error") | counter < max_tries) { 
  # Sys.sleep(2*counter)
  res <- tryCatch({ your_fun(...) }, 
      error = function(e) e)
  counter <- counter + 1
}