Method QueryContext

server/flightclient/flight_executor.go:170–249

(ctx context.Context, query string, args ...any)

		limiter = NewQueryLogLimiter()
	}
	ctx, cancel := context.WithCancel(context.Background())
	e := &FlightExecutor{
		client:          client,
		sessionToken:    sessionToken,
		ownerEpoch:      0,
		alloc:           memory.DefaultAllocator,
		ownsClient:      false,
		ctx:             ctx,
		cancel:          cancel,
		queryLogLimiter: limiter,
	}
	return e
}

// MarkDead marks this executor's backing worker as dead. All subsequent RPC
// calls will return ErrWorkerDead without touching the (possibly closed) gRPC client.
func (e *FlightExecutor) MarkDead() {
	e.dead.Store(true)
}

// IsDead reports whether this executor has been marked dead.
func (e *FlightExecutor) IsDead() bool {
	return e.dead.Load()
}

// withSession adds the session token to the gRPC context.
func (e *FlightExecutor) withSession(ctx context.Context) context.Context {
	ctx = metadata.AppendToOutgoingContext(
		ctx,
		"x-duckgres-session", e.sessionToken,
		"x-duckgres-worker-id", strconv.Itoa(e.workerID),
		"x-duckgres-cp-instance-id", e.cpInstanceID,
		"x-duckgres-owner-epoch", strconv.FormatInt(e.ownerEpoch, 10),
	)
	// Sourced from the context rather than executor state: the executor is
	// per-session and serves many statements while pgwire reaches it through
	// the same call.
	if queryID := wire.QueryIDFromContext(ctx); queryID != "" {
		ctx = metadata.AppendToOutgoingContext(ctx, wire.QueryIDMetadataKey, queryID)
	}
	return ctx
}

func (e *FlightExecutor) SetOwnerEpoch(ownerEpoch int64) {
	e.ownerEpoch = ownerEpoch
}

func (e *FlightExecutor) SetControlMetadata(workerID int, cpInstanceID string, ownerEpoch int64) {
	e.workerID = workerID
	e.cpInstanceID = cpInstanceID
	e.ownerEpoch = ownerEpoch
}

// recoverClientPanic converts a nil-pointer panic from a closed Flight SQL
// client into an error. The arrow-go Close() method nils out the embedded
// FlightServiceClient, so any concurrent RPC on the shared client panics.
// Only nil-pointer dereferences are recovered; other panics are re-raised
// to preserve stack traces for unrelated programmer errors.