github.com/wanlay/gorm-dm8@v1.0.5/dmr/zzo.go (about)

     1  /*
     2   * Copyright (c) 2000-2018, 达梦数据库有限公司.
     3   * All rights reserved.
     4   */
     5  package dmr
     6  
     7  import (
     8  	"strconv"
     9  
    10  	"github.com/wanlay/gorm-dm8/dmr/util"
    11  )
    12  
    13  const (
    14  	ARRAY_TYPE_SHORT = 1
    15  
    16  	ARRAY_TYPE_INTEGER = 2
    17  
    18  	ARRAY_TYPE_LONG = 3
    19  
    20  	ARRAY_TYPE_FLOAT = 4
    21  
    22  	ARRAY_TYPE_DOUBLE = 5
    23  )
    24  
    25  var TypeDataSV TypeData
    26  
    27  type InterfaceTypeData interface {
    28  	toBytes(x *TypeData, typeDesc *TypeDescriptor) ([]byte, error)
    29  }
    30  
    31  type TypeData struct {
    32  	m_dumyData interface{}
    33  
    34  	m_offset int
    35  
    36  	m_bufLen int
    37  
    38  	m_dataBuf []byte
    39  
    40  	m_objBlobDescBuf []byte
    41  
    42  	m_isFromBlob bool
    43  
    44  	m_packid int
    45  
    46  	m_objRefArr []interface{}
    47  }
    48  
    49  func newTypeData(val interface{}, dataBuf []byte) *TypeData {
    50  	td := new(TypeData).initTypeData()
    51  	td.m_dumyData = val
    52  	td.m_offset = 0
    53  	td.m_bufLen = 0
    54  	td.m_dataBuf = dataBuf
    55  	return td
    56  }
    57  
    58  func (td *TypeData) initTypeData() *TypeData {
    59  	td.m_dumyData = nil
    60  
    61  	td.m_offset = 0
    62  
    63  	td.m_bufLen = 0
    64  
    65  	td.m_dataBuf = nil
    66  
    67  	td.m_objBlobDescBuf = nil
    68  
    69  	td.m_isFromBlob = false
    70  
    71  	td.m_packid = -1
    72  
    73  	td.m_objRefArr = make([]interface{}, 0)
    74  
    75  	return td
    76  }
    77  
    78  func (sv TypeData) toStruct(objArr []interface{}, desc *TypeDescriptor) ([]TypeData, error) {
    79  	size := desc.getStrctMemSize()
    80  	retData := make([]TypeData, size)
    81  
    82  	for i := 0; i < size; i++ {
    83  
    84  		if objArr[i] == nil {
    85  			retData[i] = *newTypeData(objArr[i], nil)
    86  			continue
    87  		}
    88  
    89  		switch objArr[i].(type) {
    90  		case DmStruct, DmArray:
    91  			retData[i] = *newTypeData(objArr[i], nil)
    92  		default:
    93  			switch desc.m_fieldsObj[i].getDType() {
    94  			case CLASS, PLTYPE_RECORD:
    95  				tdArr, err := sv.toStruct(objArr[i].([]interface{}), &desc.m_fieldsObj[i])
    96  				if err != nil {
    97  					return nil, err
    98  				}
    99  
   100  				retData[i] = *newTypeData(newDmStructByTypeData(tdArr, &desc.m_fieldsObj[i]), nil)
   101  			case ARRAY, SARRAY:
   102  				tdArr, err := sv.toArray(objArr[i].([]interface{}), &desc.m_fieldsObj[i])
   103  				if err != nil {
   104  					return nil, err
   105  				}
   106  
   107  				retData[i] = *newTypeData(newDmArrayByTypeData(tdArr, &desc.m_fieldsObj[i]), nil)
   108  			default:
   109  				tdArr, err := sv.toMemberObj(objArr[i], &desc.m_fieldsObj[i])
   110  				if err != nil {
   111  					return nil, err
   112  				}
   113  				retData[i] = *tdArr
   114  			}
   115  
   116  		}
   117  	}
   118  	return retData, nil
   119  }
   120  
   121  func (sv TypeData) toArray(objArr []interface{}, desc *TypeDescriptor) ([]TypeData, error) {
   122  	size := len(objArr)
   123  	retData := make([]TypeData, size)
   124  	for i := 0; i < size; i++ {
   125  		if objArr[i] == nil {
   126  			retData[i] = *newTypeData(objArr[i], nil)
   127  			continue
   128  		}
   129  
   130  		switch objArr[i].(type) {
   131  		case DmStruct, DmArray:
   132  			retData[i] = *newTypeData(objArr[i], nil)
   133  		default:
   134  			switch desc.m_arrObj.getDType() {
   135  			case CLASS, PLTYPE_RECORD:
   136  				tdArr, err := sv.toStruct(objArr[i].([]interface{}), desc.m_arrObj)
   137  				if err != nil {
   138  					return nil, err
   139  				}
   140  				retData[i] = *newTypeData(newDmStructByTypeData(tdArr, desc.m_arrObj), nil)
   141  			case ARRAY, SARRAY:
   142  
   143  				tmp, ok := objArr[i].([]interface{})
   144  
   145  				if !ok && desc.m_arrObj.m_arrObj != nil {
   146  					obj, err := sv.makeupObjToArr(tmp[i], desc.m_arrObj)
   147  					if err != nil {
   148  						return nil, err
   149  					}
   150  					objArr[i] = obj
   151  				}
   152  
   153  				tdArr, err := sv.toArray(objArr[i].([]interface{}), desc.m_arrObj)
   154  				if err != nil {
   155  					return nil, err
   156  				}
   157  
   158  				retData[i] = *newTypeData(newDmArrayByTypeData(tdArr, desc.m_arrObj), nil)
   159  			default:
   160  				tdArr, err := sv.toMemberObj(objArr[i], desc.m_arrObj)
   161  				if err != nil {
   162  					return nil, err
   163  				}
   164  				retData[i] = *tdArr
   165  			}
   166  		}
   167  	}
   168  
   169  	return retData, nil
   170  }
   171  
   172  func (sv TypeData) makeupObjToArr(obj interface{}, objDesc *TypeDescriptor) ([]interface{}, error) {
   173  	arrType := objDesc.getDType()
   174  	dynamic := true
   175  	arrLen := 0
   176  	if arrType == SARRAY {
   177  		dynamic = false
   178  		arrLen = objDesc.m_length
   179  	}
   180  
   181  	subType := objDesc.m_arrObj.getDType()
   182  	if subType == BINARY || subType == VARBINARY || subType == BIT {
   183  
   184  		strRet := ""
   185  		switch v := obj.(type) {
   186  		case int:
   187  			strRet = strconv.FormatInt(int64(v), 2)
   188  		case int32:
   189  			strRet = strconv.FormatInt(int64(v), 2)
   190  		case int64:
   191  			strRet = strconv.FormatInt(v, 2)
   192  		case string:
   193  			strRet = v
   194  		default:
   195  			return nil, ECGO_DATA_CONVERTION_ERROR.throw()
   196  		}
   197  		var prec int
   198  		if dynamic {
   199  			prec = len(strRet)
   200  		} else {
   201  			prec = arrLen
   202  		}
   203  
   204  		ret := make([]interface{}, prec)
   205  		rs := Dm_build_1220.Dm_build_1433(strRet, objDesc.getServerEncoding(), objDesc.m_conn)
   206  		for i := 0; i < prec; i++ {
   207  			ret[i] = rs[i]
   208  		}
   209  
   210  		return ret, nil
   211  	}
   212  
   213  	return nil, ECGO_DATA_CONVERTION_ERROR.throw()
   214  }
   215  
   216  func (sv TypeData) toMemberObj(mem interface{}, desc *TypeDescriptor) (*TypeData, error) {
   217  	var bs []byte
   218  	scale := desc.getScale()
   219  	prec := desc.getPrec()
   220  	dtype := desc.getDType()
   221  	if mem == nil {
   222  		return newTypeData(nil, nil), nil
   223  	}
   224  
   225  	param := new(parameter).InitParameter()
   226  	param.colType = int32(dtype)
   227  	param.prec = int32(prec)
   228  	param.scale = int32(scale)
   229  
   230  	var err error
   231  	bs, err = G2DB.fromObject(mem, *param, desc.m_conn)
   232  	if err != nil {
   233  		return nil, err
   234  	}
   235  
   236  	return newTypeData(mem, bs), nil
   237  }
   238  
   239  func (sv TypeData) typeDataToBytes(data *TypeData, desc *TypeDescriptor) ([]byte, error) {
   240  	dType := desc.getDType()
   241  	var innerData []byte
   242  	var err error
   243  	if nil == data.m_dumyData {
   244  		innerData = sv.realocBuffer(nil, 0, 2)
   245  		Dm_build_1220.Dm_build_1221(innerData, 0, byte(0))
   246  		Dm_build_1220.Dm_build_1221(innerData, 1, byte(0))
   247  		return innerData, nil
   248  	}
   249  
   250  	var result []byte
   251  	var offset int
   252  	switch dType {
   253  	case ARRAY:
   254  
   255  		innerData, err = sv.arrayToBytes(data.m_dumyData.(*DmArray), desc)
   256  		if err != nil {
   257  			return nil, err
   258  		}
   259  
   260  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE)
   261  
   262  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   263  		offset = 1
   264  
   265  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   266  		offset += 1
   267  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   268  		return result, nil
   269  
   270  	case SARRAY:
   271  
   272  		innerData, err = sv.sarrayToBytes(data.m_dumyData.(*DmArray), desc)
   273  		if err != nil {
   274  			return nil, err
   275  		}
   276  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE)
   277  
   278  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   279  		offset = 1
   280  
   281  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   282  		offset += 1
   283  
   284  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   285  		return result, nil
   286  
   287  	case CLASS:
   288  
   289  		innerData, err = sv.objToBytes(data.m_dumyData, desc)
   290  		if err != nil {
   291  			return nil, err
   292  		}
   293  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE)
   294  
   295  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   296  		offset = 1
   297  
   298  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   299  		offset += 1
   300  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   301  		return result, nil
   302  
   303  	case PLTYPE_RECORD:
   304  
   305  		innerData, err = sv.recordToBytes(data.m_dumyData.(*DmStruct), desc)
   306  		if err != nil {
   307  			return nil, err
   308  		}
   309  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE)
   310  
   311  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   312  		offset = 1
   313  
   314  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   315  		offset += 1
   316  
   317  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   318  		return result, nil
   319  
   320  	case BLOB, CLOB:
   321  		innerData, err = sv.convertLobToBytes(data.m_dumyData, int(desc.column.colType), desc.getServerEncoding())
   322  
   323  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE)
   324  
   325  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   326  		offset = 1
   327  
   328  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   329  		offset += 1
   330  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   331  		return result, nil
   332  
   333  	case BOOLEAN:
   334  		innerData = sv.realocBuffer(nil, 0, 2)
   335  		Dm_build_1220.Dm_build_1221(innerData, 0, byte(0))
   336  		if data.m_dataBuf != nil && len(data.m_dataBuf) > 0 {
   337  			Dm_build_1220.Dm_build_1221(innerData, 1, data.m_dataBuf[0])
   338  		} else {
   339  			Dm_build_1220.Dm_build_1221(innerData, 1, byte(0))
   340  		}
   341  		return innerData, nil
   342  
   343  	default:
   344  
   345  		innerData = data.m_dataBuf
   346  		result = sv.realocBuffer(nil, 0, len(innerData)+BYTE_SIZE+BYTE_SIZE+USINT_SIZE)
   347  
   348  		Dm_build_1220.Dm_build_1221(result, 0, byte(0))
   349  		offset = 1
   350  
   351  		Dm_build_1220.Dm_build_1221(result, offset, byte(1))
   352  		offset += 1
   353  
   354  		Dm_build_1220.Dm_build_1231(result, offset, int16(len(innerData)))
   355  		offset += 2
   356  
   357  		copy(result[offset:offset+len(innerData)], innerData[:len(innerData)])
   358  
   359  		return result, nil
   360  	}
   361  }
   362  
   363  func (sv TypeData) convertLobToBytes(value interface{}, dtype int, serverEncoding string) ([]byte, error) {
   364  	var tmp []byte
   365  	var ret []byte
   366  	if dtype == BLOB {
   367  		lob, ok := value.(DmBlob)
   368  		if ok {
   369  			l, err := lob.GetLength()
   370  			if err != nil {
   371  				return nil, err
   372  			}
   373  			tmp, err = lob.getBytes(1, int32(l))
   374  			if err != nil {
   375  				return nil, err
   376  			}
   377  
   378  			ret = make([]byte, l+ULINT_SIZE)
   379  			Dm_build_1220.Dm_build_1236(ret, 0, int32(l))
   380  			copy(ret[:ULINT_SIZE:ULINT_SIZE+l], tmp[:l])
   381  			return ret, nil
   382  		}
   383  
   384  	}
   385  
   386  	if dtype == CLOB {
   387  		lob, ok := value.(DmClob)
   388  		if ok {
   389  			l, err := lob.GetLength()
   390  			if err != nil {
   391  				return nil, err
   392  			}
   393  
   394  			subString, err := lob.getSubString(1, int32(l))
   395  			if err != nil {
   396  				return nil, err
   397  			}
   398  
   399  			tmp = Dm_build_1220.Dm_build_1433(subString, serverEncoding, nil)
   400  			ret = make([]byte, len(tmp)+ULINT_SIZE)
   401  			Dm_build_1220.Dm_build_1236(ret, 0, int32(l))
   402  			copy(ret[:ULINT_SIZE:ULINT_SIZE+l], tmp[:l])
   403  		}
   404  		return ret, nil
   405  	}
   406  
   407  	return nil, ECGO_DATA_CONVERTION_ERROR.throw()
   408  }
   409  
   410  func (sv TypeData) sarrayToBytes(data *DmArray, desc *TypeDescriptor) ([]byte, error) {
   411  	realLen := len(data.m_arrData)
   412  	results := make([][]byte, realLen)
   413  	var rdata []byte
   414  	var err error
   415  
   416  	if desc.getObjId() == 4 {
   417  		return sv.ctlnToBytes(data, desc)
   418  	}
   419  
   420  	totalLen := 0
   421  	for i := 0; i < realLen; i++ {
   422  		results[i], err = sv.typeDataToBytes(&data.m_arrData[i], desc.m_arrObj)
   423  		if err != nil {
   424  			return nil, err
   425  		}
   426  		totalLen += len(results[i])
   427  	}
   428  
   429  	totalLen += (ULINT_SIZE + ULINT_SIZE)
   430  	rdata = sv.realocBuffer(nil, 0, totalLen)
   431  	off := 0
   432  
   433  	Dm_build_1220.Dm_build_1236(rdata, off, int32(totalLen))
   434  	off += ULINT_SIZE
   435  
   436  	Dm_build_1220.Dm_build_1236(rdata, off, int32(data.m_arrDesc.getLength()))
   437  	off += ULINT_SIZE
   438  
   439  	for i := 0; i < realLen; i++ {
   440  		copy(rdata[off:off+len(results[i])], results[i][:len(results[i])])
   441  		off += len(results[i])
   442  	}
   443  
   444  	return rdata, nil
   445  }
   446  
   447  func (sv TypeData) ctlnToBytes(data *DmArray, desc *TypeDescriptor) ([]byte, error) {
   448  	results := make([][]byte, len(data.m_arrData))
   449  	var rdata []byte
   450  	var err error
   451  
   452  	var totalLen int
   453  	totalLen = BYTE_SIZE + ULINT_SIZE
   454  
   455  	totalLen += USINT_SIZE + USINT_SIZE + ULINT_SIZE
   456  
   457  	for i := 0; i < len(data.m_arrData); i++ {
   458  		results[i], err = sv.typeDataToBytes(&data.m_arrData[i], desc.m_arrObj)
   459  		if err != nil {
   460  			return nil, err
   461  		}
   462  		totalLen += len(results[i])
   463  	}
   464  
   465  	rdata = sv.realocBuffer(nil, 0, totalLen)
   466  
   467  	offset := 0
   468  
   469  	Dm_build_1220.Dm_build_1221(rdata, offset, byte(0))
   470  	offset += BYTE_SIZE
   471  
   472  	offset += ULINT_SIZE
   473  
   474  	Dm_build_1220.Dm_build_1231(rdata, offset, int16(desc.getCltnType()))
   475  	offset += USINT_SIZE
   476  
   477  	Dm_build_1220.Dm_build_1231(rdata, offset, int16(desc.m_arrObj.getDType()))
   478  	offset += USINT_SIZE
   479  
   480  	Dm_build_1220.Dm_build_1236(rdata, offset, int32(len(data.m_arrData)))
   481  	offset += ULINT_SIZE
   482  
   483  	for i := 0; i < len(data.m_arrData); i++ {
   484  		copy(rdata[offset:offset+len(results[i])], results[i][:len(results[i])])
   485  		offset += len(results[i])
   486  	}
   487  
   488  	Dm_build_1220.Dm_build_1236(rdata, BYTE_SIZE, int32(offset))
   489  
   490  	return rdata, nil
   491  }
   492  
   493  func (sv TypeData) arrayToBytes(data *DmArray, desc *TypeDescriptor) ([]byte, error) {
   494  	results := make([][]byte, len(data.m_arrData))
   495  	var rdata []byte
   496  	var err error
   497  	if desc.getObjId() == 4 {
   498  		return sv.ctlnToBytes(data, desc)
   499  	}
   500  
   501  	totalLen := 0
   502  	for i := 0; i < len(data.m_arrData); i++ {
   503  		results[i], err = sv.typeDataToBytes(&data.m_arrData[i], desc.m_arrObj)
   504  		if err != nil {
   505  			return nil, err
   506  		}
   507  		totalLen += len(results[i])
   508  	}
   509  
   510  	totalLen += (ULINT_SIZE + ULINT_SIZE + ULINT_SIZE + ULINT_SIZE + ULINT_SIZE)
   511  
   512  	total := data.m_objCount + data.m_strCount
   513  	if total > 0 {
   514  		totalLen += USINT_SIZE * total
   515  	}
   516  
   517  	rdata = sv.realocBuffer(nil, 0, totalLen)
   518  
   519  	Dm_build_1220.Dm_build_1236(rdata, 0, int32(totalLen))
   520  	offset := ULINT_SIZE
   521  
   522  	Dm_build_1220.Dm_build_1236(rdata, offset, int32(len(data.m_arrData)))
   523  	offset += ULINT_SIZE
   524  
   525  	Dm_build_1220.Dm_build_1236(rdata, offset, 0)
   526  	offset += ULINT_SIZE
   527  
   528  	Dm_build_1220.Dm_build_1236(rdata, offset, int32(data.m_objCount))
   529  	offset += ULINT_SIZE
   530  
   531  	Dm_build_1220.Dm_build_1236(rdata, offset, int32(data.m_strCount))
   532  	offset += ULINT_SIZE
   533  
   534  	for i := 0; i < total; i++ {
   535  		Dm_build_1220.Dm_build_1236(rdata, offset, int32(data.m_objStrOffs[i]))
   536  		offset += ULINT_SIZE
   537  	}
   538  
   539  	for i := 0; i < len(data.m_arrData); i++ {
   540  		copy(rdata[offset:offset+len(results[i])], results[i][:len(results[i])])
   541  		offset += len(results[i])
   542  	}
   543  
   544  	return rdata, nil
   545  }
   546  
   547  func (sv TypeData) objToBytes(data interface{}, desc *TypeDescriptor) ([]byte, error) {
   548  
   549  	switch data.(type) {
   550  	case DmArray:
   551  		return sv.arrayToBytes(data.(*DmArray), desc)
   552  	default:
   553  		return sv.structToBytes(data.(*DmStruct), desc)
   554  	}
   555  }
   556  
   557  func (sv TypeData) structToBytes(data *DmStruct, desc *TypeDescriptor) ([]byte, error) {
   558  	size := desc.getStrctMemSize()
   559  	results := make([][]byte, size)
   560  	var rdata []byte
   561  	var err error
   562  
   563  	totalLen := 0
   564  	for i := 0; i < size; i++ {
   565  		results[i], err = sv.typeDataToBytes(&data.m_attribs[i], &desc.m_fieldsObj[i])
   566  		if err != nil {
   567  			return nil, err
   568  		}
   569  		totalLen += len(results[i])
   570  	}
   571  
   572  	totalLen += (BYTE_SIZE + ULINT_SIZE)
   573  
   574  	rdata = sv.realocBuffer(nil, 0, totalLen)
   575  	offset := 0
   576  
   577  	Dm_build_1220.Dm_build_1221(rdata, offset, byte(0))
   578  	offset += BYTE_SIZE
   579  
   580  	Dm_build_1220.Dm_build_1236(rdata, offset, int32(totalLen))
   581  	offset += ULINT_SIZE
   582  
   583  	for i := 0; i < size; i++ {
   584  		copy(rdata[offset:offset+len(results[i])], results[i][:len(results[i])])
   585  		offset += len(results[i])
   586  	}
   587  
   588  	return rdata, nil
   589  }
   590  
   591  func (sv TypeData) recordToBytes(data *DmStruct, desc *TypeDescriptor) ([]byte, error) {
   592  	size := desc.getStrctMemSize()
   593  	results := make([][]byte, size)
   594  	var rdata []byte
   595  	var err error
   596  
   597  	totalLen := 0
   598  	for i := 0; i < size; i++ {
   599  		results[i], err = sv.typeDataToBytes(&data.m_attribs[i], &desc.m_fieldsObj[i])
   600  		if err != nil {
   601  			return nil, err
   602  		}
   603  		totalLen += len(results[i])
   604  	}
   605  
   606  	totalLen += ULINT_SIZE
   607  	rdata = sv.realocBuffer(nil, 0, totalLen)
   608  	Dm_build_1220.Dm_build_1236(rdata, 0, int32(totalLen))
   609  
   610  	offset := ULINT_SIZE
   611  	for i := 0; i < desc.getStrctMemSize(); i++ {
   612  		copy(rdata[offset:offset+len(results[i])], results[i][:len(results[i])])
   613  		offset += len(results[i])
   614  	}
   615  
   616  	return rdata, nil
   617  }
   618  
   619  func (sv TypeData) bytesToBlob(val []byte, out *TypeData, desc *TypeDescriptor) (*TypeData, error) {
   620  	offset := out.m_offset
   621  	l := Dm_build_1220.Dm_build_1322(val, offset)
   622  	offset += ULINT_SIZE
   623  
   624  	tmp := Dm_build_1220.Dm_build_1371(val, offset, int(l))
   625  	offset += int(l)
   626  	out.m_offset = offset
   627  
   628  	return newTypeData(newBlobOfLocal(tmp, desc.m_conn), tmp), nil
   629  }
   630  
   631  func (sv TypeData) bytesToClob(val []byte, out *TypeData, desc *TypeDescriptor, serverEncoding string) (*TypeData, error) {
   632  	offset := out.m_offset
   633  	l := Dm_build_1220.Dm_build_1322(val, offset)
   634  	offset += ULINT_SIZE
   635  
   636  	tmp := Dm_build_1220.Dm_build_1371(val, offset, int(l))
   637  	offset += int(l)
   638  	out.m_offset = offset
   639  
   640  	return newTypeData(newClobOfLocal(Dm_build_1220.Dm_build_1377(tmp, 0, len(tmp), serverEncoding, desc.m_conn), desc.m_conn), tmp), nil
   641  }
   642  
   643  func (sv TypeData) bytesToTypeData(val []byte, out *TypeData, desc *TypeDescriptor) (*TypeData, error) {
   644  	offset := out.m_offset
   645  
   646  	offset += 1
   647  
   648  	null_flag := Dm_build_1220.Dm_build_1313(val, offset)
   649  	offset += 1
   650  
   651  	out.m_offset = offset
   652  
   653  	if desc.getDType() == BOOLEAN {
   654  		b := false
   655  		if null_flag != byte(0) {
   656  			b = true
   657  		}
   658  
   659  		tmp := Dm_build_1220.Dm_build_1371(val, offset-1, 1)
   660  		return newTypeData(b, tmp), nil
   661  	}
   662  
   663  	var retObj interface{}
   664  	var err error
   665  	var retDataBuf []byte
   666  	switch desc.getDType() {
   667  	case CLASS:
   668  		if null_flag&byte(1) != byte(0) {
   669  			retObj, err = sv.bytesToObj(val, out, desc)
   670  			if err != nil {
   671  				return nil, err
   672  			}
   673  
   674  			if out.m_offset > offset {
   675  				retDataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   676  			}
   677  
   678  			return newTypeData(retObj, retDataBuf), nil
   679  		} else {
   680  			return newTypeData(nil, nil), nil
   681  		}
   682  
   683  	case ARRAY:
   684  		if (null_flag & byte(1)) != byte(0) {
   685  			retObj, err = sv.bytesToArray(val, out, desc)
   686  			if err != nil {
   687  				return nil, err
   688  			}
   689  
   690  			if out.m_offset > offset {
   691  				retDataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   692  			}
   693  
   694  			return newTypeData(retObj, retDataBuf), nil
   695  		} else {
   696  			return newTypeData(nil, nil), nil
   697  		}
   698  
   699  	case PLTYPE_RECORD:
   700  		if (null_flag & byte(1)) != byte(0) {
   701  			retObj, err = sv.bytesToRecord(val, out, desc)
   702  			if err != nil {
   703  				return nil, err
   704  			}
   705  
   706  			if out.m_offset > offset {
   707  				retDataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   708  			}
   709  
   710  			return newTypeData(retObj, retDataBuf), nil
   711  		} else {
   712  			return newTypeData(nil, nil), nil
   713  		}
   714  
   715  	case SARRAY:
   716  		if (null_flag & byte(1)) != byte(0) {
   717  			retObj, err = sv.bytesToSArray(val, out, desc)
   718  			if err != nil {
   719  				return nil, err
   720  			}
   721  
   722  			if out.m_offset > offset {
   723  				retDataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   724  			}
   725  
   726  			return newTypeData(retObj, retDataBuf), nil
   727  		} else {
   728  			return newTypeData(nil, nil), nil
   729  		}
   730  
   731  	case BLOB:
   732  		if null_flag&byte(1) != byte(0) {
   733  			return sv.bytesToBlob(val, out, desc)
   734  		} else {
   735  			return newTypeData(nil, nil), nil
   736  		}
   737  
   738  	case CLOB:
   739  		if null_flag&byte(1) != byte(0) {
   740  			return sv.bytesToClob(val, out, desc, desc.getServerEncoding())
   741  		} else {
   742  			return newTypeData(nil, nil), nil
   743  		}
   744  
   745  	default:
   746  		if null_flag&byte(1) != byte(0) {
   747  			return sv.convertBytes2BaseData(val, out, desc)
   748  		} else {
   749  			return newTypeData(nil, nil), nil
   750  		}
   751  
   752  	}
   753  }
   754  
   755  func (sv TypeData) checkObjExist(val []byte, out *TypeData) bool {
   756  	offset := out.m_offset
   757  	exist_flag := Dm_build_1220.Dm_build_1313(val, offset)
   758  	offset += 1
   759  
   760  	out.m_offset = offset
   761  
   762  	if exist_flag == byte(1) {
   763  		return true
   764  	}
   765  
   766  	out.m_offset += ULINT_SIZE
   767  	return false
   768  }
   769  
   770  func (sv TypeData) findObjByPackId(val []byte, out *TypeData) (*DmStruct, error) {
   771  	offset := out.m_offset
   772  
   773  	pack_id := int(Dm_build_1220.Dm_build_1322(val, offset))
   774  	offset += ULINT_SIZE
   775  
   776  	out.m_offset = offset
   777  
   778  	if pack_id < 0 || pack_id > out.m_packid {
   779  		return nil, ECGO_DATA_CONVERTION_ERROR.throw()
   780  	}
   781  
   782  	return out.m_objRefArr[pack_id].(*DmStruct), nil
   783  }
   784  
   785  func (sv TypeData) addObjToRefArr(out *TypeData, objToAdd interface{}) {
   786  	out.m_objRefArr = append(out.m_objRefArr, objToAdd)
   787  	out.m_packid++
   788  }
   789  
   790  func (sv TypeData) checkObjClnt(desc *TypeDescriptor) bool {
   791  	return desc.m_objId == 4
   792  }
   793  
   794  func (sv TypeData) bytesToObj_EXACT(val []byte, out *TypeData, desc *TypeDescriptor) (*DmStruct, error) {
   795  	strOut := newDmStructByTypeData(nil, desc)
   796  	var sub_desc *TypeDescriptor
   797  	offset := out.m_offset
   798  
   799  	size := desc.getStrctMemSize()
   800  
   801  	out.m_offset = offset
   802  
   803  	strOut.m_attribs = make([]TypeData, size)
   804  	for i := 0; i < size; i++ {
   805  		sub_desc = &desc.m_fieldsObj[i]
   806  		tmp, err := sv.bytesToTypeData(val, out, sub_desc)
   807  		if err != nil {
   808  			return nil, err
   809  		}
   810  		strOut.m_attribs[i] = *tmp
   811  	}
   812  
   813  	strOut.m_dataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   814  
   815  	return strOut, nil
   816  }
   817  
   818  func (sv TypeData) bytesToNestTab(val []byte, out *TypeData, desc *TypeDescriptor) (*DmArray, error) {
   819  	offset := out.m_offset
   820  
   821  	offset += USINT_SIZE
   822  
   823  	count := Dm_build_1220.Dm_build_1322(val, offset)
   824  	offset += ULINT_SIZE
   825  
   826  	out.m_offset = offset
   827  
   828  	arrOut := newDmArrayByTypeData(nil, desc)
   829  	arrOut.m_itemCount = int(count)
   830  	arrOut.m_arrData = make([]TypeData, count)
   831  	for i := 0; i < int(count); i++ {
   832  		tmp, err := sv.bytesToTypeData(val, out, desc.m_arrObj)
   833  		if err != nil {
   834  			return nil, err
   835  		}
   836  		arrOut.m_arrData[i] = *tmp
   837  	}
   838  
   839  	arrOut.m_dataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   840  
   841  	return arrOut, nil
   842  }
   843  
   844  func (sv TypeData) bytesToClnt(val []byte, out *TypeData, desc *TypeDescriptor) (*DmArray, error) {
   845  	var array *DmArray
   846  
   847  	offset := out.m_offset
   848  
   849  	cltn_type := Dm_build_1220.Dm_build_1317(val, offset)
   850  	offset += USINT_SIZE
   851  
   852  	out.m_offset = offset
   853  	switch cltn_type {
   854  	case CLTN_TYPE_IND_TABLE:
   855  		return nil, ECGO_UNSUPPORTED_TYPE.throw()
   856  
   857  	case CLTN_TYPE_NST_TABLE, CLTN_TYPE_VARRAY:
   858  		return sv.bytesToNestTab(val, out, desc)
   859  	}
   860  
   861  	return array, nil
   862  }
   863  
   864  func (sv TypeData) bytesToObj(val []byte, out *TypeData, desc *TypeDescriptor) (interface{}, error) {
   865  	var retObj interface{}
   866  	var err error
   867  	if out == nil {
   868  		out = newTypeData(nil, nil)
   869  	}
   870  
   871  	if sv.checkObjExist(val, out) {
   872  		retObj, err = sv.findObjByPackId(val, out)
   873  		if err != nil {
   874  			return nil, err
   875  		}
   876  	} else {
   877  		sv.addObjToRefArr(out, retObj)
   878  	}
   879  
   880  	if sv.checkObjClnt(desc) {
   881  		retObj, err = sv.bytesToClnt(val, out, desc)
   882  		if err != nil {
   883  			return nil, err
   884  		}
   885  	} else {
   886  		retObj, err = sv.bytesToObj_EXACT(val, out, desc)
   887  		if err != nil {
   888  			return nil, err
   889  		}
   890  	}
   891  
   892  	return retObj, nil
   893  }
   894  
   895  func (sv TypeData) bytesToArray(val []byte, out *TypeData, desc *TypeDescriptor) (*DmArray, error) {
   896  	arrOut := newDmArrayByTypeData(nil, desc)
   897  	if out == nil {
   898  		out = newTypeData(nil, nil)
   899  	}
   900  
   901  	offset := out.m_offset
   902  
   903  	arrOut.m_bufLen = int(Dm_build_1220.Dm_build_1322(val, offset))
   904  	offset += 4
   905  
   906  	arrOut.m_itemCount = int(Dm_build_1220.Dm_build_1322(val, offset))
   907  	offset += ULINT_SIZE
   908  
   909  	arrOut.m_itemSize = int(Dm_build_1220.Dm_build_1322(val, offset))
   910  	offset += ULINT_SIZE
   911  
   912  	arrOut.m_objCount = int(Dm_build_1220.Dm_build_1322(val, offset))
   913  	offset += ULINT_SIZE
   914  
   915  	arrOut.m_strCount = int(Dm_build_1220.Dm_build_1322(val, offset))
   916  	offset += ULINT_SIZE
   917  
   918  	total := arrOut.m_objCount + arrOut.m_strCount
   919  	arrOut.m_objStrOffs = make([]int, total)
   920  	for i := 0; i < total; i++ {
   921  		arrOut.m_objStrOffs[i] = int(Dm_build_1220.Dm_build_1322(val, offset))
   922  		offset += 4
   923  	}
   924  
   925  	out.m_offset = offset
   926  
   927  	arrOut.m_arrData = make([]TypeData, arrOut.m_itemCount)
   928  	for i := 0; i < arrOut.m_itemCount; i++ {
   929  		tmp, err := sv.bytesToTypeData(val, out, desc.m_arrObj)
   930  		if err != nil {
   931  			return nil, err
   932  		}
   933  		arrOut.m_arrData[i] = *tmp
   934  	}
   935  
   936  	arrOut.m_dataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   937  
   938  	return arrOut, nil
   939  }
   940  
   941  func (sv TypeData) bytesToSArray(val []byte, out *TypeData, desc *TypeDescriptor) (*DmArray, error) {
   942  	if out == nil {
   943  		out = newTypeData(nil, nil)
   944  	}
   945  
   946  	offset := out.m_offset
   947  
   948  	arrOut := newDmArrayByTypeData(nil, desc)
   949  	arrOut.m_bufLen = int(Dm_build_1220.Dm_build_1322(val, offset))
   950  	offset += ULINT_SIZE
   951  
   952  	arrOut.m_itemCount = int(Dm_build_1220.Dm_build_1322(val, offset))
   953  	offset += ULINT_SIZE
   954  
   955  	out.m_offset = offset
   956  
   957  	arrOut.m_arrData = make([]TypeData, arrOut.m_itemCount)
   958  	for i := 0; i < arrOut.m_itemCount; i++ {
   959  		tmp, err := sv.bytesToTypeData(val, out, desc.m_arrObj)
   960  		if err != nil {
   961  			return nil, err
   962  		}
   963  		arrOut.m_arrData[i] = *tmp
   964  	}
   965  
   966  	arrOut.m_dataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   967  
   968  	return arrOut, nil
   969  }
   970  
   971  func (sv TypeData) bytesToRecord(val []byte, out *TypeData, desc *TypeDescriptor) (*DmStruct, error) {
   972  	if out == nil {
   973  		out = newTypeData(nil, nil)
   974  	}
   975  
   976  	offset := out.m_offset
   977  
   978  	strOut := newDmStructByTypeData(nil, desc)
   979  	strOut.m_bufLen = int(Dm_build_1220.Dm_build_1322(val, offset))
   980  	offset += ULINT_SIZE
   981  
   982  	out.m_offset = offset
   983  
   984  	strOut.m_attribs = make([]TypeData, desc.getStrctMemSize())
   985  	for i := 0; i < desc.getStrctMemSize(); i++ {
   986  		tmp, err := sv.bytesToTypeData(val, out, desc.m_arrObj)
   987  		if err != nil {
   988  			return nil, err
   989  		}
   990  		strOut.m_attribs[i] = *tmp
   991  	}
   992  
   993  	strOut.m_dataBuf = Dm_build_1220.Dm_build_1371(val, offset, out.m_offset-offset)
   994  
   995  	return strOut, nil
   996  }
   997  
   998  func (sv TypeData) objBlob_GetChkBuf(buf []byte, typeData *TypeData) {
   999  
  1000  	offset := 4
  1001  
  1002  	l := int(Dm_build_1220.Dm_build_1322(buf, offset))
  1003  	offset += ULINT_SIZE
  1004  
  1005  	typeData.m_objBlobDescBuf = Dm_build_1220.Dm_build_1371(buf, offset, l)
  1006  	offset += l
  1007  
  1008  	typeData.m_isFromBlob = true
  1009  
  1010  	typeData.m_offset = offset
  1011  }
  1012  
  1013  func (sv TypeData) objBlobToObj(lob *DmBlob, desc *TypeDescriptor) (interface{}, error) {
  1014  	typeData := newTypeData(nil, nil)
  1015  	loblen, err := lob.GetLength()
  1016  	if err != nil {
  1017  		return nil, err
  1018  	}
  1019  
  1020  	buf, err := lob.getBytes(1, int32(loblen))
  1021  	if err != nil {
  1022  		return nil, err
  1023  	}
  1024  
  1025  	sv.objBlob_GetChkBuf(buf, typeData)
  1026  
  1027  	return sv.bytesToObj(buf, typeData, desc)
  1028  }
  1029  
  1030  func (sv TypeData) objBlobToBytes(lobBuf []byte, desc *TypeDescriptor) ([]byte, error) {
  1031  	l := len(lobBuf)
  1032  	offset := 0
  1033  
  1034  	magic := Dm_build_1220.Dm_build_1322(lobBuf, offset)
  1035  	offset += ULINT_SIZE
  1036  
  1037  	if OBJ_BLOB_MAGIC != magic {
  1038  		return nil, ECGO_INVALID_OBJ_BLOB.throw()
  1039  	}
  1040  
  1041  	descLen := int(Dm_build_1220.Dm_build_1322(lobBuf, offset))
  1042  	offset += ULINT_SIZE
  1043  	descBuf := Dm_build_1220.Dm_build_1371(lobBuf, offset, descLen)
  1044  	tmp, err := desc.getClassDescChkInfo()
  1045  	if err != nil {
  1046  		return nil, err
  1047  	}
  1048  	if !util.SliceEquals(descBuf, tmp) {
  1049  		return nil, ECGO_INVALID_OBJ_BLOB.throw()
  1050  	}
  1051  	offset += descLen
  1052  
  1053  	ret := make([]byte, l-offset)
  1054  	copy(ret[:len(ret)], lobBuf[offset:offset+len(ret)])
  1055  	return ret, nil
  1056  }
  1057  
  1058  func (sv TypeData) realocBuffer(oldBuf []byte, offset int, needLen int) []byte {
  1059  	var retBuf []byte
  1060  
  1061  	if oldBuf == nil {
  1062  		return make([]byte, needLen)
  1063  	} else if needLen+offset > len(oldBuf) {
  1064  		retBuf = make([]byte, len(oldBuf)+needLen)
  1065  		copy(retBuf[:offset], oldBuf[:offset])
  1066  	} else {
  1067  		retBuf = oldBuf
  1068  	}
  1069  
  1070  	return retBuf
  1071  }
  1072  
  1073  func (sv TypeData) convertBytes2BaseData(val []byte, out *TypeData, desc *TypeDescriptor) (*TypeData, error) {
  1074  	offset := out.m_offset
  1075  	isNull := false
  1076  	valueLen := int(Dm_build_1220.Dm_build_1344(val, offset))
  1077  	offset += USINT_SIZE
  1078  
  1079  	if valueLen == int(Dm_build_650) {
  1080  		valueLen = 0
  1081  		isNull = true
  1082  	}
  1083  
  1084  	if -1 == valueLen {
  1085  		valueLen = int(Dm_build_1220.Dm_build_1322(val, offset))
  1086  		offset += ULINT_SIZE
  1087  	}
  1088  
  1089  	if isNull {
  1090  		out.m_offset = offset
  1091  		return newTypeData(nil, nil), nil
  1092  	}
  1093  
  1094  	var tmpObj interface{}
  1095  	var err error
  1096  	temp := Dm_build_1220.Dm_build_1371(val, offset, valueLen)
  1097  	offset += valueLen
  1098  	out.m_offset = offset
  1099  
  1100  	tmpObj, err = DB2G.toObject(temp, desc.column, desc.m_conn)
  1101  	if err != nil {
  1102  		return nil, err
  1103  	}
  1104  	return newTypeData(tmpObj, temp), nil
  1105  }
  1106  
  1107  func (td *TypeData) toJavaArray(arr *DmArray, index int64, l int, dType int) (interface{}, error) {
  1108  	if arr.m_objArray != nil {
  1109  		return arr.m_objArray, nil
  1110  	}
  1111  
  1112  	var nr = make([]interface{}, l)
  1113  	var tempData *TypeData
  1114  	switch dType {
  1115  	case CHAR, VARCHAR, VARCHAR2:
  1116  		for i := 0; i < l; i++ {
  1117  			tempData = &arr.m_arrData[index+int64(i)]
  1118  			if tempData != nil && tempData.m_dumyData != nil {
  1119  				nr[i] = tempData.m_dumyData
  1120  			}
  1121  		}
  1122  	case BIT, TINYINT:
  1123  		for i := 0; i < l; i++ {
  1124  			tempData = &arr.m_arrData[index+int64(i)]
  1125  			if tempData != nil && tempData.m_dumyData != nil {
  1126  				nr[i] = tempData.m_dumyData
  1127  			} else {
  1128  				nr[i] = nil
  1129  			}
  1130  		}
  1131  
  1132  	case BINARY, VARBINARY:
  1133  		for i := 0; i < l; i++ {
  1134  			tempData = &arr.m_arrData[index+int64(i)]
  1135  			if tempData != nil && tempData.m_dumyData != nil {
  1136  				nr[i] = tempData.m_dumyData
  1137  			}
  1138  		}
  1139  
  1140  	case BOOLEAN:
  1141  		for i := 0; i < l; i++ {
  1142  			tempData = &arr.m_arrData[index+int64(i)]
  1143  			if tempData != nil && tempData.m_dumyData != nil {
  1144  				nr[i] = tempData.m_dumyData
  1145  			} else {
  1146  				nr[i] = nil
  1147  			}
  1148  		}
  1149  
  1150  	case SMALLINT:
  1151  		for i := 0; i < l; i++ {
  1152  			tempData = &arr.m_arrData[index+int64(i)]
  1153  			if tempData != nil && tempData.m_dumyData != nil {
  1154  				nr[i] = tempData.m_dumyData
  1155  			} else {
  1156  				nr[i] = nil
  1157  			}
  1158  		}
  1159  
  1160  	case INT:
  1161  		for i := 0; i < l; i++ {
  1162  			tempData = &arr.m_arrData[index+int64(i)]
  1163  			if tempData != nil && tempData.m_dumyData != nil {
  1164  				nr[i] = tempData.m_dumyData
  1165  			} else {
  1166  				nr[i] = nil
  1167  			}
  1168  		}
  1169  
  1170  	case BIGINT:
  1171  		for i := 0; i < l; i++ {
  1172  			tempData = &arr.m_arrData[index+int64(i)]
  1173  			if tempData != nil && tempData.m_dumyData != nil {
  1174  				nr[i] = tempData.m_dumyData
  1175  			} else {
  1176  				nr[i] = nil
  1177  			}
  1178  		}
  1179  
  1180  	case DECIMAL:
  1181  
  1182  		for i := 0; i < l; i++ {
  1183  			tempData = &arr.m_arrData[index+int64(i)]
  1184  			if tempData != nil && tempData.m_dumyData != nil {
  1185  				nr[i] = tempData.m_dumyData
  1186  			}
  1187  		}
  1188  	case REAL:
  1189  		for i := 0; i < l; i++ {
  1190  			tempData = &arr.m_arrData[index+int64(i)]
  1191  			if tempData != nil && tempData.m_dumyData != nil {
  1192  				nr[i] = tempData.m_dumyData
  1193  			} else {
  1194  				nr[i] = nil
  1195  			}
  1196  		}
  1197  
  1198  	case DOUBLE:
  1199  		for i := 0; i < l; i++ {
  1200  			tempData = &arr.m_arrData[index+int64(i)]
  1201  			if tempData != nil && tempData.m_dumyData != nil {
  1202  				nr[i] = tempData.m_dumyData
  1203  			} else {
  1204  				nr[i] = nil
  1205  			}
  1206  		}
  1207  
  1208  	case DATE, TIME, DATETIME, TIME_TZ, DATETIME_TZ:
  1209  		for i := 0; i < l; i++ {
  1210  			tempData = &arr.m_arrData[index+int64(i)]
  1211  			if tempData != nil && tempData.m_dumyData != nil {
  1212  				nr[i] = tempData.m_dumyData
  1213  			}
  1214  		}
  1215  
  1216  	case INTERVAL_YM:
  1217  		for i := 0; i < l; i++ {
  1218  			tempData = &arr.m_arrData[index+int64(i)]
  1219  			if tempData != nil && tempData.m_dumyData != nil {
  1220  				nr[i] = tempData.m_dumyData
  1221  			}
  1222  		}
  1223  
  1224  	case INTERVAL_DT:
  1225  		for i := 0; i < l; i++ {
  1226  			tempData = &arr.m_arrData[index+int64(i)]
  1227  			if tempData != nil && tempData.m_dumyData != nil {
  1228  				nr[i] = tempData.m_dumyData
  1229  			}
  1230  		}
  1231  
  1232  	case PLTYPE_RECORD, CLASS, ARRAY, SARRAY:
  1233  		for i := 0; i < l; i++ {
  1234  			tempData = &arr.m_arrData[index+int64(i)]
  1235  			if tempData != nil {
  1236  				nr[i] = tempData.m_dumyData
  1237  			}
  1238  		}
  1239  
  1240  	case BLOB:
  1241  		for i := 0; i < l; i++ {
  1242  			tempData = &arr.m_arrData[index+int64(i)]
  1243  			if tempData != nil && tempData.m_dumyData != nil {
  1244  				nr[i] = tempData.m_dumyData
  1245  			}
  1246  		}
  1247  
  1248  	case CLOB:
  1249  		for i := 0; i < l; i++ {
  1250  			tempData = &arr.m_arrData[index+int64(i)]
  1251  			if tempData != nil && tempData.m_dumyData != nil {
  1252  				nr[i] = tempData.m_dumyData
  1253  			}
  1254  		}
  1255  
  1256  	default:
  1257  		return nil, ECGO_UNSUPPORTED_TYPE.throw()
  1258  	}
  1259  
  1260  	return nr, nil
  1261  }
  1262  
  1263  func (td *TypeData) toNumericArray(arr *DmArray, index int64, l int, flag int) (interface{}, error) {
  1264  	if nil == arr.m_objArray {
  1265  		return nil, nil
  1266  	}
  1267  
  1268  	var retObj interface{}
  1269  	switch arr.m_objArray.(type) {
  1270  	case []int16:
  1271  		if flag == ARRAY_TYPE_SHORT {
  1272  			ret := make([]int16, l)
  1273  			copy(ret[:l], arr.m_objArray.([]int16)[index:index+int64(l)])
  1274  			retObj = ret
  1275  		}
  1276  	case []int:
  1277  		if flag == ARRAY_TYPE_INTEGER {
  1278  			ret := make([]int, l)
  1279  			copy(ret[:l], arr.m_objArray.([]int)[index:index+int64(l)])
  1280  			retObj = ret
  1281  		}
  1282  	case []int64:
  1283  		if flag == ARRAY_TYPE_LONG {
  1284  			ret := make([]int64, l)
  1285  			copy(ret[:l], arr.m_objArray.([]int64)[index:index+int64(l)])
  1286  			retObj = ret
  1287  		}
  1288  	case []float32:
  1289  		if flag == ARRAY_TYPE_FLOAT {
  1290  			ret := make([]float32, l)
  1291  			copy(ret[:l], arr.m_objArray.([]float32)[index:index+int64(l)])
  1292  			retObj = ret
  1293  		}
  1294  	case []float64:
  1295  		if flag == ARRAY_TYPE_DOUBLE {
  1296  			ret := make([]float64, l)
  1297  			copy(ret[:l], arr.m_objArray.([]float64)[index:index+int64(l)])
  1298  			retObj = ret
  1299  		}
  1300  	default:
  1301  		return nil, ECGO_DATA_CONVERTION_ERROR.throw()
  1302  	}
  1303  
  1304  	return retObj, nil
  1305  }
  1306  
  1307  func (td *TypeData) toJavaArrayByDmStruct(st *DmStruct) ([]interface{}, error) {
  1308  	attrsData := st.getAttribsTypeData()
  1309  	if nil == st.getAttribsTypeData() || len(st.getAttribsTypeData()) <= 0 {
  1310  		return nil, nil
  1311  	}
  1312  
  1313  	fields := st.m_strctDesc.getItemsDesc()
  1314  	if len(attrsData) != len(fields) {
  1315  		return nil, ECGO_STRUCT_MEM_NOT_MATCH.throw()
  1316  	}
  1317  
  1318  	out := make([]interface{}, len(fields))
  1319  	for i := 0; i < len(fields); i++ {
  1320  		out[i] = attrsData[i].m_dumyData
  1321  	}
  1322  
  1323  	return out, nil
  1324  }
  1325  
  1326  func (td *TypeData) toBytesFromDmArray(x *DmArray, typeDesc *TypeDescriptor) ([]byte, error) {
  1327  	var err error
  1328  	desc, err := typeDesc.getClassDescChkInfo()
  1329  	if err != nil {
  1330  		return nil, err
  1331  	}
  1332  	var data []byte
  1333  	switch typeDesc.getDType() {
  1334  	case ARRAY:
  1335  		data, err = TypeDataSV.arrayToBytes(x, typeDesc)
  1336  		if err != nil {
  1337  			return nil, err
  1338  		}
  1339  	case SARRAY:
  1340  		data, err = TypeDataSV.sarrayToBytes(x, typeDesc)
  1341  		if err != nil {
  1342  			return nil, err
  1343  		}
  1344  	case PLTYPE_RECORD:
  1345  		return nil, ECGO_DATA_CONVERTION_ERROR.throw()
  1346  	case CLASS:
  1347  		data, err = TypeDataSV.objToBytes(x, typeDesc)
  1348  		if err != nil {
  1349  			return nil, err
  1350  		}
  1351  	}
  1352  	ret := make([]byte, ULINT_SIZE+ULINT_SIZE+len(desc)+len(data))
  1353  	Dm_build_1220.Dm_build_1236(ret, 0, OBJ_BLOB_MAGIC)
  1354  	Dm_build_1220.Dm_build_1236(ret, ULINT_SIZE, int32(len(desc)))
  1355  	copy(ret[ULINT_SIZE+ULINT_SIZE:ULINT_SIZE+ULINT_SIZE+len(desc)], desc[:len(desc)])
  1356  	copy(ret[ULINT_SIZE+ULINT_SIZE:ULINT_SIZE+ULINT_SIZE+len(desc)+len(data)], desc[:len(data)])
  1357  	return ret, nil
  1358  }
  1359  
  1360  func (td *TypeData) toBytesFromDmStruct(x *DmStruct, typeDesc *TypeDescriptor) ([]byte, error) {
  1361  	var err error
  1362  	desc, err := typeDesc.getClassDescChkInfo()
  1363  	if err != nil {
  1364  		return nil, err
  1365  	}
  1366  	var data []byte
  1367  	switch typeDesc.getDType() {
  1368  	case ARRAY:
  1369  		return nil, ECGO_DATA_CONVERTION_ERROR.throw()
  1370  	case SARRAY:
  1371  		return nil, ECGO_DATA_CONVERTION_ERROR.throw()
  1372  	case PLTYPE_RECORD:
  1373  		data, err = TypeDataSV.recordToBytes(x, typeDesc)
  1374  		if err != nil {
  1375  			return nil, err
  1376  		}
  1377  	case CLASS:
  1378  		data, err = TypeDataSV.objToBytes(x, typeDesc)
  1379  		if err != nil {
  1380  			return nil, err
  1381  		}
  1382  	}
  1383  	ret := make([]byte, ULINT_SIZE+ULINT_SIZE+len(desc)+len(data))
  1384  	Dm_build_1220.Dm_build_1236(ret, 0, OBJ_BLOB_MAGIC)
  1385  	Dm_build_1220.Dm_build_1236(ret, ULINT_SIZE, int32(len(desc)))
  1386  	copy(ret[ULINT_SIZE+ULINT_SIZE:ULINT_SIZE+ULINT_SIZE+len(desc)], desc[:len(desc)])
  1387  	copy(ret[ULINT_SIZE+ULINT_SIZE:ULINT_SIZE+ULINT_SIZE+len(desc)+len(data)], desc[:len(data)])
  1388  	return ret, nil
  1389  }