PostgreSQL 14 FDW跨回调传递大量元数据的问题求助

先排查List传递失效的核心原因 #

你的问题大概率和内存上下文管理、List元素的序列化兼容性有关——PostgreSQL的计划节点会被序列化存储，List中的元素如果不符合要求，会在回调间丢失或损坏：

• 直接存储栈上字符串/未用PostgreSQL内存分配的字符串：这类内存会在函数退出后被释放，导致后续回调中字符串损坏或截断。
• List元素未使用PostgreSQL认可的可序列化类型：比如自定义结构体未实现序列化逻辑，或者用了裸指针，序列化后指针失效。
• 内存上下文错误：在GetForeignPlan()中如果用了临时内存上下文创建List，没有切换到合适的持久化上下文，List会被自动回收。

修复List传递问题的步骤 #

1. 用PostgreSQL内存分配函数存储字符串
   所有要存入List的字符串必须用pstrdup()分配在PostgreSQL的永久内存上下文，避免函数退出后内存被释放：

   // 错误：栈上字符串，退出函数后内存释放
   char json_str[] = "{\"key\": \"value\"}";
   // 正确：用pstrdup分配到PostgreSQL内存
   char *safe_json = pstrdup("{\"key\": \"value\"}");
   List *fdw_private = lappend(NULL, safe_json);
   

2. 确保List使用正确的内存上下文
   在GetForeignPlan()中创建List时，切换到计划节点的内存上下文，避免List被临时上下文回收：

   MemoryContext old_ctx = MemoryContextSwitchTo(plan->plan_node_context);
   List *fdw_private = NIL;
   // 逐个添加元素，所有元素都用pstrdup或序列化后的节点
   fdw_private = lappend(fdw_private, pstrdup("metadata1"));
   fdw_private = lappend(fdw_private, pstrdup("metadata2"));
   // ... 添加更多元素
   MemoryContextSwitchTo(old_ctx);
   // 赋值给fdw_private
   fpinfo->fdw_private = fdw_private;
   

3. 复杂结构体的序列化
   如果要传递自定义结构体，需要用nodeToString()和stringToNode()来序列化/反序列化：

   // 在GetForeignPlan中序列化结构体
   MyMetadata *meta = palloc0(sizeof(MyMetadata));
   // 填充meta数据
   char *meta_str = nodeToString((Node*)meta);
   fdw_private = lappend(fdw_private, meta_str);
   
   // 在BeginForeignScan中反序列化
   char *meta_str = lfirst(list_nth(fdw_private, 0));
   MyMetadata *meta = (MyMetadata*)stringToNode(meta_str);
   

使用Bytea替代List传递元数据的实现示例 #

如果List方案仍有问题，用Bytea作为载体是更可靠的方式，核心是将元数据序列化成二进制字节流，存储到fdw_private中：

1. 在GetForeignPlan中序列化元数据为Bytea #

// 假设你有一个自定义元数据结构体
typedef struct {
    int count;
    char **values;
    int json_len;
    char *json_data;
} FdwMetadata;

// 序列化函数：将结构体转为字节流
bytea* serialize_metadata(FdwMetadata *meta) {
    // 计算总长度（包含所有字段的实际数据）
    int total_len = sizeof(int);
    for (int i=0; i<meta->count; i++) {
        total_len += sizeof(int) + strlen(meta->values[i]) + 1;
    }
    total_len += sizeof(int) + meta->json_len;

    bytea *result = (bytea*)palloc(VARHDRSZ + total_len);
    char *ptr = VARDATA(result);
    
    // 写入count
    memcpy(ptr, &meta->count, sizeof(int));
    ptr += sizeof(int);
    
    // 写入每个value的长度和内容
    for (int i=0; i<meta->count; i++) {
        int str_len = strlen(meta->values[i]) + 1;
        memcpy(ptr, &str_len, sizeof(int));
        memcpy(ptr + sizeof(int), meta->values[i], str_len);
        ptr += sizeof(int) + str_len;
    }
    
    // 写入json数据
    memcpy(ptr, &meta->json_len, sizeof(int));
    memcpy(ptr + sizeof(int), meta->json_data, meta->json_len);
    ptr += sizeof(int) + meta->json_len;
    
    SET_VARSIZE(result, VARHDRSZ + total_len);
    return result;
}

// 在GetForeignPlan中使用
MemoryContext old_ctx = MemoryContextSwitchTo(plan->plan_node_context);
FdwMetadata *meta = palloc0(sizeof(FdwMetadata));
// 填充meta数据...
bytea *serialized = serialize_metadata(meta);
// 将bytea转为字符串形式存入List
char *bytea_str = byteaout(serialized);
List *fdw_private = lappend(NULL, bytea_str);
fpinfo->fdw_private = fdw_private;
MemoryContextSwitchTo(old_ctx);

2. 在BeginForeignScan中反序列化Bytea #

// 反序列化函数：从字节流恢复结构体
FdwMetadata* deserialize_metadata(bytea *serialized) {
    FdwMetadata *meta = palloc0(sizeof(FdwMetadata));
    char *ptr = VARDATA(serialized);
    
    // 读取count
    memcpy(&meta->count, ptr, sizeof(int));
    ptr += sizeof(int);
    
    // 读取每个value
    meta->values = palloc0(meta->count * sizeof(char*));
    for (int i=0; i<meta->count; i++) {
        int str_len;
        memcpy(&str_len, ptr, sizeof(int));
        ptr += sizeof(int);
        meta->values[i] = palloc(str_len);
        memcpy(meta->values[i], ptr, str_len);
        ptr += str_len;
    }
    
    // 读取json数据
    memcpy(&meta->json_len, ptr, sizeof(int));
    ptr += sizeof(int);
    meta->json_data = palloc(meta->json_len);
    memcpy(meta->json_data, ptr, meta->json_len);
    
    return meta;
}

// 在BeginForeignScan中使用
List *fdw_private = fsinfo->fdw_private;
char *bytea_str = lfirst(list_nth(fdw_private, 0));
bytea *serialized = byteain(bytea_str, strlen(bytea_str), -1);
FdwMetadata *meta = deserialize_metadata(serialized);

简化替代方案：用JSON作为中间格式 #

如果元数据结构不复杂，可以直接将元数据转为JSON字符串，再转为bytea存储，更易维护：

// 序列化：结构体转JSON字符串，再转bytea
char *json_str = "{\"count\":3,\"values\":[\"a\",\"b\",\"c\"]}";
bytea *serialized = cstring_to_text_with_len(json_str, strlen(json_str));

// 反序列化：bytea转字符串，再解析JSON
char *json_str_out = text_to_cstring((text*)serialized);
// 用PostgreSQL的JSON API解析内容，比如json_parse()

内容的提问来源于stack exchange，提问作者Ken Dellinger