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 }