在Go语言中使用gocql处理Cassandra的Set数据类型

package main

import (
    "fmt"
    "log"

    "github.com/gocql/gocql"
)

func main() {
    // 连接到Cassandra集群
    cluster := gocql.NewCluster("127.0.0.1") // 替换为你的Cassandra地址
    cluster.Keyspace = "mykeyspace"          // 替换为你的keyspace
    cluster.Consistency = gocql.Quorum
    session, err := cluster.CreateSession()
    if err != nil {
        log.Fatalf("无法连接到Cassandra: %v", err)
    }
    defer session.Close()

    // 假设category_id为"electronics"
    key := "electronics"
    var productIdList []string // 声明一个string切片来接收set<text>类型的数据

    // 执行查询
    query := "SELECT product_list FROM category WHERE category_id=?"
    err = session.Query(query, key).Scan(&productIdList)
    if err != nil {
        if err == gocql.ErrNotFound {
            fmt.Printf("未找到类别ID: %s\n", key)
        } else {
            log.Fatalf("查询失败: %v", err)
        }
    } else {
        fmt.Printf("类别ID '%s' 的产品列表: %v\n", key, productIdList)
    }
}

// Marshaller 接口用于将Go类型编码为CQL值
type Marshaller interface {
    MarshalCQL(info TypeInfo) ([]byte, error)
}

// Unmarshaller 接口用于将CQL值解码为Go类型
type Unmarshaller interface {
    UnmarshalCQL(info TypeInfo, data []byte) error
}

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "log"
    "strconv"

    "github.com/gocql/gocql"
)

// CustomSet 定义一个自定义类型，用于表示Cassandra的Set
// 这里使用map[string]bool来模拟Set的唯一性
type CustomSet map[string]bool

// UnmarshalCQL 实现 gocql.Unmarshaller 接口
// 将Cassandra返回的字节数据解析到 CustomSet 中
func (s *CustomSet) UnmarshalCQL(info gocql.TypeInfo, data []byte) error {
    if data == nil {
        return nil // 处理NULL值
    }

    if *s == nil {
        *s = make(CustomSet)
    }

    reader := bytes.NewReader(data)

    // Cassandra Set的字节格式通常是：
    // [元素数量(int32)] [元素1长度(int16)] [元素1数据] [元素2长度(int16)] [元素2数据] ...
    // 需要根据实际的CQL协议进行精确解析
    // 这里的实现是一个简化的示例，仅用于说明概念，可能不完全符合gocql内部的Set解析逻辑。
    // 实际应用中，你可能需要参考gocql内部的Set解析代码或更底层的协议规范。

    // 假设我们直接处理一个简单的文本列表，用逗号分隔（这不是Cassandra Set的真实协议格式）
    // 真实情况需要解析每个元素的长度和数据
    // For demonstration, let's assume a simple format for the data
    // In a real scenario, you'd parse the length-prefixed elements.
    // This part is complex and usually handled by gocql internally.
    // For a custom type, you'd need to parse the raw byte stream as per Cassandra's CQL protocol for collections.

    // Example of parsing a simple list of strings from bytes (NOT actual CQL Set format)
    // This is a placeholder; real implementation is more involved.
    var numElements int32
    if err := binary.Read(reader, binary.BigEndian, &numElements); err != nil {
        return fmt.Errorf("无法读取Set元素数量: %w", err)
    }

    for i := 0; i < int(numElements); i++ {
        var elementLength int16
        if err := binary.Read(reader, binary.BigEndian, &elementLength); err != nil {
            return fmt.Errorf("无法读取Set元素长度: %w", err)
        }
        elementBytes := make([]byte, elementLength)
        if _, err := reader.Read(elementBytes); err != nil {
            return fmt.Errorf("无法读取Set元素数据: %w", err)
        }
        (*s)[string(elementBytes)] = true
    }
    return nil
}

// MarshalCQL 实现 gocql.Marshaller 接口
// 将 CustomSet 编码为Cassandra可识别的字节数据
func (s CustomSet) MarshalCQL(info gocql.TypeInfo) ([]byte, error) {
    if s == nil || len(s) == 0 {
        return nil, nil
    }

    var buffer bytes.Buffer
    // 写入元素数量
    numElements := int32(len(s))
    if err := binary.Write(&buffer, binary.BigEndian, numElements); err != nil {
        return nil, fmt.Errorf("无法写入Set元素数量: %w", err)
    }

    for key := range s {
        // 写入每个元素的长度
        elementBytes := []byte(key)
        elementLength := int16(len(elementBytes))
        if err := binary.Write(&buffer, binary.BigEndian, elementLength); err != nil {
            return nil, fmt.Errorf("无法写入Set元素长度: %w", err)
        }
        // 写入元素数据
        if _, err := buffer.Write(elementBytes); err != nil {
            return nil, fmt.Errorf("无法写入Set元素数据: %w", err)
        }
    }
    return buffer.Bytes(), nil
}

func main() {
    // 连接到Cassandra集群
    cluster := gocql.NewCluster("127.0.0.1") // 替换为你的Cassandra地址
    cluster.Keyspace = "mykeyspace"          // 替换为你的keyspace
    cluster.Consistency = gocql.Quorum
    session, err := cluster.CreateSession()
    if err != nil {
        log.Fatalf("无法连接到Cassandra: %v", err)
    }
    defer session.Close()

    // 准备数据用于插入
    customSetData := make(CustomSet)
    customSetData["itemA"] = true
    customSetData["itemB"] = true
    customSetData["itemC"] = true

    // 假设我们有一个表 'items'，其中有一个 'tags' 列是 set<text> 类型
    // CREATE TABLE mykeyspace.items (id text PRIMARY KEY, tags set<text>);

    itemId := "unique_item_id_1"

    // 插入数据
    insertQuery := "INSERT INTO items (id, tags) VALUES (?, ?)"
    err = session.Query(insertQuery, itemId, customSetData).Exec()
    if err != nil {
        log.Fatalf("插入数据失败: %v", err)
    }
    fmt.Printf("成功插入ID为 '%s' 的数据，tags: %v\n", itemId, customSetData)

    // 查询数据
    var retrievedSet CustomSet
    selectQuery := "SELECT tags FROM items WHERE id=?"
    err = session.Query(selectQuery, itemId).Scan(&retrievedSet)
    if err != nil {
        log.Fatalf("查询数据失败: %v", err)
    }
    fmt.Printf("查询到ID为 '%s' 的数据，tags: %v\n", itemId, retrievedSet)

    // 验证 Set 的行为
    if _, ok := retrievedSet["itemA"]; ok {
        fmt.Println("itemA 存在于集合中")
    }
    if _, ok := retrievedSet["nonExistentItem"]; !ok {
        fmt.Println("nonExistentItem 不存在于集合中")
    }
}