Add delta to current demand with saturation at Long/MAX_VALUE.

Used to accumulate backpressure demand counts without overflow.

Args:
  current - long, existing demand.
  delta   - long, demand increment.

Returns a long in [current, Long/MAX_VALUE].

Block the calling thread until fut completes and returns its result.

Used inside Reactive Streams callbacks where parking is not available.
Propagates CancellationException and ExecutionException unwrapped.

Args:
  fut - CompletableFuture<T>.

Returns the future's result value.

Subscribe to a Publisher<Void> and block until it completes.

Used for fire-and-forget publishers such as Statement.execute() void results.

Args:
  pub - Publisher<Void> to drain.

Subscribe to pub, request one item, and return it synchronously.

Blocks the calling thread. Intended for driver-level one-shot publishers
(e.g., connection metadata) where Missionary scheduling is unavailable.

Args:
  pub     - Publisher<T> to subscribe to.
  sub-ref - volatile that receives the Subscription for cancellation.

Call Subscription.request(n) on sub asynchronously.

Schedules the request on a ForkJoinPool background thread to avoid
re-entrant driver callbacks.

Args:
  sub - Subscription to request from.
  n   - number of items to request.

Resolve the effective fetch size from opts.

Returns the :fetch-size value when present and valid; otherwise returns
the default of 128. Applies the value as a primitive long.

Args:
  opts - map, may contain :fetch-size.

Returns a positive long.

Return a Publisher<T> for all rows in result, each transformed by row-xf.

row-xf is applied inside BiFunction.apply() - before Result.map's finally
block calls message.release() on the underlying ByteBuf. This guarantees the
Row's backing ByteBuf is live when row-xf (e.g., builder-fn) reads column
values via Row.get(), regardless of whether the downstream Flux buffers the
row internally (demand == 0) before delivering it.

Applying row-xf here rather than in the downstream subscriber's onNext is the
only safe point: once sink.next() queues a row into Reactor's internal buffer
(because demand is zero at that instant) and the enclosing handler returns,
message.release() fires and the ByteBuf is returned to the Netty pool. Any
subsequent Row.get() call on the buffered row then reads freed memory,
causing IllegalReferenceCountException that escapes the subscriber's onNext
without calling notifier - leaving the Missionary reduce waiting forever.

Args:
  result - R2DBC Result to map over.
  row-xf - 1-arity fn [Row] -> T applied to each row inside BiFunction.apply().

Return a Publisher<T> that streams transformed rows from result-pub sequentially.

At most one Result is requested at a time. Downstream demand is forwarded to
the active Result.map publisher, so row demand remains bounded by the row-flow
fetch-size rather than collapsing to Long/MAX_VALUE at the Result boundary.

row-xf is forwarded to result-row-pub and applied inside BiFunction.apply()
while the Row's ByteBuf is guaranteed to be live. See result-row-pub for the
detailed safety argument.

Args:
  result-pub     - Publisher<Result> to consume.
  result-sub-ref - volatile holding the outer Subscription for cancellation.
  row-xf         - 1-arity fn [Row] -> T applied to each row.