switch t := err.(type) {
        case *roachpb.TransactionRetryWithProtoRefreshError:
          errTxn := t.Transaction
          if errTxn.ID == curTxnID && errTxn.Epoch == curTxnEpoch {
            // A retryable error for the current transaction
            // incarnation is given the highest priority.
            return 1
          }
          return 2
        case *roachpb.TxnAlreadyEncounteredErrorError:
          // Another parallel stmt got an error that caused this one.
          return 5
        default:
          // Any other error. We sort these behind retryable errors
          // and errors we know to be their symptoms because it is
          // impossible to conclusively determine in all cases whether
          // one of these errors is a symptom of a concurrent retry or
          // not. If the error is a symptom then we want to ignore it.
          // If it is not, we expect to see the same error during a
          // transaction retry.
          return 4
        }

    switch err {
    case nil, errDidntUpdateDescriptor:
      return sqlbase.NewImmutableTableDescriptor(tableDesc.TableDescriptor), nil
    case errLeaseVersionChanged:
      // will loop around to retry
    default:
      return nil, err
    }

    switch err {
    case errRenewLease:
      // Renew lease and retry. This will block until the lease is acquired.
      if _, errLease := acquireNodeLease(ctx, m, tableID); errLease != nil {
        return nil, hlc.Timestamp{}, errLease
      }
      if m.testingKnobs.LeaseStoreTestingKnobs.LeaseAcquireResultBlockEvent != nil {
        m.testingKnobs.LeaseStoreTestingKnobs.LeaseAcquireResultBlockEvent(LeaseAcquireBlock)
      }

    case errReadOlderTableVersion:
      // Read old table versions from the store. This can block while reading
      // old table versions from the store.
      versions, errRead := m.readOlderVersionForTimestamp(ctx, tableID, timestamp)
      if errRead != nil {
        return nil, hlc.Timestamp{}, errRead
      }
      m.insertTableVersions(tableID, versions)

    default:
      return nil, hlc.Timestamp{}, err
    }

  switch err {
  case
    context.Canceled,
    context.DeadlineExceeded,
    errExistingSchemaChangeLease,
    errExpiredSchemaChangeLease,
    errNotHitGCTTLDeadline,
    errSchemaChangeDuringDrain,
    errSchemaChangeNotFirstInLine:
    return false
  }
  switch err := err.(type) {
  case errTableVersionMismatch:
    return false
  case *pgerror.Error:
    switch err.Code {
    case pgerror.CodeSerializationFailureError, pgerror.CodeConnectionFailureError:
      return false

    case pgerror.CodeInternalError:
      if err.Message == context.DeadlineExceeded.Error() {
        return false
      }

    }
  }

      switch err.(type) {
      case *roachpb.IntegerOverflowError:
        return 0, boundsExceededError(descriptor)
      default:
        return 0, err
      }