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  }