oceanbase

obsm_utils.cpp
555 строк · 23.7 Кб
Перенос по словам
1
/**
2
 * Copyright (c) 2021 OceanBase
3
 * OceanBase CE is licensed under Mulan PubL v2.
4
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
5
 * You may obtain a copy of Mulan PubL v2 at:
6
 *          http://license.coscl.org.cn/MulanPubL-2.0
7
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
 * See the Mulan PubL v2 for more details.
11
 */
12

13
#include "obsm_utils.h"
14

15
#include "lib/time/ob_time_utility.h"
16
#include "lib/charset/ob_dtoa.h"
17
#include "common/ob_field.h"
18
#include "share/schema/ob_schema_getter_guard.h"
19
#include "share/schema/ob_udt_info.h"
20
#include "pl/ob_pl_user_type.h"
21

22
using namespace oceanbase::common;
23
using namespace oceanbase::obmysql;
24
using namespace oceanbase::share::schema;
25
using namespace oceanbase::pl;
26

27
struct ObMySQLTypeMap
28
{
29
  /* oceanbase::common::ObObjType ob_type; */
30
  EMySQLFieldType mysql_type;
31
  uint16_t flags;         /* flags if Field */
32
  uint64_t length;        /* other than varchar type */
33
};
34

35
// @todo
36
// reference: https://dev.mysql.com/doc/refman/5.6/en/c-api-data-structures.html
37
// reference: http://dev.mysql.com/doc/internals/en/client-server-protocol.html
38
static const ObMySQLTypeMap type_maps_[ObMaxType] =
39
{
40
  /* ObMinType */
41
  {EMySQLFieldType::MYSQL_TYPE_NULL,      BINARY_FLAG, 0},                        /* ObNullType */
42
  {EMySQLFieldType::MYSQL_TYPE_TINY,      0, 0},                                  /* ObTinyIntType */
43
  {EMySQLFieldType::MYSQL_TYPE_SHORT,     0, 0},                                  /* ObSmallIntType */
44
  {EMySQLFieldType::MYSQL_TYPE_INT24,     0, 0},                                  /* ObMediumIntType */
45
  {EMySQLFieldType::MYSQL_TYPE_LONG,      0, 0},                                  /* ObInt32Type */
46
  {EMySQLFieldType::MYSQL_TYPE_LONGLONG,  0, 0},                                  /* ObIntType */
47
  {EMySQLFieldType::MYSQL_TYPE_TINY,      UNSIGNED_FLAG, 0},                      /* ObUTinyIntType */
48
  {EMySQLFieldType::MYSQL_TYPE_SHORT,     UNSIGNED_FLAG, 0},                      /* ObUSmallIntType */
49
  {EMySQLFieldType::MYSQL_TYPE_INT24,     UNSIGNED_FLAG, 0},                      /* ObUMediumIntType */
50
  {EMySQLFieldType::MYSQL_TYPE_LONG,      UNSIGNED_FLAG, 0},                      /* ObUInt32Type */
51
  {EMySQLFieldType::MYSQL_TYPE_LONGLONG,  UNSIGNED_FLAG, 0},                      /* ObUInt64Type */
52
  {EMySQLFieldType::MYSQL_TYPE_FLOAT,     0, 0},                                  /* ObFloatType */
53
  {EMySQLFieldType::MYSQL_TYPE_DOUBLE,    0, 0},                                  /* ObDoubleType */
54
  {EMySQLFieldType::MYSQL_TYPE_FLOAT,     UNSIGNED_FLAG, 0},                      /* ObUFloatType */
55
  {EMySQLFieldType::MYSQL_TYPE_DOUBLE,    UNSIGNED_FLAG, 0},                      /* ObUDoubleType */
56
  {EMySQLFieldType::MYSQL_TYPE_NEWDECIMAL,0, 0},                                  /* ObNumberType */
57
  {EMySQLFieldType::MYSQL_TYPE_NEWDECIMAL,UNSIGNED_FLAG, 0},                      /* ObUNumberType */
58
  {EMySQLFieldType::MYSQL_TYPE_DATETIME,  BINARY_FLAG, 0},                        /* ObDateTimeType */
59
  {EMySQLFieldType::MYSQL_TYPE_TIMESTAMP, BINARY_FLAG | TIMESTAMP_FLAG, 0},       /* ObTimestampType */
60
  {EMySQLFieldType::MYSQL_TYPE_DATE,      BINARY_FLAG, 0},                        /* ObDateType */
61
  {EMySQLFieldType::MYSQL_TYPE_TIME,      BINARY_FLAG, 0},                        /* ObTimeType */
62
  {EMySQLFieldType::MYSQL_TYPE_YEAR,      UNSIGNED_FLAG | ZEROFILL_FLAG, 0},      /* ObYearType */
63
  {EMySQLFieldType::MYSQL_TYPE_VAR_STRING,   0, 0},                               /* ObVarcharType */
64
  {EMySQLFieldType::MYSQL_TYPE_STRING,       0, 0},                               /* ObCharType */
65
  {EMySQLFieldType::MYSQL_TYPE_VAR_STRING,   BINARY_FLAG, 0},                     /* ObHexStringType */
66
  {EMySQLFieldType::MYSQL_TYPE_COMPLEX,      0, 0},                               /* ObExtendType */
67
  {EMySQLFieldType::MYSQL_TYPE_NOT_DEFINED,  0, 0},                               /* ObUnknownType */
68
  {EMySQLFieldType::MYSQL_TYPE_TINY_BLOB,    BLOB_FLAG, 0},                       /* ObTinyTextType */
69
  {EMySQLFieldType::MYSQL_TYPE_BLOB,         BLOB_FLAG, 0},                       /* ObTextType */
70
  {EMySQLFieldType::MYSQL_TYPE_MEDIUM_BLOB,  BLOB_FLAG, 0},                       /* ObMediumTextType */
71
  {EMySQLFieldType::MYSQL_TYPE_LONG_BLOB,    BLOB_FLAG, 0},                       /* ObLongTextType */
72
  {EMySQLFieldType::MYSQL_TYPE_BIT,          UNSIGNED_FLAG, 0},                   /* ObBitType */
73
  {EMySQLFieldType::MYSQL_TYPE_STRING,       ENUM_FLAG, 0},                       /* ObEnumType */
74
  {EMySQLFieldType::MYSQL_TYPE_STRING,       SET_FLAG, 0},                        /* ObSetType */
75
  {EMySQLFieldType::MYSQL_TYPE_NOT_DEFINED,  0, 0},                               /* ObEnumInnerType */
76
  {EMySQLFieldType::MYSQL_TYPE_NOT_DEFINED,  0, 0},                               /* ObSetInnerType */
77
  {EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_TIME_ZONE,       BINARY_FLAG | TIMESTAMP_FLAG, 0}, /* ObTimestampTZType */
78
  {EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_LOCAL_TIME_ZONE, BINARY_FLAG | TIMESTAMP_FLAG, 0}, /* ObTimestampLTZType */
79
  {EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_NANO,                 BINARY_FLAG | TIMESTAMP_FLAG, 0},  /* ObTimestampNanoType */
80
  {EMySQLFieldType::MYSQL_TYPE_OB_RAW,                            BINARY_FLAG,                  0},  /* ObRawType */
81
  {EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_YM,                    BINARY_FLAG,                  0},  /* ObIntervalYMType */
82
  {EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_DS,                    BINARY_FLAG,                  0},  /* ObIntervalDSType */	
83
  {EMySQLFieldType::MYSQL_TYPE_OB_NUMBER_FLOAT,                   BINARY_FLAG,                  0},  /* ObNumberFloatType */
84
  {EMySQLFieldType::MYSQL_TYPE_OB_NVARCHAR2, 0, 0},                               /* ObNVarchar2Type */
85
  {EMySQLFieldType::MYSQL_TYPE_OB_NCHAR,     0, 0},                               /* ObNCharType */
86
  {EMySQLFieldType::MYSQL_TYPE_OB_UROWID,    0, 0},
87
  {EMySQLFieldType::MYSQL_TYPE_ORA_BLOB,       0, 0},                       /* ObLobType */
88
  {EMySQLFieldType::MYSQL_TYPE_JSON,       BLOB_FLAG | BINARY_FLAG, 0}, /* ObJsonType */
89
  {EMySQLFieldType::MYSQL_TYPE_GEOMETRY,   BLOB_FLAG | BINARY_FLAG, 0}, /* ObGeometryType */
90
  {EMySQLFieldType::MYSQL_TYPE_COMPLEX,   0, 0}, /* ObUserDefinedSQLType */
91
  {EMySQLFieldType::MYSQL_TYPE_NEWDECIMAL, 0, 0},                           /* ObDecimalIntType */
92
  /* ObMaxType */
93
};
94

95
//called by handle COM_STMT_EXECUTE offset is 0
96
bool ObSMUtils::update_from_bitmap(ObObj &param, const char *bitmap, int64_t field_index)
97
{
98
  bool ret = false;
99
  if (update_from_bitmap(bitmap, field_index)) {
100
    param.set_null();
101
    ret = true;
102
  }
103
  return ret;
104
}
105

106
bool ObSMUtils::update_from_bitmap(const char *bitmap, int64_t field_index)
107
{
108
  bool ret = false;
109
  int byte_pos = static_cast<int>(field_index / 8);
110
  int bit_pos  = static_cast<int>(field_index % 8);
111
  if (NULL != bitmap) {
112
    char value = bitmap[byte_pos];
113
    if (value & (1 << bit_pos)) {
114
      ret = true;
115
    }
116
  }
117
  return ret;
118
}
119

120
int ObSMUtils::cell_str(
121
    char *buf, const int64_t len,
122
    const ObObj &obj,
123
    MYSQL_PROTOCOL_TYPE type, int64_t &pos,
124
    int64_t cell_idx, char *bitmap,
125
    const ObDataTypeCastParams &dtc_params,
126
    const ObField *field,
127
    ObSchemaGetterGuard *schema_guard,
128
    uint64_t tenant_id)
129
{
130
  int ret = OB_SUCCESS;
131

132
  ObScale scale = 0;
133
  ObPrecision precision = 0;
134
  bool zerofill = false;
135
  int32_t zflength = 0;
136
  bool is_oracle_raw = false;
137
  if (NULL == field) {
138
    if (OB_UNLIKELY(obj.is_invalid_type())) {
139
      ret = OB_INVALID_ARGUMENT;
140
    } else {
141
      scale = ObAccuracy::DML_DEFAULT_ACCURACY[obj.get_type()].get_scale();
142
    }
143
  } else {
144
    scale = field->accuracy_.get_scale();
145
    precision = field->accuracy_.get_precision();
146
    zerofill = field->flags_ & ZEROFILL_FLAG;
147
    zflength = field->length_;
148
    OB_LOG(DEBUG, "get field accuracy_", K(field->accuracy_), K(zerofill), K(obj));
149
  }
150
  if (OB_SUCC(ret)) {
151
    switch (obj.get_type_class()) {
152
      case ObNullTC:
153
        ret = ObMySQLUtil::null_cell_str(buf, len, type, pos, cell_idx, bitmap);
154
        break;
155
      case ObIntTC:
156
        ret = ObMySQLUtil::int_cell_str(buf, len, obj.get_int(), obj.get_type(), false, type, pos, zerofill, zflength);
157
        break;
158
      case ObUIntTC:
159
        ret = ObMySQLUtil::int_cell_str(buf, len, obj.get_int(), obj.get_type(), true, type, pos, zerofill, zflength);
160
        break;
161
      case ObFloatTC:
162
        ret = ObMySQLUtil::float_cell_str(buf, len, obj.get_float(), type, pos, scale, zerofill, zflength);
163
        break;
164
      case ObDoubleTC:
165
        ret = ObMySQLUtil::double_cell_str(buf, len, obj.get_double(), type, pos, scale, zerofill, zflength);
166
        break;
167
      case ObNumberTC:
168
        ret = ObMySQLUtil::number_cell_str(buf, len, obj.get_number(), pos, scale, zerofill, zflength);
169
        break;
170
      case ObDateTimeTC:
171
        ret = ObMySQLUtil::datetime_cell_str(buf, len, obj.get_datetime(), type, pos, (obj.is_timestamp() ? dtc_params.tz_info_ : NULL), scale);
172
        break;
173
      case ObDateTC:
174
        ret = ObMySQLUtil::date_cell_str(buf, len, obj.get_date(), type, pos);
175
        break;
176
      case ObTimeTC:
177
        ret = ObMySQLUtil::time_cell_str(buf, len, obj.get_time(), type, pos, scale);
178
        break;
179
      case ObYearTC:
180
        ret = ObMySQLUtil::year_cell_str(buf, len, obj.get_year(), type, pos);
181
        break;
182
      case ObOTimestampTC:
183
        ret = ObMySQLUtil::otimestamp_cell_str(buf, len, obj.get_otimestamp_value(), type, pos, dtc_params, scale, obj.get_type());
184
        break;
185
      case ObRawTC:
186
      case ObTextTC: // TODO@hanhui texttc share the stringtc temporarily
187
      case ObStringTC:
188
      // lob locator也会按varchar方式进行encode, 客户端往server端传输数据时,
189
      // 也是将lob locator按varchar传输, 先编码LobLocator length, 然后再编码整个lob Locator
190
      case ObLobTC: {
191
        ret = ObMySQLUtil::varchar_cell_str(buf, len, obj.get_string(), is_oracle_raw, pos);
192
        break;
193
      }
194
      case ObJsonTC:{
195
        ret = ObMySQLUtil::json_cell_str(MTL_ID(), buf, len, obj.get_string(), pos);
196
        break;
197
      }
198
      case ObGeometryTC: {
199
        ret = ObMySQLUtil::geometry_cell_str(buf, len, obj.get_string(), pos);
200
        break;
201
      }
202
      case ObBitTC: {
203
        int32_t bit_len = 0;
204
        if (OB_LIKELY(precision > 0)) {
205
          bit_len = precision;
206
        } else {
207
          bit_len = ObAccuracy::MAX_ACCURACY[obj.get_type()].precision_;
208
          _OB_LOG(WARN, "max precision is used. origin precision is %d", precision);
209
        }
210
        ret = ObMySQLUtil::bit_cell_str(buf, len, obj.get_bit(), bit_len, type, pos);
211
        break;
212
      }
213
      case ObExtendTC: {
214
        common::ObArenaAllocator allocator;
215
        const pl::ObUserDefinedType *user_type = NULL;
216
        const ObUDTTypeInfo *udt_info = NULL;
217
        ObObj shadow_obj = obj;
218
        char *src = reinterpret_cast<char*>(&shadow_obj);
219
        uint64_t database_id = OB_INVALID_ID;
220
        if (OB_ISNULL(field) || OB_ISNULL(schema_guard)) {
221
          ret = OB_ERR_UNEXPECTED;
222
          OB_LOG(WARN, "complex type need field and schema guard not null", K(ret));
223
        } else if (field->type_.get_type() != ObExtendType) {
224
          ret = OB_ERR_UNEXPECTED;
225
          OB_LOG(WARN, "field type is not ObExtended", K(ret));
226
        } else if (field->type_owner_.empty() || field->type_name_.empty()) {
227
          if (0 == field->type_name_.case_compare("SYS_REFCURSOR")) {
228
            ObPLCursorInfo *cursor = reinterpret_cast<ObPLCursorInfo*>(obj.get_int());
229
            if (OB_ISNULL(cursor)) {
230
              // cursor may null, we cell null to client.
231
              ret = ObMySQLUtil::null_cell_str(buf, len, type, pos, cell_idx, bitmap);
232
            } else if (OB_FAIL(ObMySQLUtil::int_cell_str(buf,
233
                                                         len,
234
                                                         cursor->get_id(),
235
                                                         ObInt32Type,
236
                                                         false,
237
                                                         type,
238
                                                         pos,
239
                                                         zerofill,
240
                                                         zflength))) {
241
              OB_LOG(WARN,
242
                     "int cell str filled",
243
                     K(cursor->get_id()),
244
                     K(ObString(len, buf)),
245
                     K(ret));
246
            } else { /*do nothing*/ }
247
#ifdef OB_BUILD_ORACLE_PL
248
          } else if (obj.is_pl_extend()
249
                     && PL_NESTED_TABLE_TYPE == obj.get_meta().get_extend_type()) {
250
            // anonymous collection
251
            ObPLCollection *coll = reinterpret_cast<ObPLCollection *>(obj.get_ext());
252
            ObNestedTableType *nested_type = NULL;
253
            ObPLDataType element_type;
254
            if (OB_ISNULL(nested_type =
255
              reinterpret_cast<ObNestedTableType*>(allocator.alloc(sizeof(ObNestedTableType))))) {
256
              ret = OB_ALLOCATE_MEMORY_FAILED;
257
              OB_LOG(WARN, "failed to alloc memory for ObNestedTableType", K(ret));
258
            } else if (OB_ISNULL(coll)) {
259
              ret = OB_ERR_UNEXPECTED;
260
              OB_LOG(WARN, "coll is null", K(ret));
261
            } else if (FALSE_IT(new (nested_type) ObNestedTableType())) {
262
            } else if (FALSE_IT(element_type.reset())) {
263
            } else if (FALSE_IT(element_type.set_data_type(coll->get_element_type()))) {
264
            } else if (FALSE_IT(nested_type->set_element_type(element_type))) {
265
            } else if (OB_FAIL(nested_type->serialize(
266
                                *schema_guard, dtc_params.tz_info_, type, src, buf, len, pos))) {
267
              OB_LOG(WARN, "failed to serialize anonymous collection", K(ret));
268
            } else {
269
              OB_LOG(DEBUG, "success to serialize anonymous collection", K(ret));
270
            }
271
#endif
272
          } else {
273
            ret = OB_ERR_UNEXPECTED;
274
            OB_LOG(WARN, "type owner or type name is empty", KPC(field), K(ret));
275
          }
276
        } else {
277
          if (OB_FAIL(schema_guard->get_database_id(tenant_id, field->type_owner_, database_id))) {
278
            OB_LOG(WARN, "failed to get database id", K(ret));
279
          } else if (OB_FAIL(schema_guard->get_udt_info(tenant_id, database_id, OB_INVALID_ID,
280
                                                        field->type_name_, udt_info))) {
281
            OB_LOG(WARN, "failed to get udt info", K(ret), K(field));
282
          }
283
          if (OB_ISNULL(udt_info)) {
284
            // try system udt
285
            if (0 == field->type_owner_.case_compare(OB_SYS_DATABASE_NAME)
286
                || 0 == field->type_owner_.case_compare("SYS")) {
287
              if (OB_FAIL(schema_guard->get_udt_info(
288
                  OB_SYS_TENANT_ID, OB_SYS_DATABASE_ID,
289
                  OB_INVALID_ID, field->type_name_, udt_info))) {
290
                OB_LOG(WARN, "failed to get sys udt info", K(ret), K(field));
291
              }
292
            }
293
            if (OB_SUCC(ret) && OB_ISNULL(udt_info)) {
294
              ret = OB_ERR_UNEXPECTED;
295
              OB_LOG(WARN, "udt info is null", K(ret));
296
            }
297
          }
298
          if (OB_FAIL(ret)) {
299
          } else if (OB_FAIL(udt_info->transform_to_pl_type(allocator, user_type))) {
300
            OB_LOG(WARN, "faild to transform to pl type", K(ret));
301
          } else if (OB_ISNULL(user_type)) {
302
            ret = OB_ERR_UNEXPECTED;
303
            OB_LOG(WARN, "user type is null", K(ret));
304
          } else if (OB_FAIL(user_type->serialize(*schema_guard, dtc_params.tz_info_, type, src, buf, len, pos))) {
305
            OB_LOG(WARN, "failed to serialize", K(ret));
306
          }
307
        }
308
        break;
309
      }
310
      case ObIntervalTC: {
311
        ret = obj.is_interval_ym() ?
312
              ObMySQLUtil::interval_ym_cell_str(buf, len, obj.get_interval_ym(), type, pos, scale) :
313
              ObMySQLUtil::interval_ds_cell_str(buf, len, obj.get_interval_ds(), type, pos, scale);
314
        break;
315
      }
316
      case ObRowIDTC: {
317
        if (obj.is_urowid()) {
318
          ret = ObMySQLUtil::urowid_cell_str(buf, len, obj.get_urowid(), pos);
319
        } else {
320
          ret = OB_NOT_SUPPORTED;
321
          OB_LOG(WARN, "not support rowid type for now", K(ret));
322
        }
323
        break;
324
      }
325
      case ObUserDefinedSQLTC: {
326
        ret = ObMySQLUtil::sql_utd_cell_str(MTL_ID(), buf, len, obj.get_string(), pos);
327
        break;
328
      }
329
      case ObDecimalIntTC: {
330
        ret = ObMySQLUtil::decimalint_cell_str(buf, len, obj.get_decimal_int(), obj.get_int_bytes(),
331
                                               obj.get_scale(), pos, zerofill, zflength);
332
        break;
333
      }
334
      default:
335
        _OB_LOG(ERROR, "invalid ob type=%d", obj.get_type());
336
        ret = OB_ERROR;
337
        break;
338
    }
339
  }
340
  return ret;
341
}
342

343
int get_map(ObObjType ob_type, const ObMySQLTypeMap *&map)
344
{
345
  int ret = OB_SUCCESS;
346
  if (ob_type >= ObMaxType) {
347
    ret = OB_OBJ_TYPE_ERROR;
348
  }
349

350
  if (OB_SUCC(ret)) {
351
    map = type_maps_ + ob_type;
352
  }
353

354
  return ret;
355
}
356

357
int ObSMUtils::get_type_length(ObObjType ob_type, int64_t &length)
358
{
359
  const ObMySQLTypeMap *map = NULL;
360
  int ret = OB_SUCCESS;
361

362
  if ((ret = get_map(ob_type, map)) == OB_SUCCESS) {
363
    length = map->length;
364
  }
365
  return ret;
366
}
367

368
int ObSMUtils::get_mysql_type(ObObjType ob_type, EMySQLFieldType &mysql_type,
369
                              uint16_t &flags, ObScale &num_decimals)
370
{
371
  const ObMySQLTypeMap *map = NULL;
372
  int ret = OB_SUCCESS;
373

374
  if ((ret = get_map(ob_type, map)) == OB_SUCCESS) {
375
    mysql_type = map->mysql_type;
376
    flags |= map->flags;
377
    // batch fixup num_decimal values
378
    // so as to be compatible with mysql metainfo
379
    switch (mysql_type) {
380
      case EMySQLFieldType::MYSQL_TYPE_LONGLONG:
381
      case EMySQLFieldType::MYSQL_TYPE_LONG:
382
      case EMySQLFieldType::MYSQL_TYPE_INT24:
383
      case EMySQLFieldType::MYSQL_TYPE_SHORT:
384
      case EMySQLFieldType::MYSQL_TYPE_TINY:
385
      case EMySQLFieldType::MYSQL_TYPE_NULL:
386
      case EMySQLFieldType::MYSQL_TYPE_DATE:
387
      case EMySQLFieldType::MYSQL_TYPE_YEAR:
388
      case EMySQLFieldType::MYSQL_TYPE_BIT:
389
      case EMySQLFieldType::MYSQL_TYPE_JSON: // mysql json and long text decimals are 0, we do not need it?
390
      case EMySQLFieldType::MYSQL_TYPE_GEOMETRY:
391
      case EMySQLFieldType::MYSQL_TYPE_ORA_XML:
392
        num_decimals = 0;
393
        break;
394

395
      case EMySQLFieldType::MYSQL_TYPE_TINY_BLOB:
396
      case EMySQLFieldType::MYSQL_TYPE_BLOB:
397
      case EMySQLFieldType::MYSQL_TYPE_MEDIUM_BLOB:
398
      case EMySQLFieldType::MYSQL_TYPE_LONG_BLOB:
399
      case EMySQLFieldType::MYSQL_TYPE_VAR_STRING:
400
      case EMySQLFieldType::MYSQL_TYPE_STRING:
401
      case EMySQLFieldType::MYSQL_TYPE_OB_RAW:
402
      case EMySQLFieldType::MYSQL_TYPE_COMPLEX:
403
      case EMySQLFieldType::MYSQL_TYPE_OB_NVARCHAR2:
404
      case EMySQLFieldType::MYSQL_TYPE_OB_NCHAR:
405
      case EMySQLFieldType::MYSQL_TYPE_OB_UROWID:
406
      case EMySQLFieldType::MYSQL_TYPE_ORA_BLOB:
407
      case EMySQLFieldType::MYSQL_TYPE_ORA_CLOB:
408
        // for compatible with MySQL, ugly convention.
409
        num_decimals = static_cast<ObScale>(lib::is_oracle_mode()
410
        ? ORACLE_NOT_FIXED_DEC
411
        : 0);
412
        break;
413
      case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_TIME_ZONE:
414
      case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_LOCAL_TIME_ZONE:
415
      case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_NANO:
416
      case EMySQLFieldType::MYSQL_TYPE_TIMESTAMP:
417
      case EMySQLFieldType::MYSQL_TYPE_DATETIME:
418
      case EMySQLFieldType::MYSQL_TYPE_TIME:
419
      case EMySQLFieldType::MYSQL_TYPE_FLOAT:
420
      case EMySQLFieldType::MYSQL_TYPE_DOUBLE:
421
      case EMySQLFieldType::MYSQL_TYPE_NEWDECIMAL:
422
      case EMySQLFieldType::MYSQL_TYPE_OB_NUMBER_FLOAT:
423
      case EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_YM:
424
      case EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_DS:
425
        num_decimals = static_cast<ObScale>((num_decimals == -1)
426
            ? (lib::is_oracle_mode() ? ORACLE_NOT_FIXED_DEC : NOT_FIXED_DEC)
427
            : num_decimals);
428
        break;
429
      default:
430
        ret = OB_ERR_UNEXPECTED;
431
        _OB_LOG(WARN, "unexpected mysql_type=%d", mysql_type);
432
        break;
433
    } // end switch
434
  }
435
  return ret;
436
}
437

438
int ObSMUtils::get_ob_type(ObObjType &ob_type, EMySQLFieldType mysql_type, const bool is_unsigned)
439
{
440
  int ret = OB_SUCCESS;
441
  switch (mysql_type) {
442
    case EMySQLFieldType::MYSQL_TYPE_NULL:
443
      ob_type = ObNullType;
444
      break;
445
    case EMySQLFieldType::MYSQL_TYPE_TINY:
446
      ob_type = is_unsigned ? ObUTinyIntType : ObTinyIntType;
447
      break;
448
    case EMySQLFieldType::MYSQL_TYPE_SHORT:
449
      ob_type = is_unsigned ? ObUSmallIntType : ObSmallIntType;
450
      break;
451
    case EMySQLFieldType::MYSQL_TYPE_LONG:
452
      ob_type = is_unsigned ? ObUInt32Type : ObInt32Type;
453
      break;
454
    case EMySQLFieldType::MYSQL_TYPE_LONGLONG:
455
      ob_type = is_unsigned ? ObUInt64Type : ObIntType;
456
      break;
457
    case EMySQLFieldType::MYSQL_TYPE_FLOAT:
458
      ob_type = ObFloatType;
459
      break;
460
    case EMySQLFieldType::MYSQL_TYPE_DOUBLE:
461
      ob_type = ObDoubleType;
462
      break;
463
    case EMySQLFieldType::MYSQL_TYPE_TIMESTAMP:
464
      ob_type = ObTimestampType;
465
      break;
466
    case EMySQLFieldType::MYSQL_TYPE_DATETIME:
467
      ob_type = ObDateTimeType;
468
      break;
469
    case EMySQLFieldType::MYSQL_TYPE_TIME:
470
      ob_type = ObTimeType;
471
      break;
472
    case EMySQLFieldType::MYSQL_TYPE_DATE:
473
      ob_type = ObDateType;
474
      break;
475
    case EMySQLFieldType::MYSQL_TYPE_YEAR:
476
      ob_type = ObYearType;
477
      break;
478
    case EMySQLFieldType::MYSQL_TYPE_VARCHAR:
479
    case EMySQLFieldType::MYSQL_TYPE_STRING:
480
    case EMySQLFieldType::MYSQL_TYPE_VAR_STRING:
481
      ob_type = ObVarcharType;
482
      break;
483
    case EMySQLFieldType::MYSQL_TYPE_TINY_BLOB:
484
      ob_type = ObTinyTextType;
485
      break;
486
    case EMySQLFieldType::MYSQL_TYPE_BLOB:
487
      ob_type = ObTextType;
488
      break;
489
    case EMySQLFieldType::MYSQL_TYPE_MEDIUM_BLOB:
490
      ob_type = ObMediumTextType;
491
      break;
492
    case EMySQLFieldType::MYSQL_TYPE_LONG_BLOB:
493
      ob_type = ObLongTextType;
494
      break;
495
    case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_TIME_ZONE:
496
      ob_type = ObTimestampTZType;
497
      break;
498
    case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_WITH_LOCAL_TIME_ZONE:
499
      ob_type = ObTimestampLTZType;
500
      break;
501
    case EMySQLFieldType::MYSQL_TYPE_OB_TIMESTAMP_NANO:
502
      ob_type = ObTimestampNanoType;
503
      break;
504
    case EMySQLFieldType::MYSQL_TYPE_OB_RAW:
505
      ob_type = ObRawType;
506
      break;
507
    case EMySQLFieldType::MYSQL_TYPE_NEWDECIMAL:
508
      ob_type = ObNumberType;
509
      break;
510
    case EMySQLFieldType::MYSQL_TYPE_BIT:
511
      ob_type = ObBitType;
512
      break;
513
    case EMySQLFieldType::MYSQL_TYPE_ENUM:
514
      ob_type = ObEnumType;
515
      break;
516
    case EMySQLFieldType::MYSQL_TYPE_SET:
517
      ob_type = ObSetType;
518
      break;
519
    case EMySQLFieldType::MYSQL_TYPE_COMPLEX:
520
      ob_type = ObExtendType;
521
      break;
522
    case EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_YM:
523
      ob_type = ObIntervalYMType;
524
      break;
525
    case EMySQLFieldType::MYSQL_TYPE_OB_INTERVAL_DS:
526
      ob_type = ObIntervalDSType;
527
      break;
528
    case EMySQLFieldType::MYSQL_TYPE_OB_NUMBER_FLOAT:
529
      ob_type = ObNumberFloatType;
530
      break;
531
    case EMySQLFieldType::MYSQL_TYPE_OB_NVARCHAR2:
532
      ob_type = ObNVarchar2Type;
533
      break;
534
    case EMySQLFieldType::MYSQL_TYPE_OB_NCHAR:
535
      ob_type = ObNCharType;
536
      break;
537
    case EMySQLFieldType::MYSQL_TYPE_OB_UROWID:
538
      ob_type = ObURowIDType;
539
      break;
540
    case EMySQLFieldType::MYSQL_TYPE_ORA_BLOB:
541
    case EMySQLFieldType::MYSQL_TYPE_ORA_CLOB:
542
      ob_type = ObLobType;
543
      break;
544
    case EMySQLFieldType::MYSQL_TYPE_JSON:
545
      ob_type = ObJsonType;
546
      break;
547
    case EMySQLFieldType::MYSQL_TYPE_GEOMETRY:
548
      ob_type = ObGeometryType;
549
      break;
550
    default:
551
      _OB_LOG(WARN, "unsupport MySQL type %d", mysql_type);
552
      ret = OB_OBJ_TYPE_ERROR;
553
  }
554
  return ret;
555
}
556
oceanbase

Использование cookies
