review: gracefully degrade on libchdb builds without the signal handler API

Per review feedback: pre-check chdb_set_signal_handlers_enabled via Dlsym
before calling RegisterLibFunc, so older libchdb builds that don't export
the signal handler control API (added in chdb-core#11) don't make this
package's init() panic.

When the symbol is missing:
  - the init's snapshot / set_enabled(0) / restore dance is skipped;
  - loadSigaction() is also skipped (libcSigaction stays nil);
  - the NewConnection guard becomes a no-op closure;
  - the two signal-handler tests t.Skip() instead of crashing.

Net effect: on old libchdb the binding loads and works exactly as it did
before this PR — the issue #30 fix simply doesn't apply. On v26.x+ the
fix is active.

The NewConnection call site now uses `defer guardSignalHandlers()()`
which captures the snapshot at defer-statement time and returns either
the restore closure or a no-op. Cleaner than the previous explicit
saved/defer pair.

Verified with a Dlsym probe that purego returns (handle, nil) for
present symbols and (0, err) for missing ones on both macOS and Linux.
Full `go test -race ./...` still green on macOS arm64 and Linux arm64.

Author: xianml

chdb-purego/binding.go

@@ -176,29 +176,58 @@ func init() {
 	purego.RegisterLibFunc(&chdbResultStorageBytesRead, libchdb, "chdb_result_storage_bytes_read")
 	purego.RegisterLibFunc(&chdbResultError, libchdb, "chdb_result_error")
 
-	purego.RegisterLibFunc(&chdbSetSignalHandlersEnabled, libchdb, "chdb_set_signal_handlers_enabled")
-	purego.RegisterLibFunc(&chdbResetSignalHandlers, libchdb, "chdb_reset_signal_handlers")
-
-	// Tell libchdb NOT to install its own signal handlers on the first
-	// chdb_connect(). Without this, libchdb's ClickHouse daemon code
-	// installs handlers for SIGSEGV / SIGABRT / SIGBUS / SIGILL / SIGFPE
-	// the first time a connection is opened, overwriting the handlers
-	// the Go runtime relies on for stack growth and panic recovery. When
-	// a Go signal then lands in libchdb's handler instead of the
-	// runtime's, the result is the rare std::mutex::unlock crash
-	// described in issue #30 — most often on macOS arm64 CI where signal
-	// pressure is highest.
-	//
-	// Important: chdb_set_signal_handlers_enabled(0) doesn't only set a
-	// flag — it also wipes the existing handlers in the same set back to
-	// SIG_DFL (verified empirically; the chdb.h header doesn't mention
-	// this side effect). Since the Go runtime has already installed its
-	// handlers by the time this package's init runs, we have to save Go's
-	// handlers, call the disable, then restore them. After this dance the
-	// libchdb flag is set (so no future connect installs handlers) and
-	// Go's handlers remain in place.
-	loadSigaction()
+	// Signal handler protection (issue #30). The required API was added in
+	// libchdb v26.x via chdb-core#11. Pre-check the symbol with Dlsym so
+	// that older libchdb builds — which don't export
+	// chdb_set_signal_handlers_enabled — degrade gracefully instead of
+	// panicking inside RegisterLibFunc at init. On those builds the crash
+	// from issue #30 stays unfixed, but the binding still loads.
+	if sym, dlsymErr := purego.Dlsym(libchdb, "chdb_set_signal_handlers_enabled"); dlsymErr == nil && sym != 0 {
+		purego.RegisterLibFunc(&chdbSetSignalHandlersEnabled, libchdb, "chdb_set_signal_handlers_enabled")
+		purego.RegisterLibFunc(&chdbResetSignalHandlers, libchdb, "chdb_reset_signal_handlers")
+
+		// Tell libchdb NOT to install its own signal handlers on the
+		// first chdb_connect(). Without this, libchdb's ClickHouse
+		// daemon code installs handlers for SIGSEGV / SIGABRT / SIGBUS
+		// / SIGILL / SIGFPE the first time a connection is opened,
+		// overwriting the handlers the Go runtime relies on for stack
+		// growth and panic recovery. When a Go signal then lands in
+		// libchdb's handler instead of the runtime's, the result is
+		// the rare std::mutex::unlock crash described in issue #30 —
+		// most often on macOS arm64 CI where signal pressure is
+		// highest.
+		//
+		// Important: chdb_set_signal_handlers_enabled(0) doesn't only
+		// set a flag — it also wipes the existing handlers in the same
+		// set back to SIG_DFL (verified empirically; the chdb.h header
+		// doesn't mention this side effect). Since the Go runtime has
+		// already installed its handlers by the time this package's
+		// init runs, we have to save Go's handlers, call the disable,
+		// then restore them. After this dance the libchdb flag is set
+		// (so no future connect installs handlers) and Go's handlers
+		// remain in place.
+		loadSigaction()
+		saved := snapshotSignalHandlers()
+		chdbSetSignalHandlersEnabled(0)
+		restoreSignalHandlers(saved)
+	}
+}
+
+// signalProtectionAvailable reports whether the running libchdb exposes the
+// signal handler control API. When false, snapshotSignalHandlers and
+// restoreSignalHandlers must NOT be called (libcSigaction was not loaded).
+func signalProtectionAvailable() bool {
+	return chdbSetSignalHandlersEnabled != nil
+}
+
+// guardSignalHandlers returns a function suitable for `defer`-ing around a
+// call into libchdb. When signal protection is available, it captures the
+// current sigaction state now and the returned closure restores it. When
+// not available (old libchdb), both calls are no-ops.
+func guardSignalHandlers() func() {
+	if !signalProtectionAvailable() {
+		return func() {}
+	}
 	saved := snapshotSignalHandlers()
-	chdbSetSignalHandlersEnabled(0)
-	restoreSignalHandlers(saved)
+	return func() { restoreSignalHandlers(saved) }
 }

chdb-purego/chdb.go

@@ -220,17 +220,19 @@ func NewConnection(argc int, argv []string) (ChdbConn, error) {
 		// chdb_connect — even after chdb_set_signal_handlers_enabled(0) —
 		// still resets the kernel sigaction table for SIGSEGV / SIGABRT /
 		// SIGBUS / SIGILL / SIGFPE to SIG_DFL on the first call (verified
-		// empirically; see issue #30 for context). Snapshot Go's handlers
-		// and restore them on return so the runtime keeps its stack-growth
-		// / panic-recovery handlers.
+		// empirically; see issue #30 for context). guardSignalHandlers
+		// snapshots Go's handlers now and the deferred closure restores
+		// them on return — even if chdb_connect panics (a C++ exception
+		// propagated through purego), the LIFO defer order runs
+		// recover() first to set err and then the restore, leaving the
+		// process with Go's stack-growth / panic-recovery handlers
+		// intact.
 		//
-		// Restore is deferred BEFORE the panic-recovery defer so that even
-		// if chdb_connect panics (e.g. C++ exception propagated through
-		// purego), Go's handlers are still put back before this function
-		// unwinds — otherwise the rest of the process would be left with
-		// SIG_DFL for these signals.
-		saved := snapshotSignalHandlers()
-		defer restoreSignalHandlers(saved)
+		// On old libchdb builds that don't export the signal-handler
+		// control API, guardSignalHandlers returns a no-op closure and
+		// the call site behaves exactly as it did before the issue #30
+		// fix landed.
+		defer guardSignalHandlers()()
 
 		defer func() {
 			if r := recover(); r != nil {

chdb-purego/stress_test.go

@@ -21,6 +21,9 @@ import (
 // breaks Go's stack growth and panic recovery; under load it surfaces as the
 // rare std::mutex::unlock crash reported on macOS arm64.
 func TestSignalHandlersPreservedAcrossConnect(t *testing.T) {
+	if !signalProtectionAvailable() {
+		t.Skip("libchdb does not export chdb_set_signal_handlers_enabled; protection disabled on this build")
+	}
 	before := snapshotSignalHandlers()
 
 	conn, err := NewConnectionFromConnString(":memory:")
@@ -57,6 +60,9 @@ func TestSignalHandlersPreservedAcrossConnect(t *testing.T) {
 // makes the restore unconditional. This test wipes a handler, panics, and
 // asserts that on unwinding the handler is back to what we snapshotted.
 func TestSignalHandlersRestoredAfterPanic(t *testing.T) {
+	if !signalProtectionAvailable() {
+		t.Skip("libchdb does not export chdb_set_signal_handlers_enabled; protection disabled on this build")
+	}
 	initial := snapshotSignalHandlers()
 
 	recovered := false