github.com/xiyichan/dm8@v0.0.0-20211213021639-be727be3e136/zh.go (about) 1 /* 2 * Copyright (c) 2000-2018, 达梦数据库有限公司. 3 * All rights reserved. 4 */ 5 package dm 6 7 import ( 8 "bytes" 9 "github.com/xiyichan/dm8/util" 10 "io" 11 "math/big" 12 "strconv" 13 "strings" 14 "time" 15 ) 16 17 var G2DB g2db 18 19 type g2db struct { 20 } 21 22 func (G2DB g2db) checkTinyint(val interface{}) error { 23 switch v := val.(type) { 24 case float64: 25 if v < float64(INT8_MIN) || v > float64(INT8_MAX) { 26 return ECGO_DATA_OVERFLOW.throw() 27 } 28 case DmDecimal: 29 if v.ToBigInt().Cmp(big.NewInt(int64(INT8_MIN))) < 0 || 30 v.ToBigInt().Cmp(big.NewInt(int64(INT8_MAX))) > 0 { 31 return ECGO_DATA_OVERFLOW.throw() 32 } 33 } 34 return nil 35 } 36 37 func (G2DB g2db) checkSmallint(val interface{}) error { 38 switch v := val.(type) { 39 case float64: 40 if v < float64(INT16_MIN) || v > float64(INT16_MAX) { 41 return ECGO_DATA_OVERFLOW.throw() 42 } 43 case DmDecimal: 44 if v.ToBigInt().Cmp(big.NewInt(int64(INT16_MIN))) < 0 || 45 v.ToBigInt().Cmp(big.NewInt(int64(INT16_MAX))) > 0 { 46 return ECGO_DATA_OVERFLOW.throw() 47 } 48 } 49 return nil 50 } 51 52 func (G2DB g2db) checkInt(val interface{}) error { 53 switch v := val.(type) { 54 case float64: 55 if v < float64(INT32_MIN) || v > float64(INT32_MAX) { 56 return ECGO_DATA_OVERFLOW.throw() 57 } 58 case DmDecimal: 59 if v.ToBigInt().Cmp(big.NewInt(int64(INT32_MIN))) < 0 || 60 v.ToBigInt().Cmp(big.NewInt(int64(INT32_MAX))) > 0 { 61 return ECGO_DATA_OVERFLOW.throw() 62 } 63 } 64 return nil 65 } 66 67 func (G2DB g2db) checkBigint(val interface{}) error { 68 switch v := val.(type) { 69 case float64: 70 if v < float64(INT64_MIN) || v > float64(INT64_MAX) { 71 return ECGO_DATA_OVERFLOW.throw() 72 } 73 case DmDecimal: 74 if v.ToBigInt().Cmp(big.NewInt(INT64_MIN)) < 0 || 75 v.ToBigInt().Cmp(big.NewInt(INT64_MAX)) > 0 { 76 return ECGO_DATA_OVERFLOW.throw() 77 } 78 } 79 return nil 80 } 81 82 func (G2DB g2db) checkReal(val interface{}) error { 83 switch v := val.(type) { 84 case float64: 85 if v < float64(FLOAT32_MIN) || v > float64(FLOAT32_MAX) { 86 return ECGO_DATA_OVERFLOW.throw() 87 } 88 case DmDecimal: 89 if v.ToBigFloat().Cmp(big.NewFloat(float64(FLOAT32_MIN))) < 0 || 90 v.ToBigFloat().Cmp(big.NewFloat(float64(FLOAT32_MAX))) > 0 { 91 return ECGO_DATA_OVERFLOW.throw() 92 } 93 } 94 return nil 95 } 96 97 func (G2DB g2db) fromBool(val bool, param parameter, conn *DmConnection) ([]byte, error) { 98 switch param.colType { 99 case BOOLEAN, BIT, TINYINT, SMALLINT, INT, BIGINT, REAL, DOUBLE, DECIMAL, CHAR, 100 VARCHAR2, VARCHAR, CLOB: 101 if val { 102 return G2DB.fromInt64(1, param, conn) 103 } else { 104 return G2DB.fromInt64(0, param, conn) 105 } 106 case BINARY, VARBINARY, BLOB: 107 if val { 108 return Dm_build_599.Dm_build_774(byte(1)), nil 109 } else { 110 return Dm_build_599.Dm_build_774(byte(0)), nil 111 } 112 } 113 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 114 } 115 116 func (G2DB g2db) fromInt64(val int64, param parameter, conn *DmConnection) ([]byte, error) { 117 118 switch param.colType { 119 case BOOLEAN, BIT: 120 if val == 0 { 121 return Dm_build_599.Dm_build_774(byte(0)), nil 122 } 123 124 return Dm_build_599.Dm_build_774(byte(1)), nil 125 126 case TINYINT: 127 err := G2DB.checkTinyint(float64(val)) 128 129 if err != nil { 130 return nil, err 131 } 132 133 return Dm_build_599.Dm_build_774(byte(val)), nil 134 case SMALLINT: 135 err := G2DB.checkSmallint(float64(val)) 136 137 if err != nil { 138 return nil, err 139 } 140 141 return Dm_build_599.Dm_build_777(int16(val)), nil 142 case INT: 143 err := G2DB.checkInt(float64(val)) 144 145 if err != nil { 146 return nil, err 147 } 148 149 return Dm_build_599.Dm_build_780(int32(val)), nil 150 case BIGINT: 151 err := G2DB.checkBigint(float64(val)) 152 153 if err != nil { 154 return nil, err 155 } 156 157 return Dm_build_599.Dm_build_783(int64(val)), nil 158 case REAL: 159 err := G2DB.checkReal(float64(val)) 160 161 if err != nil { 162 return nil, err 163 } 164 165 return Dm_build_599.Dm_build_786(float32(val)), nil 166 case DOUBLE: 167 return Dm_build_599.Dm_build_789(float64(val)), nil 168 case DECIMAL: 169 d, err := newDecimal(big.NewInt(val), int(param.prec), int(param.scale)) 170 if err != nil { 171 return nil, err 172 } 173 return d.encodeDecimal() 174 case CHAR, VARCHAR2, VARCHAR, CLOB: 175 return Dm_build_599.Dm_build_809(strconv.FormatInt(val, 10), conn.getServerEncoding(), conn), nil 176 case BINARY, VARBINARY, BLOB: 177 return G2DB.ToBinary(val, int(param.prec)), nil 178 case DATE, TIME, DATETIME: 179 if err := G2DB.checkInt(float64(val)); err != nil { 180 return nil, err 181 } 182 return encodeByDateNumber(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), conn.DbTimezone) 183 } 184 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 185 } 186 187 func (G2DB g2db) ToBinary(x int64, prec int) []byte { 188 b := make([]byte, 8) 189 b[7] = byte(x) 190 b[6] = byte(x >> 8) 191 b[5] = byte(x >> 16) 192 b[4] = byte(x >> 24) 193 b[3] = byte(x >> 32) 194 b[2] = byte(x >> 40) 195 b[1] = byte(x >> 48) 196 b[0] = byte(x >> 56) 197 198 if prec > 0 && prec < len(b) { 199 dest := make([]byte, prec) 200 copy(dest, b[len(b)-prec:]) 201 return dest 202 } 203 return b 204 } 205 206 func (G2DB g2db) fromFloat32(val float32, param parameter, conn *DmConnection) ([]byte, error) { 207 switch param.colType { 208 case BOOLEAN, BIT: 209 if val == 0.0 { 210 return Dm_build_599.Dm_build_774(0), nil 211 } 212 return Dm_build_599.Dm_build_774(1), nil 213 case TINYINT: 214 if err := G2DB.checkTinyint(float64(val)); err != nil { 215 return nil, err 216 } 217 return Dm_build_599.Dm_build_774(byte(val)), nil 218 case SMALLINT: 219 if err := G2DB.checkSmallint(float64(val)); err != nil { 220 return nil, err 221 } 222 return Dm_build_599.Dm_build_777(int16(val)), nil 223 case INT: 224 if err := G2DB.checkInt(float64(val)); err != nil { 225 return nil, err 226 } 227 return Dm_build_599.Dm_build_780(int32(val)), nil 228 case BIGINT: 229 if err := G2DB.checkBigint(float64(val)); err != nil { 230 return nil, err 231 } 232 return Dm_build_599.Dm_build_783(int64(val)), nil 233 case REAL: 234 if err := G2DB.checkReal(float64(val)); err != nil { 235 return nil, err 236 } 237 return Dm_build_599.Dm_build_786(val), nil 238 case DOUBLE: 239 return Dm_build_599.Dm_build_789(float64(val)), nil 240 case DECIMAL: 241 d, err := newDecimal(big.NewFloat(float64(val)), int(param.prec), int(param.scale)) 242 if err != nil { 243 return nil, err 244 } 245 return d.encodeDecimal() 246 case CHAR, VARCHAR2, VARCHAR, CLOB: 247 return Dm_build_599.Dm_build_809(strconv.FormatFloat(float64(val), 'f', -1, 32), conn.getServerEncoding(), conn), nil 248 } 249 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 250 } 251 252 func (G2DB g2db) fromFloat64(val float64, param parameter, conn *DmConnection) ([]byte, error) { 253 254 switch param.colType { 255 case BOOLEAN, BIT: 256 if val == 0.0 { 257 return Dm_build_599.Dm_build_774(0), nil 258 } 259 return Dm_build_599.Dm_build_774(1), nil 260 261 case TINYINT: 262 err := G2DB.checkTinyint(val) 263 264 if err != nil { 265 return nil, err 266 } 267 268 return Dm_build_599.Dm_build_774(byte(val)), nil 269 case SMALLINT: 270 err := G2DB.checkSmallint(val) 271 272 if err != nil { 273 return nil, err 274 } 275 276 return Dm_build_599.Dm_build_777(int16(val)), nil 277 case INT: 278 err := G2DB.checkInt(val) 279 280 if err != nil { 281 return nil, err 282 } 283 284 return Dm_build_599.Dm_build_780(int32(val)), nil 285 case BIGINT: 286 err := G2DB.checkBigint(val) 287 288 if err != nil { 289 return nil, err 290 } 291 292 return Dm_build_599.Dm_build_783(int64(val)), nil 293 case REAL: 294 err := G2DB.checkReal(val) 295 296 if err != nil { 297 return nil, err 298 } 299 300 return Dm_build_599.Dm_build_786(float32(val)), nil 301 case DOUBLE: 302 return Dm_build_599.Dm_build_789(float64(val)), nil 303 case DECIMAL: 304 d, err := newDecimal(big.NewFloat(val), int(param.prec), int(param.scale)) 305 if err != nil { 306 return nil, err 307 } 308 return d.encodeDecimal() 309 case CHAR, VARCHAR2, VARCHAR, CLOB: 310 return Dm_build_599.Dm_build_809(strconv.FormatFloat(val, 'f', -1, 64), conn.getServerEncoding(), conn), nil 311 } 312 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 313 } 314 315 func (G2DB g2db) fromBytes(val []byte, param parameter, conn *DmConnection) (interface{}, error) { 316 switch param.colType { 317 case CHAR, VARCHAR2, VARCHAR: 318 return G2DB.toVarchar(val) 319 case CLOB: 320 b, err := G2DB.toVarchar(val) 321 if err != nil { 322 return nil, err 323 } 324 return G2DB.changeOffRowData(param, b, conn.getServerEncoding()) 325 case BINARY, VARBINARY: 326 return val, nil 327 case BLOB: 328 return G2DB.bytes2Blob(val, param, conn) 329 case ARRAY, CLASS, PLTYPE_RECORD, SARRAY: 330 if param.typeDescriptor == nil { 331 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 332 } 333 return TypeDataSV.objBlobToBytes(val, param.typeDescriptor) 334 } 335 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 336 } 337 338 func (G2DB g2db) toVarchar(bsArr []byte) ([]byte, error) { 339 if bsArr == nil || len(bsArr) == 0 { 340 return make([]byte, 0), nil 341 } 342 343 realLen := len(bsArr) * 2 344 bsRet := make([]byte, realLen) 345 for i := 0; i < len(bsArr); i++ { 346 bsTemp, err := G2DB.toChar(bsArr[i]) 347 if err != nil { 348 return nil, err 349 } 350 351 bsRet[i*2] = bsTemp[0] 352 bsRet[i*2+1] = bsTemp[1] 353 } 354 355 return bsRet, nil 356 } 357 358 func (G2DB g2db) toChar(bt byte) ([]byte, error) { 359 bytes := make([]byte, 2) 360 var err error 361 362 bytes[0], err = G2DB.getCharByNumVal((bt >> 4) & 0x0F) 363 if err != nil { 364 return nil, err 365 } 366 367 bytes[1], err = G2DB.getCharByNumVal(bt & 0x0F) 368 if err != nil { 369 return nil, err 370 } 371 372 return bytes, nil 373 } 374 375 func (G2DB g2db) getCharByNumVal(val byte) (byte, error) { 376 if val >= 0 && val <= 9 { 377 return (byte)(val + '0'), nil 378 } 379 380 if val >= 0x0a && val <= 0x0F { 381 return (byte)(val + 'A' - 0x0a), nil 382 } 383 return 0, ECGO_INVALID_HEX.throw() 384 } 385 386 func (G2DB g2db) fromString(val string, param parameter, conn *DmConnection) (interface{}, error) { 387 switch param.colType { 388 case BOOLEAN, BIT: 389 ret, err := G2DB.toBool(val) 390 if err != nil { 391 return nil, err 392 } 393 394 if ret { 395 return Dm_build_599.Dm_build_774(byte(1)), nil 396 } else { 397 return Dm_build_599.Dm_build_774(byte(0)), nil 398 } 399 400 case TINYINT, SMALLINT, INT, BIGINT: 401 f, ok := new(big.Float).SetString(val) 402 if !ok { 403 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 404 } 405 if f.Sign() < 0 { 406 f.Sub(f, big.NewFloat(0.5)) 407 } else { 408 f.Add(f, big.NewFloat(0.5)) 409 } 410 z, _ := f.Int(nil) 411 return G2DB.fromBigInt(z, param, conn) 412 case REAL, DOUBLE, DECIMAL: 413 f, ok := new(big.Float).SetString(val) 414 if ok { 415 return G2DB.fromBigFloat(f, param, conn) 416 } else { 417 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 418 } 419 420 case CHAR, VARCHAR2, VARCHAR: 421 return Dm_build_599.Dm_build_809(val, conn.getServerEncoding(), conn), nil 422 case CLOB: 423 return G2DB.string2Clob(val, param, conn) 424 case BINARY, VARBINARY: 425 return util.StringUtil.HexStringToBytes(val), nil 426 case BLOB: 427 return G2DB.bytes2Blob(util.StringUtil.HexStringToBytes(val), param, conn) 428 case DATE: 429 if conn.OracleDateFormat != "" { 430 dt, err := parse(val, conn.OracleDateFormat, int(conn.OracleDateLanguage)) 431 if err != nil { 432 return nil, ECGO_INVALID_DATETIME_FORMAT.throw() 433 } 434 435 return encode(dt, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone)) 436 } 437 438 return encodeByString(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 439 case TIME: 440 if conn.OracleTimeFormat != "" { 441 dt, err := parse(val, conn.OracleTimeFormat, int(conn.OracleDateLanguage)) 442 if err != nil { 443 return nil, ECGO_INVALID_DATETIME_FORMAT.throw() 444 } 445 446 return encode(dt, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone)) 447 } 448 449 return encodeByString(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 450 case DATETIME: 451 if conn.OracleTimestampFormat != "" { 452 dt, err := parse(val, conn.OracleTimestampFormat, int(conn.OracleDateLanguage)) 453 if err != nil { 454 return nil, ECGO_INVALID_DATETIME_FORMAT.throw() 455 } 456 457 return encode(dt, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone)) 458 } 459 460 return encodeByString(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 461 case TIME_TZ: 462 dt, err := parse(val, conn.OracleTimeTZFormat, int(conn.OracleDateLanguage)) 463 if err != nil { 464 return nil, ECGO_INVALID_DATETIME_FORMAT.throw() 465 } 466 467 if conn.OracleTimeTZFormat != "" { 468 return encode(dt, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone)) 469 } 470 471 return encodeByString(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 472 case DATETIME_TZ: 473 if conn.OracleTimestampTZFormat != "" { 474 dt, err := parse(val, conn.OracleTimestampTZFormat, int(conn.OracleDateLanguage)) 475 if err != nil { 476 return nil, ECGO_INVALID_DATETIME_FORMAT.throw() 477 } 478 479 return encode(dt, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone)) 480 } 481 482 return encodeByString(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 483 case INTERVAL_DT: 484 dt, err := NewDmIntervalDTByString(val) 485 if err != nil { 486 return nil, err 487 } 488 return dt.encode(int(param.scale)) 489 490 case INTERVAL_YM: 491 ym, err := NewDmIntervalYMByString(val) 492 if err != nil { 493 return nil, err 494 } 495 return ym.encode(int(param.scale)) 496 } 497 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 498 } 499 500 func (G2DB g2db) toBool(str string) (bool, error) { 501 str = strings.TrimSpace(str) 502 if util.StringUtil.Equals(str, "0") { 503 return false, nil 504 } else if util.StringUtil.Equals(str, "1") { 505 return true, nil 506 } 507 508 return strings.ToLower(str) == "true", nil 509 } 510 511 func (G2DB g2db) fromBigInt(val *big.Int, param parameter, conn *DmConnection) ([]byte, error) { 512 var ret []byte 513 switch param.colType { 514 case BOOLEAN, BIT: 515 if val.Sign() == 0 { 516 ret = Dm_build_599.Dm_build_774(0) 517 } else { 518 ret = Dm_build_599.Dm_build_774(1) 519 } 520 case TINYINT: 521 err := G2DB.checkTinyint(float64(val.Int64())) 522 523 if err != nil { 524 return nil, err 525 } 526 527 ret = Dm_build_599.Dm_build_774(byte(val.Int64())) 528 case SMALLINT: 529 err := G2DB.checkSmallint(float64(val.Int64())) 530 531 if err != nil { 532 return nil, err 533 } 534 535 ret = Dm_build_599.Dm_build_777(int16(val.Int64())) 536 case INT: 537 err := G2DB.checkInt(float64(val.Int64())) 538 539 if err != nil { 540 return nil, err 541 } 542 543 ret = Dm_build_599.Dm_build_780(int32(val.Int64())) 544 case BIGINT: 545 err := G2DB.checkBigint(float64(val.Int64())) 546 547 if err != nil { 548 return nil, err 549 } 550 551 ret = Dm_build_599.Dm_build_783(val.Int64()) 552 case REAL: 553 err := G2DB.checkReal(float64(val.Int64())) 554 555 if err != nil { 556 return nil, err 557 } 558 559 ret = Dm_build_599.Dm_build_786(float32(val.Int64())) 560 case DOUBLE: 561 ret = Dm_build_599.Dm_build_789(float64(val.Int64())) 562 case DECIMAL, BINARY, VARBINARY, BLOB: 563 d, err := newDecimal(val, int(param.prec), int(param.scale)) 564 if err != nil { 565 return nil, err 566 } 567 ret, err = d.encodeDecimal() 568 if err != nil { 569 return nil, err 570 } 571 case CHAR, VARCHAR2, VARCHAR, CLOB: 572 ret = Dm_build_599.Dm_build_809(val.String(), conn.getServerEncoding(), conn) 573 default: 574 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 575 } 576 return ret, nil 577 } 578 579 func (G2DB g2db) fromBigFloat(val *big.Float, param parameter, conn *DmConnection) ([]byte, error) { 580 var ret []byte 581 switch param.colType { 582 case BOOLEAN, BIT: 583 if val.Sign() == 0 { 584 ret = Dm_build_599.Dm_build_774(0) 585 } else { 586 ret = Dm_build_599.Dm_build_774(1) 587 } 588 case TINYINT: 589 f, _ := val.Float64() 590 591 err := G2DB.checkTinyint(f) 592 593 if err != nil { 594 return nil, err 595 } 596 597 ret = Dm_build_599.Dm_build_774(byte(f)) 598 case SMALLINT: 599 f, _ := val.Float64() 600 601 err := G2DB.checkSmallint(f) 602 603 if err != nil { 604 return nil, err 605 } 606 607 ret = Dm_build_599.Dm_build_777(int16(f)) 608 case INT: 609 f, _ := val.Float64() 610 611 err := G2DB.checkInt(f) 612 613 if err != nil { 614 return nil, err 615 } 616 617 ret = Dm_build_599.Dm_build_780(int32(f)) 618 case BIGINT: 619 f, _ := val.Float64() 620 621 err := G2DB.checkBigint(f) 622 623 if err != nil { 624 return nil, err 625 } 626 627 ret = Dm_build_599.Dm_build_783(int64(f)) 628 case REAL: 629 f, _ := val.Float64() 630 631 err := G2DB.checkReal(f) 632 633 if err != nil { 634 return nil, err 635 } 636 637 ret = Dm_build_599.Dm_build_786(float32(f)) 638 case DOUBLE: 639 f, _ := val.Float64() 640 ret = Dm_build_599.Dm_build_789(f) 641 case DECIMAL: 642 d, err := newDecimal(val, int(param.prec), int(param.scale)) 643 if err != nil { 644 return nil, err 645 } 646 ret, err = d.encodeDecimal() 647 if err != nil { 648 return nil, err 649 } 650 case CHAR, VARCHAR2, VARCHAR, CLOB: 651 ret = Dm_build_599.Dm_build_809(val.Text('f', int(param.scale)), conn.getServerEncoding(), conn) 652 default: 653 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 654 } 655 return ret, nil 656 } 657 658 func (G2DB g2db) fromDecimal(val DmDecimal, param parameter, conn *DmConnection) ([]byte, error) { 659 var ret []byte 660 switch param.colType { 661 case BOOLEAN, BIT: 662 if val.Sign() == 0 { 663 ret = Dm_build_599.Dm_build_774(0) 664 } else { 665 ret = Dm_build_599.Dm_build_774(1) 666 } 667 case TINYINT: 668 if err := G2DB.checkTinyint(val); err != nil { 669 return nil, err 670 } 671 ret = Dm_build_599.Dm_build_774(byte(val.ToBigInt().Int64())) 672 case SMALLINT: 673 if err := G2DB.checkSmallint(val); err != nil { 674 return nil, err 675 } 676 ret = Dm_build_599.Dm_build_777(int16(val.ToBigInt().Int64())) 677 case INT: 678 if err := G2DB.checkInt(val); err != nil { 679 return nil, err 680 } 681 ret = Dm_build_599.Dm_build_780(int32(val.ToBigInt().Int64())) 682 case BIGINT: 683 if err := G2DB.checkBigint(val); err != nil { 684 return nil, err 685 } 686 ret = Dm_build_599.Dm_build_783(int64(val.ToBigInt().Int64())) 687 case REAL: 688 if err := G2DB.checkReal(val); err != nil { 689 return nil, err 690 } 691 f, _ := val.ToBigFloat().Float32() 692 ret = Dm_build_599.Dm_build_786(f) 693 case DOUBLE: 694 f, _ := val.ToBigFloat().Float64() 695 ret = Dm_build_599.Dm_build_789(f) 696 case DECIMAL: 697 var err error 698 ret, err = val.encodeDecimal() 699 if err != nil { 700 return nil, err 701 } 702 case CHAR, VARCHAR2, VARCHAR, CLOB: 703 ret = Dm_build_599.Dm_build_809(val.ToBigFloat().Text('f', -1), conn.getServerEncoding(), conn) 704 default: 705 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 706 } 707 return ret, nil 708 } 709 710 func (G2DB g2db) fromTime(val time.Time, param parameter, conn *DmConnection) ([]byte, error) { 711 712 switch param.colType { 713 case DATE, DATETIME, DATETIME_TZ, TIME, TIME_TZ: 714 return encodeByTime(val, int(param.colType), int(param.scale), int(conn.dmConnector.localTimezone), int(conn.DbTimezone)) 715 case CHAR, VARCHAR2, VARCHAR, CLOB: 716 return Dm_build_599.Dm_build_809(val.Format("2006-01-02 15:04:05.999999999 -07:00"), conn.getServerEncoding(), conn), nil 717 } 718 719 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 720 } 721 722 func (G2DB g2db) fromDmIntervalDT(val DmIntervalDT, param parameter, conn *DmConnection) ([]byte, error) { 723 switch param.colType { 724 case CHAR, VARCHAR2, VARCHAR, CLOB: 725 return Dm_build_599.Dm_build_809(val.String(), conn.getServerEncoding(), conn), nil 726 case INTERVAL_DT: 727 return val.encode(int(param.scale)) 728 default: 729 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 730 } 731 } 732 733 func (G2DB g2db) fromDmdbIntervalYM(val DmIntervalYM, param parameter, conn *DmConnection) ([]byte, error) { 734 735 switch param.colType { 736 case CHAR, VARCHAR, VARCHAR2, CLOB: 737 return Dm_build_599.Dm_build_809(val.String(), conn.getServerEncoding(), conn), nil 738 case INTERVAL_YM: 739 return val.encode(int(param.scale)) 740 default: 741 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 742 } 743 } 744 745 func (G2DB g2db) fromBlob(val DmBlob, param parameter, conn *DmConnection) (interface{}, error) { 746 var ret interface{} 747 switch param.colType { 748 case BINARY, VARBINARY: 749 len, err := val.GetLength() 750 if err != nil { 751 return nil, err 752 } 753 ret, err = val.getBytes(1, int32(len)) 754 if err != nil { 755 return nil, err 756 } 757 case BLOB: 758 var err error 759 ret, err = G2DB.blob2Blob(val, param, conn) 760 if err != nil { 761 return nil, err 762 } 763 case ARRAY, CLASS, PLTYPE_RECORD, SARRAY: 764 765 default: 766 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 767 } 768 return ret, nil 769 } 770 771 func (G2DB g2db) fromClob(val DmClob, param parameter, conn *DmConnection) (interface{}, error) { 772 var ret interface{} 773 switch param.colType { 774 case CHAR, VARCHAR, VARCHAR2: 775 var len int64 776 var s string 777 var err error 778 len, err = val.GetLength() 779 if err != nil { 780 return nil, err 781 } 782 s, err = val.getSubString(1, int32(len)) 783 if err != nil { 784 return nil, err 785 } 786 ret = []byte(s) 787 case CLOB: 788 var err error 789 ret, err = G2DB.clob2Clob(val, param, conn) 790 if err != nil { 791 return nil, err 792 } 793 default: 794 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 795 } 796 return ret, nil 797 } 798 799 func (G2DB g2db) fromReader(val io.Reader, param parameter, conn *DmConnection) (interface{}, error) { 800 var ret interface{} 801 switch param.colType { 802 case CHAR, VARCHAR2, VARCHAR: 803 var bytesBuf = new(bytes.Buffer) 804 if _, err := bytesBuf.ReadFrom(val); err != nil { 805 return nil, err 806 } 807 return Dm_build_599.Dm_build_809(string(bytesBuf.Bytes()), conn.getServerEncoding(), conn), nil 808 case BINARY, VARBINARY: 809 var bytesBuf = new(bytes.Buffer) 810 if _, err := bytesBuf.ReadFrom(val); err != nil { 811 return nil, err 812 } 813 return util.StringUtil.HexStringToBytes(string(bytesBuf.Bytes())), nil 814 case BLOB, CLOB: 815 var binder = newOffRowReaderBinder(val, conn.getServerEncoding()) 816 if binder.offRow { 817 ret = binder 818 } else { 819 ret = binder.readAll() 820 } 821 default: 822 return nil, ECGO_DATA_CONVERTION_ERROR.throw() 823 } 824 return ret, nil 825 } 826 827 func (G2DB g2db) string2Clob(val string, param parameter, conn *DmConnection) (interface{}, error) { 828 return G2DB.changeOffRowData(param, Dm_build_599.Dm_build_809(val, conn.getServerEncoding(), conn), conn.getServerEncoding()) 829 } 830 831 func (G2DB g2db) bytes2Blob(val []byte, param parameter, conn *DmConnection) (interface{}, error) { 832 return G2DB.changeOffRowData(param, val, conn.getServerEncoding()) 833 } 834 835 func (G2DB g2db) clob2Clob(val DmClob, param parameter, conn *DmConnection) (interface{}, error) { 836 var clobLen int64 837 var err error 838 if clobLen, err = val.GetLength(); err != nil { 839 return nil, err 840 } 841 if G2DB.isOffRow(param.colType, clobLen) { 842 return newOffRowClobBinder(val, conn.getServerEncoding()), nil 843 } else { 844 var length int64 845 var str string 846 if length, err = val.GetLength(); err != nil { 847 return nil, err 848 } 849 if str, err = val.getSubString(1, int32(length)); err != nil { 850 return nil, err 851 } 852 return Dm_build_599.Dm_build_809(str, conn.getServerEncoding(), conn), nil 853 } 854 } 855 856 func (G2DB g2db) blob2Blob(val DmBlob, param parameter, conn *DmConnection) (interface{}, error) { 857 var clobLen int64 858 var err error 859 if clobLen, err = val.GetLength(); err != nil { 860 return nil, err 861 } 862 if G2DB.isOffRow(param.colType, clobLen) { 863 return newOffRowBlobBinder(val, conn.getServerEncoding()), nil 864 } else { 865 var length int64 866 if length, err = val.GetLength(); err != nil { 867 return nil, err 868 } 869 return val.getBytes(1, int32(length)) 870 } 871 } 872 873 func (G2DB g2db) changeOffRowData(paramDesc parameter, paramData []byte, encoding string) (interface{}, error) { 874 if G2DB.isOffRow(paramDesc.colType, int64(len(paramData))) { 875 return newOffRowBytesBinder(paramData, encoding), nil 876 } else { 877 return paramData, nil 878 } 879 } 880 881 func (G2DB g2db) isOffRow(dtype int32, length int64) bool { 882 return (dtype == BLOB || dtype == CLOB) && length > Dm_build_114 883 } 884 885 func (G2DB g2db) fromObject(mem interface{}, param parameter, conn *DmConnection) ([]byte, error) { 886 switch v := mem.(type) { 887 case bool: 888 return G2DB.fromBool(v, param, conn) 889 case rune: 890 val, err := G2DB.fromString(string(v), param, conn) 891 return val.([]byte), err 892 case string: 893 val, err := G2DB.fromString(v, param, conn) 894 return val.([]byte), err 895 case byte: 896 return G2DB.fromInt64(int64(v), param, conn) 897 case int: 898 return G2DB.fromInt64(int64(v), param, conn) 899 case int16: 900 return G2DB.fromInt64(int64(v), param, conn) 901 case int64: 902 return G2DB.fromInt64(v, param, conn) 903 case float32: 904 return G2DB.fromFloat64(float64(v), param, conn) 905 case float64: 906 return G2DB.fromFloat64(v, param, conn) 907 case time.Time: 908 return G2DB.fromTime(v, param, conn) 909 case DmDecimal: 910 return G2DB.fromDecimal(v, param, conn) 911 case DmIntervalDT: 912 return G2DB.fromDmIntervalDT(v, param, conn) 913 case DmIntervalYM: 914 return G2DB.fromDmdbIntervalYM(v, param, conn) 915 case DmBlob: 916 length, _ := v.GetLength() 917 return v.getBytes(1, int32(length)) 918 case DmClob: 919 length, _ := v.GetLength() 920 str, err := v.getSubString(1, int32(length)) 921 if err != nil { 922 return nil, err 923 } 924 return Dm_build_599.Dm_build_809(str, conn.getServerEncoding(), conn), nil 925 default: 926 return nil, ECGO_UNSUPPORTED_TYPE.throw() 927 } 928 929 } 930 931 func (G2DB g2db) toInt32(val int32) []byte { 932 bytes := make([]byte, 4) 933 Dm_build_599.Dm_build_615(bytes, 0, val) 934 return bytes 935 } 936 937 func (G2DB g2db) toInt64(val int64) []byte { 938 bytes := make([]byte, 8) 939 Dm_build_599.Dm_build_620(bytes, 0, val) 940 return bytes 941 } 942 943 func (G2DB g2db) toFloat32(val float32) []byte { 944 bytes := make([]byte, 4) 945 Dm_build_599.Dm_build_625(bytes, 0, val) 946 return bytes 947 } 948 949 func (G2DB g2db) toFloat64(val float64) []byte { 950 bytes := make([]byte, 8) 951 Dm_build_599.Dm_build_630(bytes, 0, val) 952 return bytes 953 } 954 955 func (G2DB g2db) toDecimal(val string, prec int, scale int) ([]byte, error) { 956 d, err := decodeDecimal([]byte(val), prec, scale) 957 if err != nil { 958 return nil, err 959 } 960 return d.encodeDecimal() 961 } 962 963 func (G2DB g2db) fromArray(x *DmArray, param parameter, connection *DmConnection) (interface{}, error) { 964 var ret interface{} 965 var err error 966 switch param.colType { 967 case SARRAY: 968 ret, err = TypeDataSV.sarrayToBytes(x, param.typeDescriptor) 969 case CLASS, ARRAY: 970 ret, err = TypeDataSV.arrayToBytes(x, param.typeDescriptor) 971 case BLOB: 972 ret, err = TypeDataSV.toBytesFromDmArray(x, param.typeDescriptor) 973 if err == nil { 974 ret, err = G2DB.bytes2Blob(ret.([]byte), param, connection) 975 } 976 default: 977 err = ECGO_DATA_CONVERTION_ERROR.throw() 978 } 979 return ret, err 980 } 981 982 func (G2DB g2db) fromStruct(x *DmStruct, param parameter, connection *DmConnection) (interface{}, error) { 983 var ret interface{} 984 var err error 985 switch param.colType { 986 case CLASS: 987 ret, err = TypeDataSV.structToBytes(x, param.typeDescriptor) 988 case PLTYPE_RECORD: 989 ret, err = TypeDataSV.recordToBytes(x, param.typeDescriptor) 990 case BLOB: 991 ret, err = TypeDataSV.toBytesFromDmStruct(x, param.typeDescriptor) 992 if err == nil { 993 ret, err = G2DB.bytes2Blob(ret.([]byte), param, connection) 994 } 995 996 default: 997 err = ECGO_DATA_CONVERTION_ERROR.throw() 998 } 999 return ret, err 1000 }