Method logQueryError

server/conn.go:499–560

logQueryError logs a query execution failure. DuckLake-specific retryable conditions and user-attributable errors get Warn / Info so the Error level stays meaningful as an alerting signal — "Query execution errored." should mean the system genuinely went wrong (worker crash, IO failure, internal pan

(query string, err error)

	// SIGUSR1 sends one token (worker.go notifyQueryCancel); discard a token
	// that arrived while no query was in flight — like Postgres, a cancel
	// request targets only the query running when it is delivered, so a stale
	// one must not kill the next query.
	if c.server.externalCancelCh != nil {
		select {
		case <-c.server.externalCancelCh:
		default:
		}
		go func() {
			select {
			case <-c.server.externalCancelCh:
				cancel()
			case <-ctx.Done():
				// Context already cancelled, nothing to do
			}
		}()
	}

	var stopMonitor func()
	if monitor {
		stopMonitor = c.startDisconnectMonitor(ctx)
	}

	cleanup := func() {
		if stopMonitor != nil {
			stopMonitor()
		}
		c.server.UnregisterQuery(key)
		cancel()
	}

	return ctx, cleanup
}

// startDisconnectMonitor starts a goroutine that polls the client connection
// for disconnects using bufio.Reader.Peek. During query execution the message
// loop is blocked on the executor, so nobody else touches the bufio.Reader,
// making concurrent Peek calls safe. When the client sends a TCP FIN or RST,
// Peek returns a non-timeout error and the connection context is cancelled.
//
// The returned stop function MUST be called when query execution completes.
// It waits for the monitor goroutine to exit before returning, ensuring the
// bufio.Reader is not accessed concurrently with the message loop.
func (c *clientConn) startDisconnectMonitor(ctx context.Context) (stop func()) {
	stopped := make(chan struct{})
	done := make(chan struct{})

	go func() {
		defer close(stopped)
		for {
			_ = c.conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
			_, err := c.reader.Peek(1)
			if err != nil {
				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
					select {
					case <-done:
						return
					case <-ctx.Done():
						return