Golang如何调用Oracle存储过程并处理自定义类型的输出参数

在Go中调用Oracle存储过程并处理包含BLOB的自定义类型输出参数，需要使用godror库的特殊处理方式。以下是解决方案：

package main

import (
    "context"
    "database/sql"
    "fmt"
    "io"
    "github.com/godror/godror"
    _ "github.com/godror/godror"
)

type FileData struct {
    FileName     string
    FileType     string
    FileContents []byte
}

func main() {
    db, err := sql.Open("godror", "xxeem/*****@ORAPOCDB")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer db.Close()

    ctx := context.Background()
    conn, err := db.Conn(ctx)
    if err != nil {
        fmt.Println("Connection error:", err)
        return
    }
    defer conn.Close()

    // 获取对象类型
    objType, err := godror.GetObjectType(ctx, conn, "XX_TEST_OBJ")
    if err != nil {
        fmt.Println("GetObjectType error:", err)
        return
    }

    // 创建对象实例
    obj, err := objType.NewObject()
    if err != nil {
        fmt.Println("NewObject error:", err)
        return
    }
    defer obj.Close()

    var code, message string
    
    // 准备调用语句
    stmt, err := conn.PrepareContext(ctx, 
        "BEGIN xxtest_procedure(:1, :2, :3, :4, :5, :6); END;")
    if err != nil {
        fmt.Println("Prepare error:", err)
        return
    }
    defer stmt.Close()

    // 执行存储过程
    _, err = stmt.ExecContext(ctx,
        "Test",           // p_cco_id
        "Test",           // p_partner_name
        "Test",           // p_tp_ref_num
        sql.Out{Dest: &obj}, // p_shipind_docs_o
        sql.Out{Dest: &code}, // p_return_code_o
        sql.Out{Dest: &message}, // p_return_message_o
    )
    if err != nil {
        fmt.Println("Exec error:", err)
        return
    }

    // 从对象中提取数据
    var fileData FileData
    
    // 获取FILE_NAME
    fileNameVal, err := obj.Get("FILE_NAME")
    if err != nil {
        fmt.Println("Get FILE_NAME error:", err)
        return
    }
    if fileNameBytes, ok := fileNameVal.([]byte); ok {
        fileData.FileName = string(fileNameBytes)
    }

    // 获取FILE_TYPE
    fileTypeVal, err := obj.Get("FILE_TYPE")
    if err != nil {
        fmt.Println("Get FILE_TYPE error:", err)
        return
    }
    if fileTypeBytes, ok := fileTypeVal.([]byte); ok {
        fileData.FileType = string(fileTypeBytes)
    }

    // 获取FILE_CONTENTS (BLOB)
    fileContentsVal, err := obj.Get("FILE_CONTENTS")
    if err != nil {
        fmt.Println("Get FILE_CONTENTS error:", err)
        return
    }

    // 处理BLOB数据
    if lob, ok := fileContentsVal.(*godror.Lob); ok {
        // 方法1: 直接读取到字节数组
        blobData, err := io.ReadAll(lob)
        if err != nil {
            fmt.Println("Read BLOB error:", err)
            return
        }
        fileData.FileContents = blobData
        
        // 方法2: 使用Hijack获取底层Reader
        // reader := lob.Hijack()
        // blobData, err := io.ReadAll(reader)
        // if err != nil {
        //     fmt.Println("Read BLOB error:", err)
        //     return
        // }
        // fileData.FileContents = blobData
    }

    fmt.Println("Return Code:", code)
    fmt.Println("Return Message:", message)
    fmt.Println("File Name:", fileData.FileName)
    fmt.Println("File Type:", fileData.FileType)
    fmt.Printf("File Contents Size: %d bytes\n", len(fileData.FileContents))
}

对于BLOB属性的处理，这里提供另一种更详细的实现方式：

func getBlobFromObject(obj *godror.Object, attrName string) ([]byte, error) {
    val, err := obj.Get(attrName)
    if err != nil {
        return nil, fmt.Errorf("failed to get attribute %s: %w", attrName, err)
    }

    switch v := val.(type) {
    case *godror.Lob:
        // 使用Hijack获取Reader
        reader := v.Hijack()
        defer v.Close()
        
        data, err := io.ReadAll(reader)
        if err != nil {
            return nil, fmt.Errorf("failed to read BLOB: %w", err)
        }
        return data, nil
        
    case []byte:
        // 如果已经是字节数组，直接返回
        return v, nil
        
    default:
        return nil, fmt.Errorf("unexpected type for BLOB: %T", v)
    }
}

// 在main函数中使用
func main() {
    // ... 前面的代码相同
    
    // 获取BLOB内容
    blobData, err := getBlobFromObject(obj, "FILE_CONTENTS")
    if err != nil {
        fmt.Println("Error getting BLOB:", err)
        return
    }
    
    fileData.FileContents = blobData
    
    // 输出结果
    fmt.Printf("Successfully retrieved file: %s (Type: %s, Size: %d bytes)\n",
        fileData.FileName, fileData.FileType, len(fileData.FileContents))
}

如果遇到BLOB为空的情况，可以添加空值检查：

func getBlobFromObjectSafe(obj *godror.Object, attrName string) ([]byte, error) {
    val, err := obj.Get(attrName)
    if err != nil {
        return nil, fmt.Errorf("failed to get attribute %s: %w", attrName, err)
    }

    // 检查是否为空
    if val == nil {
        return nil, nil
    }

    if lob, ok := val.(*godror.Lob); ok {
        // 检查Lob是否为空
        if lob == nil || lob.IsNull() {
            return nil, nil
        }
        
        reader := lob.Hijack()
        defer lob.Close()
        
        data, err := io.ReadAll(reader)
        if err != nil {
            return nil, fmt.Errorf("failed to read BLOB: %w", err)
        }
        return data, nil
    }
    
    return nil, fmt.Errorf("unexpected type for BLOB: %T", val)
}

关键点：

1. 使用godror.Lob类型处理BLOB数据
2. 通过Hijack()方法获取io.Reader来读取BLOB内容
3. 使用io.ReadAll()将BLOB数据读取到字节数组
4. 正确处理对象属性的类型转换
5. 注意资源的关闭和错误处理