fix: change query_log normalized_query_hash column from UBIGINT to BIGINT

The previous fix (#366) cast uint64 hashes to int64 to work around
Go's database/sql driver rejecting high-bit uint64 values. However,
the column was still UBIGINT, so DuckDB rejected negative int64 values
with "Type INT64 with value ... can't be cast because the value is out
of range for the destination type UINT64".

Change the column to BIGINT and add a best-effort ALTER TABLE migration
for existing tables.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: fuziontech

server/querylog.go

@@ -114,7 +114,7 @@ func NewQueryLogger(cfg Config) (*QueryLogger, error) {
 		query               VARCHAR NOT NULL,
 		transpiled_query    VARCHAR,
 		query_kind          VARCHAR,
-		normalized_query_hash UBIGINT,
+		normalized_query_hash BIGINT,
 		result_rows         BIGINT,
 		written_rows        BIGINT,
 		exception_code      VARCHAR,
@@ -134,6 +134,16 @@ func NewQueryLogger(cfg Config) (*QueryLogger, error) {
 		return nil, fmt.Errorf("querylog: create table: %w", err)
 	}
 
+	// Migrate normalized_query_hash from UBIGINT to BIGINT for existing tables.
+	// The Go database/sql driver cannot bind uint64 values with the high bit set,
+	// so we cast to int64 before inserting. A BIGINT column accepts negative int64
+	// values without a conversion error.
+	if _, err := db.Exec("ALTER TABLE ducklake.system.query_log ALTER COLUMN normalized_query_hash SET DATA TYPE BIGINT"); err != nil {
+		// Ignore error — column may already be BIGINT (new table) or DuckLake
+		// may not support ALTER TYPE. Either way, this is best-effort.
+		slog.Debug("querylog: ALTER normalized_query_hash to BIGINT (may already be correct).", "error", err)
+	}
+
 	// Configure data inlining
 	inlineStmt := fmt.Sprintf(
 		"CALL ducklake.set_option('data_inlining_row_limit', %d, schema => 'system', table_name => 'query_log')",

server/querylog_test.go

@@ -180,6 +180,59 @@ func TestQueryLoggerStopIsIdempotent(t *testing.T) {
 	ql.Stop()
 }
 
+func TestHighBitHashInsertIntoBigint(t *testing.T) {
+	db, err := sql.Open("duckdb", ":memory:")
+	if err != nil {
+		t.Fatalf("open duckdb: %v", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE test_hash (h BIGINT)")
+	if err != nil {
+		t.Fatalf("create table: %v", err)
+	}
+
+	// Use a hash with the high bit set — this is the scenario that caused the
+	// "INT64 value can't be cast to UINT64" error when the column was UBIGINT.
+	var highBitHash uint64 = 0xD700_0000_0000_0000
+
+	// This is the same cast used in flushBatch: int64(uint64_value)
+	_, err = db.Exec("INSERT INTO test_hash VALUES ($1)", int64(highBitHash))
+	if err != nil {
+		t.Fatalf("insert failed (this was the original bug): %v", err)
+	}
+
+	var stored int64
+	err = db.QueryRow("SELECT h FROM test_hash").Scan(&stored)
+	if err != nil {
+		t.Fatalf("query failed: %v", err)
+	}
+	if uint64(stored) != highBitHash {
+		t.Errorf("hash round-trip mismatch: got uint64(%d) = %d, want %d", stored, uint64(stored), highBitHash)
+	}
+}
+
+// TestHighBitHashRejectsUbigint confirms that UBIGINT rejects negative int64
+// values — this is the bug we fixed by switching to BIGINT.
+func TestHighBitHashRejectsUbigint(t *testing.T) {
+	db, err := sql.Open("duckdb", ":memory:")
+	if err != nil {
+		t.Fatalf("open duckdb: %v", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE test_hash_u (h UBIGINT)")
+	if err != nil {
+		t.Fatalf("create table: %v", err)
+	}
+
+	var highBitHash uint64 = 0xD700_0000_0000_0000
+	_, err = db.Exec("INSERT INTO test_hash_u VALUES ($1)", int64(highBitHash))
+	if err == nil {
+		t.Fatal("expected error inserting negative int64 into UBIGINT, but insert succeeded")
+	}
+}
+
 func TestSplitHostPort(t *testing.T) {
 	host, port, err := splitHostPort("192.168.1.1:5432")
 	if err != nil {