Bug with tuple

[Tang8330]

I'm running this:

func (i *snapshotIterator) Next() ([]map[string]any, error) {
	if i.done {
		return nil, fmt.Errorf("no more rows to scan")
	}

	if i.iter == nil {
		colNames := make([]string, len(i.columns))
		for idx, col := range i.columns {
			// Cassandra identifiers are typically lowercase; avoid quoting to keep it simple.
			colNames[idx] = col.Name
		}

		// Build fully-qualified table name keyspace.table
		stmt := fmt.Sprintf("SELECT %s FROM %s.%s", strings.Join(colNames, ","), i.keyspace, i.tableName)
		fmt.Println("stmt", stmt)
		i.iter = i.session.Query(stmt).PageSize(i.batchSize).Iter()
	}

	var rows []map[string]any
	for len(rows) < i.batchSize {
		row := make(map[string]any)
		if !i.iter.MapScan(row) {
			i.done = true
			break
		}

		out, err := i.normalizeRow(row)
		if err != nil {
			return nil, fmt.Errorf("failed to normalize row: %w", err)
		}

		rows = append(rows, out)
	}

	return rows, nil
}

You can clearly see that c_tuple_int_text is null:

However, this is what I'm getting back:

stmt SELECT id,c_ascii,c_bigint,c_blob,c_boolean,c_date,c_decimal,c_double,c_float,c_frozen_list_int,c_inet,c_int,c_smallint,c_text,c_time,c_timestamp,c_timeuuid,c_tinyint,c_tuple_int_text,c_uuid,c_varchar,c_varint,c_list_int,c_map_text_int,c_set_int FROM artie_test.data_type_test
key c_double value 4.14159
key c_time value 12h34m56s
key c_timestamp value 2025-09-10 23:45:22.811 +0000 UTC
key c_tinyint value 42
key c_varint value 1234567890123456789
key c_timeuuid value 37a76f2c-8ea0-11f0-bed0-d6c22f62521e
key c_list_int value [10]
key c_map_text_int value map[a:1 b:2]
key c_set_int value [1]
key c_ascii value ascii_1
key c_boolean value false
key c_decimal value 123.45
key c_float value 3.71828
key c_tuple_int_text[0] value 0
key c_tuple_int_text[1] value
key c_varchar value varchar_1
key id value 2
key c_blob value [1 2 3 1]
key c_frozen_list_int value [1]
key c_inet value 10.0.1.2
key c_int value 1001
key c_smallint value 1234
key c_text value text_1
key c_uuid value baed9c37-e600-497d-857d-852d395dad07
key c_bigint value 9000000001
key c_date value 2025-09-10 00:00:00 +0000 UTC

[Tang8330]

I ended up writing an unfold method,

package cassandra

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

func FoldTuples(row map[string]any, col string) (map[string]any, error) {
	re, err := regexp.Compile(fmt.Sprintf(`^(%s)\[(\d+)\]$`, col))
	if err != nil {
		return nil, fmt.Errorf("failed to compile regex pattern: %w", err)
	}

	foldedParts := make(map[int]any)
	out := make(map[string]any)
	for key, value := range row {
		if strings.HasPrefix(key, col) && key != col {
			parts := re.FindStringSubmatch(key)
			if len(parts) != 3 {
				return nil, fmt.Errorf("expected 2 parts got %d (%s) for key: %q", len(parts), strings.Join(parts, ","), key)
			}

			// Skip the first part, since it'll be the whole match.
			index, err := strconv.Atoi(parts[2])
			if err != nil {
				return nil, fmt.Errorf("failed to convert index to int: %w", err)
			}

			if _, ok := foldedParts[index]; ok {
				return nil, fmt.Errorf("duplicate index found for key: %q", key)
			}

			foldedParts[index] = value
		} else {
			out[key] = value
		}
	}

	if len(foldedParts) == 0 {
		return out, nil
	}

	packedValue := make(map[string]any)
	// Else, now let's pack all of the folded parts into the tuple.
	for i := range len(foldedParts) {
		// This is done to be compatible with Debezium, where it marks the first value as "field1".
		value, ok := foldedParts[i]
		if !ok {
			return nil, fmt.Errorf("expected value for index %d but got none", i)
		}

		packedValue[fmt.Sprintf("field%d", i+1)] = value
	}

	out[col] = packedValue
	return out, nil
}

It'd be great if this wasn't required.

[jameshartig]

@Tang8330 Can you clarify the specific issue with tuples? If a tuple is NULL and you send *[]int to Unmarshal we should be setting the pointer's value to []int(nil). Can you also specify if you're using v1.x or v2.x since this changed in v2. That said, I don't understand how your "unfold" method changes any behavior related to NULL tuples. Instead it seems like that method rewrites the tuples to instead be a map with keys like field0 which seems unrelated to the NULL tuples in the original message.

Separately, I'd avoid using MapScan if you desire specific column behavior, especially with tuples, since that method assumes you want to use the nomenclature defined by TupleColumnName.