hoteas
7f7b585ffb
- 在应用程序中新增对达梦数据库（DM）的配置和连接支持 - 实现 SetDmDB 函数以配置达梦数据库连接 - 更新数据库操作逻辑，支持达梦特有的 SQL 语法和功能 - 在相关文件中添加达梦数据库的处理逻辑，包括表创建、数据插入和查询 - 更新 go.mod 和 go.sum 文件以引入达梦数据库驱动 - 增强文档，详细说明达梦数据库的配置和使用方法
918 lines
25 KiB
Go
918 lines
25 KiB
Go
/*
|
|
* Copyright (c) 2000-2018, 达梦数据库有限公司.
|
|
* All rights reserved.
|
|
*/
|
|
package dm
|
|
|
|
import (
|
|
"strconv"
|
|
"time"
|
|
|
|
"gitee.com/chunanyong/dm/util"
|
|
)
|
|
|
|
var DB2G db2g
|
|
|
|
type db2g struct {
|
|
}
|
|
|
|
func (DB2G db2g) processVarchar2(bytes []byte, prec int) []byte {
|
|
rbytes := make([]byte, prec)
|
|
copy(rbytes[:len(bytes)], bytes[:])
|
|
for i := len(bytes); i < len(rbytes); i++ {
|
|
rbytes[i] = ' '
|
|
}
|
|
return rbytes
|
|
}
|
|
|
|
func (DB2G db2g) charToString(bytes []byte, column *column, conn *DmConnection) string {
|
|
if column.colType == VARCHAR2 {
|
|
bytes = DB2G.processVarchar2(bytes, int(column.prec))
|
|
} else if column.colType == CLOB {
|
|
clob := newClobFromDB(bytes, conn, column, true)
|
|
clobLen, _ := clob.GetLength()
|
|
clobStr, _ := clob.getSubString(1, int32(clobLen))
|
|
return clobStr
|
|
}
|
|
return Dm_build_1346.Dm_build_1598(bytes, conn.serverEncoding, conn)
|
|
}
|
|
|
|
func (DB2G db2g) charToFloat64(bytes []byte, column *column, conn *DmConnection) (float64, error) {
|
|
str := DB2G.charToString(bytes, column, conn)
|
|
val, err := strconv.ParseFloat(str, 64)
|
|
if err != nil {
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
return val, nil
|
|
}
|
|
|
|
func (DB2G db2g) charToDeciaml(bytes []byte, column *column, conn *DmConnection) (*DmDecimal, error) {
|
|
str := DB2G.charToString(bytes, column, conn)
|
|
return NewDecimalFromString(str)
|
|
}
|
|
|
|
func (DB2G db2g) BinaryToInt64(bytes []byte, column *column, conn *DmConnection) (int64, error) {
|
|
if column.colType == BLOB {
|
|
blob := newBlobFromDB(bytes, conn, column, true)
|
|
blobLen, err := blob.GetLength()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
bytes, err = blob.getBytes(1, int32(blobLen))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
var n, b int64 = 0, 0
|
|
|
|
startIndex := 0
|
|
var length int
|
|
if len(bytes) > 8 {
|
|
length = 8
|
|
for j := 0; j < len(bytes)-8; j++ {
|
|
if bytes[j] != 0 {
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
startIndex = len(bytes) - 8
|
|
length = 8
|
|
}
|
|
} else {
|
|
length = len(bytes)
|
|
}
|
|
|
|
for j := startIndex; j < startIndex+length; j++ {
|
|
b = int64(0xff & bytes[j])
|
|
n = b | (n << 8)
|
|
}
|
|
|
|
return n, nil
|
|
}
|
|
|
|
func (DB2G db2g) decToDecimal(bytes []byte, prec int, scale int, compatibleOracle bool) (*DmDecimal, error) {
|
|
|
|
if compatibleOracle {
|
|
prec = -1
|
|
scale = -1
|
|
}
|
|
return newDecimal(bytes, prec, scale)
|
|
}
|
|
|
|
func (DB2G db2g) toBytes(bytes []byte, column *column, conn *DmConnection) ([]byte, error) {
|
|
retBytes := Dm_build_1346.Dm_build_1497(bytes, 0, len(bytes))
|
|
switch column.colType {
|
|
case CLOB:
|
|
clob := newClobFromDB(retBytes, conn, column, true)
|
|
str, err := clob.getSubString(1, int32(clob.length))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return Dm_build_1346.Dm_build_1562(str, conn.getServerEncoding(), conn), nil
|
|
case BLOB:
|
|
blob := newBlobFromDB(retBytes, conn, column, true)
|
|
bs, err := blob.getBytes(1, int32(blob.length))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return bs, nil
|
|
}
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toString(bytes []byte, column *column, conn *DmConnection) string {
|
|
switch column.colType {
|
|
case CHAR, VARCHAR, VARCHAR2:
|
|
return DB2G.charToString(bytes, column, conn)
|
|
case BIT, BOOLEAN, TINYINT:
|
|
return strconv.FormatInt(int64(bytes[0]), 10)
|
|
case SMALLINT:
|
|
return strconv.FormatInt(int64(Dm_build_1346.Dm_build_1570(bytes)), 10)
|
|
case INT:
|
|
return strconv.FormatInt(int64(Dm_build_1346.Dm_build_1573(bytes)), 10)
|
|
case BIGINT:
|
|
return strconv.FormatInt(int64(Dm_build_1346.Dm_build_1576(bytes)), 10)
|
|
case REAL:
|
|
return strconv.FormatFloat(float64(Dm_build_1346.Dm_build_1579(bytes)), 'f', -1, 32)
|
|
case DOUBLE:
|
|
return strconv.FormatFloat(float64(Dm_build_1346.Dm_build_1582(bytes)), 'f', -1, 64)
|
|
case DECIMAL:
|
|
|
|
case BINARY, VARBINARY:
|
|
util.StringUtil.BytesToHexString(bytes, false)
|
|
case BLOB:
|
|
|
|
case CLOB:
|
|
|
|
case DATE:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
if conn.FormatDate != "" {
|
|
return dtToStringByOracleFormat(dt, conn.FormatDate, column.scale, int(conn.OracleDateLanguage))
|
|
}
|
|
case TIME:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
if conn.FormatTime != "" {
|
|
return dtToStringByOracleFormat(dt, conn.FormatTime, column.scale, int(conn.OracleDateLanguage))
|
|
}
|
|
case DATETIME, DATETIME2:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
if conn.FormatTimestamp != "" {
|
|
return dtToStringByOracleFormat(dt, conn.FormatTimestamp, column.scale, int(conn.OracleDateLanguage))
|
|
}
|
|
case TIME_TZ:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
if conn.FormatTimeTZ != "" {
|
|
return dtToStringByOracleFormat(dt, conn.FormatTimeTZ, column.scale, int(conn.OracleDateLanguage))
|
|
}
|
|
case DATETIME_TZ, DATETIME2_TZ:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
if conn.FormatTimestampTZ != "" {
|
|
return dtToStringByOracleFormat(dt, conn.FormatTimestampTZ, column.scale, int(conn.OracleDateLanguage))
|
|
}
|
|
case INTERVAL_DT:
|
|
return newDmIntervalDTByBytes(bytes).String()
|
|
case INTERVAL_YM:
|
|
return newDmIntervalYMByBytes(bytes).String()
|
|
case ARRAY:
|
|
|
|
case SARRAY:
|
|
|
|
case CLASS:
|
|
|
|
case PLTYPE_RECORD:
|
|
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (DB2G db2g) toBool(bytes []byte, column *column, conn *DmConnection) (bool, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
return bytes[0] != 0, nil
|
|
case SMALLINT:
|
|
return Dm_build_1346.Dm_build_1443(bytes, 0) != 0, nil
|
|
case INT:
|
|
return Dm_build_1346.Dm_build_1448(bytes, 0) != 0, nil
|
|
case BIGINT:
|
|
return Dm_build_1346.Dm_build_1453(bytes, 0) != 0, nil
|
|
case REAL:
|
|
return Dm_build_1346.Dm_build_1458(bytes, 0) != 0, nil
|
|
case DOUBLE:
|
|
return Dm_build_1346.Dm_build_1462(bytes, 0) != 0, nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
return G2DB.toBool(DB2G.charToString(bytes, column, conn))
|
|
}
|
|
|
|
return false, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toByte(bytes []byte, column *column, conn *DmConnection) (byte, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
} else {
|
|
return bytes[0], nil
|
|
}
|
|
case SMALLINT:
|
|
tval := Dm_build_1346.Dm_build_1443(bytes, 0)
|
|
if tval < int16(BYTE_MIN) || tval > int16(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case INT:
|
|
tval := Dm_build_1346.Dm_build_1448(bytes, 0)
|
|
if tval < int32(BYTE_MIN) || tval > int32(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(BYTE_MIN) || tval > int64(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(BYTE_MIN) || tval > float32(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(BYTE_MIN) || tval > float64(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(BYTE_MIN) || tval > float64(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(BYTE_MIN) || tval > int64(BYTE_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return byte(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toInt8(bytes []byte, column *column, conn *DmConnection) (int8, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
return int8(bytes[0]), nil
|
|
case SMALLINT:
|
|
tval := Dm_build_1346.Dm_build_1443(bytes, 0)
|
|
if tval < int16(INT8_MIN) || tval < int16(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case INT:
|
|
|
|
tval := Dm_build_1346.Dm_build_1448(bytes, 0)
|
|
if tval < int32(INT8_MIN) || tval > int32(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(INT8_MIN) || tval > int64(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(INT8_MIN) || tval > float32(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(INT8_MIN) || tval > float64(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(INT8_MIN) || tval > float64(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(INT8_MIN) || tval > int64(INT8_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int8(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toInt16(bytes []byte, column *column, conn *DmConnection) (int16, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
return int16(bytes[0]), nil
|
|
case SMALLINT:
|
|
return Dm_build_1346.Dm_build_1443(bytes, 0), nil
|
|
case INT:
|
|
|
|
tval := Dm_build_1346.Dm_build_1448(bytes, 0)
|
|
if tval < int32(INT16_MIN) || tval > int32(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(INT16_MIN) || tval > int64(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(INT16_MIN) || tval > float32(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(INT16_MIN) || tval > float64(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(INT16_MIN) || tval > float64(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(INT16_MIN) || tval > int64(INT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int16(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toUInt16(bytes []byte, column *column, conn *DmConnection) (uint16, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
return uint16(bytes[0]), nil
|
|
case SMALLINT:
|
|
return uint16(Dm_build_1346.Dm_build_1443(bytes, 0)), nil
|
|
case INT:
|
|
tval := Dm_build_1346.Dm_build_1448(bytes, 0)
|
|
if tval < int32(UINT16_MIN) || tval > int32(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(UINT16_MIN) || tval > int64(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(UINT16_MIN) || tval > float32(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(UINT16_MIN) || tval > float64(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(UINT16_MIN) || tval > float64(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(UINT16_MIN) || tval > int64(UINT16_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint16(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toInt32(bytes []byte, column *column, conn *DmConnection) (int32, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
return int32(bytes[0]), nil
|
|
case SMALLINT:
|
|
return int32(Dm_build_1346.Dm_build_1443(bytes, 0)), nil
|
|
case INT:
|
|
return Dm_build_1346.Dm_build_1448(bytes, 0), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(INT32_MIN) || tval > int64(INT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int32(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(INT32_MIN) || tval > float32(INT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int32(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(INT32_MIN) || tval > float64(INT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int32(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(INT32_MIN) || tval > float64(INT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int32(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(INT32_MIN) || tval > int64(INT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int32(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toUInt32(bytes []byte, column *column, conn *DmConnection) (uint32, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
return uint32(bytes[0]), nil
|
|
case SMALLINT:
|
|
return uint32(Dm_build_1346.Dm_build_1443(bytes, 0)), nil
|
|
case INT:
|
|
return uint32(Dm_build_1346.Dm_build_1448(bytes, 0)), nil
|
|
case BIGINT:
|
|
tval := Dm_build_1346.Dm_build_1453(bytes, 0)
|
|
if tval < int64(UINT32_MIN) || tval > int64(UINT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint32(tval), nil
|
|
case REAL:
|
|
tval := Dm_build_1346.Dm_build_1458(bytes, 0)
|
|
if tval < float32(UINT32_MIN) || tval > float32(UINT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint32(tval), nil
|
|
case DOUBLE:
|
|
tval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
if tval < float64(UINT32_MIN) || tval > float64(UINT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint32(tval), nil
|
|
case DECIMAL:
|
|
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < float64(UINT32_MIN) || tval > float64(UINT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint32(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
{
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if tval < int64(UINT32_MIN) || tval > int64(UINT32_MAX) {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint32(tval), nil
|
|
}
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toInt64(bytes []byte, column *column, conn *DmConnection) (int64, error) {
|
|
switch column.colType {
|
|
case BOOLEAN, BIT, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return int64(0), nil
|
|
} else {
|
|
return int64(bytes[0]), nil
|
|
}
|
|
case SMALLINT:
|
|
return int64(Dm_build_1346.Dm_build_1570(bytes)), nil
|
|
case INT:
|
|
return int64(Dm_build_1346.Dm_build_1573(bytes)), nil
|
|
case BIGINT:
|
|
return int64(Dm_build_1346.Dm_build_1576(bytes)), nil
|
|
case REAL:
|
|
return int64(Dm_build_1346.Dm_build_1579(bytes)), nil
|
|
case DOUBLE:
|
|
return int64(Dm_build_1346.Dm_build_1582(bytes)), nil
|
|
|
|
case CHAR, VARCHAR2, VARCHAR, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if int64(tval) < INT64_MIN || int64(tval) > INT64_MAX {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return int64(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return tval, nil
|
|
}
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toUInt64(bytes []byte, column *column, conn *DmConnection) (uint64, error) {
|
|
switch column.colType {
|
|
case BOOLEAN, BIT, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return uint64(0), nil
|
|
} else {
|
|
return uint64(bytes[0]), nil
|
|
}
|
|
case SMALLINT:
|
|
return uint64(Dm_build_1346.Dm_build_1570(bytes)), nil
|
|
case INT:
|
|
return uint64(Dm_build_1346.Dm_build_1573(bytes)), nil
|
|
case BIGINT:
|
|
return uint64(Dm_build_1346.Dm_build_1576(bytes)), nil
|
|
case REAL:
|
|
return uint64(Dm_build_1346.Dm_build_1579(bytes)), nil
|
|
case DOUBLE:
|
|
return uint64(Dm_build_1346.Dm_build_1582(bytes)), nil
|
|
|
|
case CHAR, VARCHAR2, VARCHAR, CLOB:
|
|
tval, err := DB2G.charToFloat64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if uint64(tval) < UINT64_MIN || uint64(tval) > UINT64_MAX {
|
|
return 0, ECGO_DATA_OVERFLOW.throw()
|
|
}
|
|
return uint64(tval), nil
|
|
case BINARY, VARBINARY, BLOB:
|
|
tval, err := DB2G.BinaryToInt64(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return uint64(tval), nil
|
|
}
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toInt(bytes []byte, column *column, conn *DmConnection) (int, error) {
|
|
if strconv.IntSize == 32 {
|
|
tmp, err := DB2G.toInt32(bytes, column, conn)
|
|
return int(tmp), err
|
|
} else {
|
|
tmp, err := DB2G.toInt64(bytes, column, conn)
|
|
return int(tmp), err
|
|
}
|
|
}
|
|
|
|
func (DB2G db2g) toUInt(bytes []byte, column *column, conn *DmConnection) (uint, error) {
|
|
if strconv.IntSize == 32 {
|
|
tmp, err := DB2G.toUInt32(bytes, column, conn)
|
|
return uint(tmp), err
|
|
} else {
|
|
tmp, err := DB2G.toUInt64(bytes, column, conn)
|
|
return uint(tmp), err
|
|
}
|
|
}
|
|
|
|
func (DB2G db2g) toFloat32(bytes []byte, column *column, conn *DmConnection) (float32, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
return float32(bytes[0]), nil
|
|
case SMALLINT:
|
|
return float32(Dm_build_1346.Dm_build_1443(bytes, 0)), nil
|
|
case INT:
|
|
return float32(Dm_build_1346.Dm_build_1448(bytes, 0)), nil
|
|
case BIGINT:
|
|
return float32(Dm_build_1346.Dm_build_1453(bytes, 0)), nil
|
|
case REAL:
|
|
return Dm_build_1346.Dm_build_1458(bytes, 0), nil
|
|
case DOUBLE:
|
|
dval := Dm_build_1346.Dm_build_1462(bytes, 0)
|
|
return float32(dval), nil
|
|
case DECIMAL:
|
|
dval, err := DB2G.decToDecimal(bytes, int(column.prec), int(column.scale), conn.CompatibleOracle())
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return float32(dval.ToFloat64()), nil
|
|
case CHAR, VARCHAR2, VARCHAR, CLOB:
|
|
dval, err := DB2G.charToDeciaml(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return float32(dval.ToFloat64()), nil
|
|
}
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toFloat64(bytes []byte, column *column, conn *DmConnection) (float64, error) {
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if bytes == nil || len(bytes) == 0 {
|
|
return 0, nil
|
|
}
|
|
return float64(bytes[0]), nil
|
|
case SMALLINT:
|
|
return float64(Dm_build_1346.Dm_build_1443(bytes, 0)), nil
|
|
case INT:
|
|
return float64(Dm_build_1346.Dm_build_1448(bytes, 0)), nil
|
|
case BIGINT:
|
|
return float64(Dm_build_1346.Dm_build_1453(bytes, 0)), nil
|
|
case REAL:
|
|
return float64(Dm_build_1346.Dm_build_1458(bytes, 0)), nil
|
|
case DOUBLE:
|
|
return Dm_build_1346.Dm_build_1462(bytes, 0), nil
|
|
case DECIMAL:
|
|
dval, err := DB2G.decToDecimal(bytes, int(column.prec), int(column.scale), conn.CompatibleOracle())
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return dval.ToFloat64(), nil
|
|
case CHAR, VARCHAR2, VARCHAR, CLOB:
|
|
dval, err := DB2G.charToDeciaml(bytes, column, conn)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return dval.ToFloat64(), nil
|
|
}
|
|
|
|
return 0, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toDmBlob(value []byte, column *column, conn *DmConnection) *DmBlob {
|
|
|
|
switch column.colType {
|
|
case BLOB:
|
|
return newBlobFromDB(value, conn, column, conn.lobFetchAll())
|
|
default:
|
|
return newBlobOfLocal(value, conn)
|
|
}
|
|
}
|
|
|
|
func (DB2G db2g) toDmClob(value []byte, conn *DmConnection, column *column) *DmClob {
|
|
|
|
switch column.colType {
|
|
case CLOB:
|
|
return newClobFromDB(value, conn, column, conn.lobFetchAll())
|
|
default:
|
|
return newClobOfLocal(DB2G.toString(value, column, conn), conn)
|
|
}
|
|
}
|
|
|
|
func (DB2G db2g) toDmDecimal(value []byte, column *column, conn *DmConnection) (*DmDecimal, error) {
|
|
|
|
switch column.colType {
|
|
case BIT, BOOLEAN, TINYINT:
|
|
if value == nil || len(value) == 0 {
|
|
return NewDecimalFromInt64(0)
|
|
} else {
|
|
return NewDecimalFromInt64(int64(value[0]))
|
|
}
|
|
case SMALLINT:
|
|
return NewDecimalFromInt64(int64(Dm_build_1346.Dm_build_1443(value, 0)))
|
|
case INT:
|
|
return NewDecimalFromInt64(int64(Dm_build_1346.Dm_build_1448(value, 0)))
|
|
case BIGINT:
|
|
return NewDecimalFromInt64(Dm_build_1346.Dm_build_1453(value, 0))
|
|
case REAL:
|
|
return NewDecimalFromFloat64(float64(Dm_build_1346.Dm_build_1458(value, 0)))
|
|
case DOUBLE:
|
|
return NewDecimalFromFloat64(Dm_build_1346.Dm_build_1462(value, 0))
|
|
case DECIMAL:
|
|
return decodeDecimal(value, int(column.prec), int(column.scale))
|
|
case CHAR, VARCHAR, VARCHAR2, CLOB:
|
|
return DB2G.charToDeciaml(value, column, conn)
|
|
}
|
|
|
|
return nil, ECGO_DATA_CONVERTION_ERROR
|
|
}
|
|
|
|
func (DB2G db2g) toTime(bytes []byte, column *column, conn *DmConnection) (time.Time, error) {
|
|
switch column.colType {
|
|
case DATE, TIME, TIME_TZ, DATETIME_TZ, DATETIME, DATETIME2_TZ, DATETIME2:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
return toTimeFromDT(dt, int(conn.dmConnector.localTimezone)), nil
|
|
case CHAR, VARCHAR2, VARCHAR, CLOB:
|
|
return toTimeFromString(DB2G.charToString(bytes, column, conn), int(conn.dmConnector.localTimezone)), nil
|
|
}
|
|
return time.Now(), ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toObject(bytes []byte, column *column, conn *DmConnection) (interface{}, error) {
|
|
|
|
switch column.colType {
|
|
case BIT, BOOLEAN:
|
|
return bytes[0] != 0, nil
|
|
|
|
case TINYINT:
|
|
|
|
return Dm_build_1346.Dm_build_1439(bytes, 0), nil
|
|
case SMALLINT:
|
|
return Dm_build_1346.Dm_build_1443(bytes, 0), nil
|
|
case INT:
|
|
return Dm_build_1346.Dm_build_1448(bytes, 0), nil
|
|
case BIGINT:
|
|
return Dm_build_1346.Dm_build_1453(bytes, 0), nil
|
|
case DECIMAL:
|
|
return DB2G.decToDecimal(bytes, int(column.prec), int(column.scale), conn.CompatibleOracle())
|
|
case REAL:
|
|
return Dm_build_1346.Dm_build_1458(bytes, 0), nil
|
|
case DOUBLE:
|
|
return Dm_build_1346.Dm_build_1462(bytes, 0), nil
|
|
case DATE, TIME, DATETIME, TIME_TZ, DATETIME_TZ, DATETIME2, DATETIME2_TZ:
|
|
dt := decode(bytes, column.isBdta, *column, int(conn.dmConnector.localTimezone), int(conn.DbTimezone))
|
|
return toTimeFromDT(dt, int(conn.dmConnector.localTimezone)), nil
|
|
case BINARY, VARBINARY:
|
|
return bytes, nil
|
|
case BLOB:
|
|
blob := newBlobFromDB(bytes, conn, column, conn.lobFetchAll())
|
|
|
|
if util.StringUtil.EqualsIgnoreCase(column.typeName, "LONGVARBINARY") {
|
|
|
|
l, err := blob.GetLength()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return blob.getBytes(1, int32(l))
|
|
} else {
|
|
return blob, nil
|
|
}
|
|
case CHAR, VARCHAR, VARCHAR2:
|
|
val := DB2G.charToString(bytes, column, conn)
|
|
if column.mask == MASK_BFILE {
|
|
|
|
}
|
|
|
|
return val, nil
|
|
case CLOB:
|
|
clob := newClobFromDB(bytes, conn, column, conn.lobFetchAll())
|
|
if util.StringUtil.EqualsIgnoreCase(column.typeName, "LONGVARCHAR") {
|
|
|
|
l, err := clob.GetLength()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return clob.getSubString(1, int32(l))
|
|
} else {
|
|
return clob, nil
|
|
}
|
|
case INTERVAL_YM:
|
|
return newDmIntervalYMByBytes(bytes), nil
|
|
case INTERVAL_DT:
|
|
return newDmIntervalDTByBytes(bytes), nil
|
|
case ARRAY:
|
|
return TypeDataSV.bytesToArray(bytes, nil, column.typeDescriptor)
|
|
case SARRAY:
|
|
return TypeDataSV.bytesToSArray(bytes, nil, column.typeDescriptor)
|
|
case CLASS:
|
|
|
|
case PLTYPE_RECORD:
|
|
|
|
default:
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
|
|
func (DB2G db2g) toComplexType(bytes []byte, column *column, conn *DmConnection) (interface{}, error) {
|
|
switch column.colType {
|
|
case BLOB:
|
|
if !isComplexType(int(column.colType), int(column.scale)) {
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
blob := newBlobFromDB(bytes, conn, column, true)
|
|
return TypeDataSV.objBlobToObj(blob, column.typeDescriptor)
|
|
case ARRAY:
|
|
return TypeDataSV.bytesToArray(bytes, nil, column.typeDescriptor)
|
|
case SARRAY:
|
|
return TypeDataSV.bytesToSArray(bytes, nil, column.typeDescriptor)
|
|
case CLASS:
|
|
return TypeDataSV.bytesToObj(bytes, nil, column.typeDescriptor)
|
|
case PLTYPE_RECORD:
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
default:
|
|
return nil, ECGO_DATA_CONVERTION_ERROR.throw()
|
|
}
|
|
}
|