docs: def _get_tough_method(self, name):
          """Return a "tough" version of the given cursor method."""
          def tough_method(*args, **kwargs):
              execute = name.startswith('execute')
              con = self._con
              transaction = con._transaction
              if not transaction:
                  con._ping_check(4)
              try:
                  if con._maxusage:
                      if con._usage >= con._maxusage:
                          # the connection was used too often
                          raise con._failure
                  if execute:
                      self._setsizes()
                  method = getattr(self._cursor, name)
                  result = method(*args, **kwargs)  # try to execute
                  if execute:
                      self._clearsizes()
              except con._failures as error:  # execution error
                  if not transaction:
                      try:
                          cursor2 = con._cursor(
                              *self._args, **self._kwargs)  # open new cursor
                      except Exception:
                          pass
                      else:
                          try:  # and try one more time to execute
                              if execute:
                                  self._setsizes(cursor2)
                              method = getattr(cursor2, name)
                              result = method(*args, **kwargs)
                              if execute:
                                  self._clearsizes()
                          except Exception:
                              pass
                          else:
                              self.close()
                              self._cursor = cursor2
                              con._usage += 1
                              return result
                          try:
                              cursor2.close()
                          except Exception:
                              pass
                  try:  # try to reopen the connection
                      con2 = con._create()
                  except Exception:
                      pass
                  else:
                      try:
                          cursor2 = con2.cursor(
                              *self._args, **self._kwargs)  # open new cursor
                      except Exception:
                          pass
                      else:
                          if transaction:
                              self.close()
                              con._close()
                              con._store(con2)
                              self._cursor = cursor2
                              raise error  # raise the original error again
                          error2 = None
                          try:  # try one more time to execute
                              if execute:
                                  self._setsizes(cursor2)
                              method2 = getattr(cursor2, name)
                              result = method2(*args, **kwargs)
                              if execute:
                                  self._clearsizes()
                          except error.__class__:  # same execution error
                              use2 = False
                              error2 = error
                          except Exception as error:  # other execution errors
                              use2 = True
                              error2 = error
                          else:
                              use2 = True
                          if use2:
                              self.close()
                              con._close()
                              con._store(con2)
                              self._cursor = cursor2
                              con._usage += 1
                              if error2:
                                  raise error2  # raise the other error
                              return result
                          try:
                              cursor2.close()
                          except Exception:
                              pass
                      try:
                          con2.close()
                      except Exception:
                          pass
                  if transaction:
                      self._transaction = False
                  raise error  # re-raise the original error again
              else:
                  con._usage += 1
                  return result
          return tough_method