Bug: a non-nil `*string` holding valid JSON stored at `{}`

[kavirajk]

AppendRow unset-version switch matches string and []byte, but not *string. The reflect-based []byte check only catches slice-of-uint8, so *string falls through to appendRowObject, where no branch converts a pointer-to-string into JSON.

obj stays nil and is replaced with an empty chcol.NewJSON(). Then AppendRow returns nil, the caller sees no error, and the column is stored as {}.

I think this bug is made visible after this PR (which changed the order of append. first try object then string. If like before the PR first trying string would have worked)

Below is a simple example to reproduce on tip of the main branch

func bug(ctx context.Context, conn driver.Conn) error {
	if err := conn.Exec(ctx, "DROP TABLE IF EXISTS go_json_repro_issue1"); err != nil {
		return err
	}
	if err := conn.Exec(ctx, `CREATE TABLE go_json_repro_issue1 (product JSON) ENGINE=Memory`); err != nil {
		return err
	}

	jsonText := `{"id":1234,"name":"Book","tags":["a","b"]}`
	ptr := &jsonText

	batch, err := conn.PrepareBatch(ctx, "INSERT INTO go_json_repro_issue1 (product)")
	if err != nil {
		return err
	}
	if err := batch.Append(ptr); err != nil {
		return fmt.Errorf("append returned an error (would be preferable): %w", err)
	}
	if err := batch.Send(); err != nil {
		return err
	}

	var stored string
	if err := conn.QueryRow(ctx,
		"SELECT toString(product) FROM go_json_repro_issue1").Scan(&stored); err != nil {
		return err
	}

	fmt.Printf("  input (*string):  %s\n", jsonText)
	fmt.Printf("  stored value:     %s\n", stored)
	fmt.Printf("  data lost:        %t\n", stored != jsonText)
	return nil
}

This will produce following output

$ go run json_issue.go
  input (*string):  {"id":1234,"name":"Book","tags":["a","b"]}
  stored value:     {}
  data lost:        true

Proposal:

1. Handle *string case in both Append() and AppendRow() similar to string and []byte. Doing so it invokes correct appendRowString() api for string.
2. Check other places in JSON where this silent failure can happen if type missaligned. And throw explicit error instead

[kavirajk]

I realized the same bug can cause another subtle behavior.

Say we have this table
CREATE TABLE go_json_repro_issue2 (id UInt32, product Nullable(JSON)) ENGINE=MergeTree ORDER BY id

Now consider the following query

batch, _ := conn.PrepareBatch(ctx, "INSERT INTO t (id, product)")
batch.Append(uint32(1), nil)        // row 1 — product is nil
batch.Append(uint32(2), jsonText)   // row 2 — product is a JSON string
batch.Send()

Now. ClickHouse wire format (Native protocol) expects one serialization mode per column per batch (WriteStatePrefix type). You can also verify it on the ClickHouse server side.

Now what happens is if you pass nil first to Append() for your Nullable(JSON). it end up setting the WriteSTatePrefix type to ObjectSerializationVersion for the whole block. So now if you pass JSON string on second Append(), the state prefix is still object type and end up in non-nil value ({}).