xugu_driver_go/xugu/xugu_sock_recv2.go

package xugu

import (
	"bufio"
	"io"
)

// ----------------------------------------------------------------------------------------------------
type SrvResponse struct {
	FormArgDescri []*FormArgDescri
	SelectResult  []*SelectResult
	InsertResult  []*InsertResult
	UpdateResult  []*UpdateResult
	DeleteResult  []*DeleteResult
	ProcRet       []*ProcRet
	OutParamRet   []*OutParamRet
	ErrInfo       []*ErrInfo
	WarnInfo      []*WarnInfo
	Message       []*Message
}

type FormArgDescri struct {
	ArgNum int
	Args   []ArgDescri
}

type ArgDescri struct {
	ArgNameLen    int
	ArgName       string
	ArgNo         int
	ArgDType      int
	ArgPreciScale int
}

type InsertResult struct {
	RowidLen  int
	RowidData []byte
}

type UpdateResult struct {
	UpdateNum int
}

type DeleteResult struct {
	DeleteNum int
}

type ProcRet struct {
	RetDType   int
	RetDataLen int
	RetData    []byte
}

type OutParamRet struct {
	OutParamNo    int
	OutParamDType int
	OutParamLen   int
	OutParamData  []byte
}

type ErrInfo struct {
	ErrStrLen int
	ErrStr    string
}

type WarnInfo struct {
	WarnStrLen int
	WarnStr    string
}

type Message struct {
	MsgStrLen int
	MsgStr    string
}

// func parseResponse(conn net.Conn) (*SrvResponse, error) {
// 	response := &SrvResponse{}
// 	reader := bufio.NewReader(conn)

// 	for {
// 		msgType, err := reader.ReadByte()
// 		if err != nil {
// 			return nil, err
// 		}

// 		switch msgType {
// 		case '$':
// 			argDescri, err := parseFormArgDescri(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.FormArgDescri = append(response.FormArgDescri, argDescri)

// 		case 'I':
// 			insertResult, err := parseInsertResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.InsertResult = append(response.InsertResult, insertResult)
// 		case 'U':
// 			updateResult, err := parseUpdateResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.UpdateResult = append(response.UpdateResult, updateResult)
// 		case 'D':
// 			deleteResult, err := parseDeleteResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.DeleteResult = append(response.DeleteResult, deleteResult)
// 		case 'O':
// 			procRet, err := parseProcRet(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.ProcRet = append(response.ProcRet, procRet)
// 		case 'P':
// 			outParamRet, err := parseOutParamRet(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.OutParamRet = append(response.OutParamRet, outParamRet)
// 		case 'E':
// 			errInfo, err := parseErrInfo(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.ErrInfo = append(response.ErrInfo, errInfo)
// 		case 'W':
// 			warnInfo, err := parseWarnInfo(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.WarnInfo = append(response.WarnInfo, warnInfo)
// 		case 'M':
// 			message, err := parseMessage(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.Message = append(response.Message, message)
// 		case 'K':
// 			return response, nil
// 		default:
// 			return nil, fmt.Errorf("未知的消息类型: %v", msgType)
// 		}
// 	}
// }

// 解析函数的实现，例如 parseFormArgDescri 等

func parseFormArgDescri(reader *bufio.Reader) (*FormArgDescri, error) {
	argNum, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	formArgDescri := &FormArgDescri{ArgNum: argNum}
	for i := 0; i < argNum; i++ {
		argDescri := ArgDescri{}
		argDescri.ArgNameLen, err = readInt32(reader)
		if err != nil {
			return nil, err
		}
		argDescri.ArgName, err = readString(reader, argDescri.ArgNameLen)
		if err != nil {
			return nil, err
		}
		argDescri.ArgNo, err = readInt32(reader)
		if err != nil {
			return nil, err
		}
		argDescri.ArgDType, err = readInt32(reader)
		if err != nil {
			return nil, err
		}
		argDescri.ArgPreciScale, err = readInt32(reader)
		if err != nil {
			return nil, err
		}
		formArgDescri.Args = append(formArgDescri.Args, argDescri)
	}
	return formArgDescri, nil
}

func readString(reader *bufio.Reader, length int) (string, error) {
	bytes := make([]byte, length)
	_, err := reader.Read(bytes)
	return string(bytes), err
}

func parseFieldDescri(reader *bufio.Reader) (FieldDescri, error) {
	fieldDescri := FieldDescri{}
	var err error

	fieldDescri.FieldNameLen, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}
	fieldDescri.FieldName, err = readString(reader, fieldDescri.FieldNameLen)
	if err != nil {
		return fieldDescri, err
	}
	// fieldDescri.FieldType, err = fieldType(reader)
	// if err != nil {
	// 	return fieldDescri, err
	// }
	fieldDescri.FieldPreciScale, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}
	fieldDescri.FieldFlag, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}

	return fieldDescri, nil
}

func parseUpdateResult(reader *bufio.Reader) (*UpdateResult, error) {
	updateNum, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	return &UpdateResult{UpdateNum: updateNum}, nil
}
func parseDeleteResult(reader *bufio.Reader) (*DeleteResult, error) {
	deleteNum, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	return &DeleteResult{DeleteNum: deleteNum}, nil
}
func parseProcRet(reader *bufio.Reader) (*ProcRet, error) {
	retDType, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	retDataLen, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	retData := make([]byte, retDataLen)
	_, err = io.ReadFull(reader, retData)
	if err != nil {
		return nil, err
	}
	return &ProcRet{RetDType: retDType, RetDataLen: retDataLen, RetData: retData}, nil
}
func parseOutParamRet(reader *bufio.Reader) (*OutParamRet, error) {
	outParamNo, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	outParamDType, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	outParamLen, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	outParamData := make([]byte, outParamLen)
	_, err = io.ReadFull(reader, outParamData)
	if err != nil {
		return nil, err
	}
	return &OutParamRet{
		OutParamNo:    outParamNo,
		OutParamDType: outParamDType,
		OutParamLen:   outParamLen,
		OutParamData:  outParamData,
	}, nil
}
func parseErrInfo(reader *bufio.Reader) (*ErrInfo, error) {
	errStrLen, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	errStr, err := readString(reader, errStrLen)
	if err != nil {
		return nil, err
	}
	return &ErrInfo{ErrStrLen: errStrLen, ErrStr: errStr}, nil
}
func parseWarnInfo(reader *bufio.Reader) (*WarnInfo, error) {
	warnStrLen, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	warnStr, err := readString(reader, warnStrLen)
	if err != nil {
		return nil, err
	}
	return &WarnInfo{WarnStrLen: warnStrLen, WarnStr: warnStr}, nil
}
func parseMessage(reader *bufio.Reader) (*Message, error) {
	msgStrLen, err := readInt32(reader)
	if err != nil {
		return nil, err
	}
	msgStr, err := readString(reader, msgStrLen)
	if err != nil {
		return nil, err
	}
	return &Message{MsgStrLen: msgStrLen, MsgStr: msgStr}, nil
}