[C++] Make status codes pluggable

[asfimport]

Currently we're defining all Status codes in the Arrow base library, even those pertaining to sub-libraries such as arrow_python, plasma, gandiva, etc. We should try to devise some kind of simple registry system to avoid centralizing those.

Reporter: Antoine Pitrou / @pitrou
Assignee: Micah Kornfield / @emkornfield

PRs and other links:

• GitHub Pull Request #3199
• GitHub Pull Request #4484

_{Note: This issue was originally created as ARROW-4036. Please see the migration documentation for further details.}

[asfimport]

Ben Kietzman / @bkietz:
A few ways I can think of to accomplish that without collisions

• Extend Status with something like std::error_category for each sub library (could be as simple as adding a byte to Status::State identifying sub library)

• Replace StatusCode with the hardcoded timestamp of each code's definition (== weaksauce uuid)

• RegisterStatusCode(&kSomeStatusCode) will not yield consistent codes; if we add a new one in arrow then all the sub library codes will increment. Is that a problem? It would break if, for example, different versions of arrow were communicating Statuses

• RegisterStatusCode(timestamp, &kSomeStatusCode) will fix that if we have guaranteed load order for sub libraries

  Either of the latter two mean being a little careful about StatusCodes since their values will not be defined until loading is complete. For example, constexpr StatusCode my_code = kSomeStatusCode; would be undefined behavior

[asfimport]

Wes McKinney / @wesm:
One way would be to make Status::State a public type with virtual methods. Since Status::state_ is null in almost all cases, I wouldn't think this would have performance implications (though delete state_ now would require invoking a virtual ctor) but this should be examined more closely (in godbolt) to be sure.

So we could define something like

class GandivaErrorState : public Status::ErrorState {
 public:
  std::string error_type() const override { return "gandiva"; }
  ...
};

[asfimport]

Ben Kietzman / @bkietz:
I like that. In that case would it still be useful to define StatusCodes? We could define subclasses for each error condition

To avoid copy construction/virtual destructor calls when a status is copied, we could by make ErrorState ref counted

[asfimport]

Antoine Pitrou / @pitrou:
We already had Status appear in performance profiles for some benchmarks (most notably Python-to-Arrow conversions), so I'm wary of introducing polymorphism here.

[asfimport]

Antoine Pitrou / @pitrou:
I posted an example of another approach here:
#3199

Perhaps we want to compare several approaches together.

[asfimport]

Antoine Pitrou / @pitrou:
I'll note that there are two main pain points if we want to make the API usable enough:

1. The convenience factory functions (e.g. Status::Invalid())

2. The convenience query functions (e.g. Status::IsInvalid())

   C++ does not seem to provide us with an easy solution for those.

[asfimport]

Ben Kietzman / @bkietz:
We could use the status range and the error code within it to get something similar:

enum GandivaErrorCode : int32_t {
  CodeGenError,
  //...
};

static StatusRange GandivaError("gandiva", {
  "CodeGenError",
  //...
});

Status MakeCodeGenError() {
  return GandivaError(CodeGenError, "msg"); // overload call operator to act as a factory
}

void QueryUsage(Status s) {
  s.Is<GandivaError>();               // query category
  s.Is<GandivaError, CodeGenError>(); // query code within category
  // or equivalently
  s.Is(GandivaError);               // query category
  s.Is(GandivaError, CodeGenError); // query code within category
}

[asfimport]

Wes McKinney / @wesm:
Moved this to 1.0.0 so we aren't rushing this change, though if we merge for 0.14.0 then that's fine with me

[asfimport]

Antoine Pitrou / @pitrou:
Issue resolved by pull request 4484
#4484