hcq/obconnector-c
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4c565b9dd75bb1719e3a4eedf5df0d17fa9c70da
obconnector-c/libmariadb/ob_oracle_format_models.c
weihao.twh 4c565b9dd7 support protocol ob20 and full link trace
2022-10-17 16:49:00 +08:00

2513 lines
85 KiB
C
Raw Blame History

/*
Copyright (c) 2000, 2018, Oracle and/or its affiliates.
Copyright (c) 2009, 2019, MariaDB Corporation.
Copyright (c) 2021 OceanBase Technology Co.,Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#include <ma_global.h>
#include <ma_sys.h>
#include "ob_oralce_format_models.h"
#include "mariadb_ctype.h"
#include <ma_string.h>
#include "ob_bitmap.h"
int32_t calc_max_name_length(const struct ObTimeConstStr names[], const int64_t size);
#define FALSE_IT(stmt) ({ (stmt); FALSE; })
#define INT32_MAX_DIGITS_LEN 10
#define EPOCH_YEAR4 1970
#define EPOCH_WDAY 4 // 1970-1-1 is thursday.
#define LEAP_YEAR_COUNT(y) ((y) / 4 - (y) / 100 + (y) / 400)
#define IS_LEAP_YEAR(y) ((((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) ? 1 : 0)
#define DAYS_PER_NYEAR 365
#define DAYS_PER_LYEAR 366
static const int32_t MIN_OFFSET_MINUTES = -15 * 60 - 59;
static const int32_t MAX_OFFSET_MINUTES = 15 * 60 + 59;
static const int32_t ZERO_DATE = (int32_t)(-106751991);
static const int64_t ZERO_TIME = 0;
static const int64_t MAX_VARCHAR_LENGTH = 1024L * 1024L; // unit is byte
static const int64_t COMMON_ELEMENT_NUMBER = 10;
static const int16_t MAX_SCALE_FOR_ORACLE_TEMPORAL = 9;
static const int16_t DEFAULT_SCALE_FOR_ORACLE_FRACTIONAL_SECONDS = 6;
static const int64_t UNKNOWN_LENGTH_OF_ELEMENT = 20;
static const int64_t power_of_10[INT32_MAX_DIGITS_LEN] = {
1L,
10L,
100L,
1000L,
10000L,
100000L,
1000000L,
10000000L,
100000000L,
1000000000L,
//2147483647
};
const int64_t TZ_PART_MIN[DATETIME_PART_CNT] = { 1, 1, 1, 0, 0, 0, 0};
const int64_t TZ_PART_MAX[DATETIME_PART_CNT] = {9999, 12, 31, 23, 59, 59, 1000000000};
static const int8_t DAYS_PER_MON[2][12 + 1] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
static const int32_t DAYS_UNTIL_MON[2][12 + 1] = {
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
{0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
};
/**
* 3 days after wday 5 is wday 1, so [3][5] = 1.
* 5 days before wday 2 is wday 4, so [-5][2] = 4.
* and so on, max wday is 7, min offset is -6, max offset days is 6.
*/
static const int8_t WDAY_OFFSET_ARR[DAYS_PER_WEEK * 2 - 1][DAYS_PER_WEEK + 1] = {
{0, 2, 3, 4, 5, 6, 7, 1},
{0, 3, 4, 5, 6, 7, 1, 2},
{0, 4, 5, 6, 7, 1, 2, 3},
{0, 5, 6, 7, 1, 2, 3, 4},
{0, 6, 7, 1, 2, 3, 4, 5},
{0, 7, 1, 2, 3, 4, 5, 6}, // offset = -1, wday = 1/2/3/4/5/6/7.
{0, 1, 2, 3, 4, 5, 6, 7}, // offset = 0, wday = 1/2/3/4/5/6/7.
{0, 2, 3, 4, 5, 6, 7, 1}, // offset = 1, wday = 1/2/3/4/5/6/7.
{0, 3, 4, 5, 6, 7, 1, 2},
{0, 4, 5, 6, 7, 1, 2, 3},
{0, 5, 6, 7, 1, 2, 3, 4},
{0, 6, 7, 1, 2, 3, 4, 5},
{0, 7, 1, 2, 3, 4, 5, 6}
};
static const int8_t (*WDAY_OFFSET)[DAYS_PER_WEEK + 1] = &WDAY_OFFSET_ARR[6];
/*
* if wday of yday 1 is 4, not SUN_BEGIN, not GE_4_BEGIN, yday of fitst day of week 1 is 5, so [4][0][0] = 5.
* if wday of yday 1 is 2, SUN_BEGIN, GE_4_BEGIN, yday of fitst day of week 1 is 5, so [2][1][1] = 1.
* and so on, max wday is 7, and other two is 1.
* ps: if the first week is not full week(GE_4_BEGIN), the yday maybe zero or neg, such as 0 means
* the last day of prev year, and so on.
*/
static const int8_t YDAY_WEEK1[DAYS_PER_WEEK + 1][2][2] = {
{{0, 0}, {0, 0}},
{{1, 1}, {7, 0}}, // wday of day 1 is 1.
{{7, 0}, {6, -1}}, // 2.
{{6, -1}, {5, -2}}, // 3.
{{5, -2}, {4, 4}}, // 4.
{{4, 4}, {3, 3}}, // 5.
{{3, 3}, {2, 2}}, // 6.
{{2, 2}, {1, 1}} // 7.
};
#define WEEK_MODE_CNT 8
static const ObDTMode WEEK_MODE[WEEK_MODE_CNT] = {
DT_WEEK_SUN_BEGIN | DT_WEEK_ZERO_BEGIN ,
DT_WEEK_ZERO_BEGIN | DT_WEEK_GE_4_BEGIN ,
DT_WEEK_SUN_BEGIN ,
DT_WEEK_GE_4_BEGIN , //ISO-8601 standard week
DT_WEEK_SUN_BEGIN | DT_WEEK_ZERO_BEGIN | DT_WEEK_GE_4_BEGIN ,
DT_WEEK_ZERO_BEGIN ,
DT_WEEK_SUN_BEGIN | DT_WEEK_GE_4_BEGIN ,
0
};
static const int32_t DAYS_PER_YEAR[2]=
{
DAYS_PER_NYEAR, DAYS_PER_LYEAR
};
static const struct ObTimeConstStr WDAY_NAMES[DAYS_PER_WEEK + 1] = {
{"null", 4},
{"Monday", 6}, {"Tuesday", 7}, {"Wednesday", 9}, {"Thursday", 8}, {"Friday", 6}, {"Saturday", 8}, {"Sunday", 6}
};
static const int32_t MAX_WDAY_NAME_LENGTH = 9;
static const struct ObTimeConstStr WDAY_ABBR_NAMES[DAYS_PER_WEEK + 1] = {
{"null", 4},
{"Mon", 3}, {"Tue", 3}, {"Wed", 3}, {"Thu", 3}, {"Fri", 3}, {"Sat", 3}, {"Sun", 3}
};
static const struct ObTimeConstStr MON_NAMES[12 + 1] = {
{"null", 4},
{"January", 7}, {"February", 8}, {"March", 5}, {"April", 5}, {"May", 3}, {"June", 4},
{"July", 4}, {"August", 6}, {"September", 9}, {"October", 7}, {"November", 8}, {"December", 8}
};
static const int32_t MAX_MON_NAME_LENGTH = 9;
static const struct ObTimeConstStr MON_ABBR_NAMES[12 + 1] = {
{"null", 4},
{"Jan", 3}, {"Feb", 3}, {"Mar", 3}, {"Apr", 3}, {"May", 3}, {"Jun", 3},
{"Jul", 3}, {"Aug", 3}, {"Sep", 3}, {"Oct", 3}, {"Nov", 3}, {"Dec", 3}
};
static int64_t CONFLICT_GROUP_MAP[MAX_FLAG_NUMBER] =
{
/**AD*/ ERA_GROUP,
/**AD2*/ ERA_GROUP,
/**BC*/ ERA_GROUP,
/**BC2*/ ERA_GROUP,
/**CC,*/ NEVER_APPEAR_GROUP,
/**SCC*/ NEVER_APPEAR_GROUP,
/**D*/ WEEK_OF_DAY_GROUP,
/**DAY*/ WEEK_OF_DAY_GROUP,
/**DD*/ NON_CONFLICT_GROUP,
/**DDD*/ DAY_OF_YEAR_GROUP,
/**DY*/ WEEK_OF_DAY_GROUP,
/**FF1*/ NON_CONFLICT_GROUP,
/**FF2*/ NON_CONFLICT_GROUP,
/**FF3*/ NON_CONFLICT_GROUP,
/**FF4*/ NON_CONFLICT_GROUP,
/**FF5*/ NON_CONFLICT_GROUP,
/**FF6*/ NON_CONFLICT_GROUP,
/**FF7*/ NON_CONFLICT_GROUP,
/**FF8*/ NON_CONFLICT_GROUP,
/**FF9*/ NON_CONFLICT_GROUP,
/**FF*/ NON_CONFLICT_GROUP,
/**HH*/ HOUR_GROUP,
/**HH24*/ HOUR_GROUP,
/**HH12*/ HOUR_GROUP,
/**IW*/ NEVER_APPEAR_GROUP,
/**I*/ NEVER_APPEAR_GROUP,
/**IY*/ NEVER_APPEAR_GROUP,
/**IYY*/ NEVER_APPEAR_GROUP,
/**IYYY*/ NEVER_APPEAR_GROUP,
/**MI*/ NON_CONFLICT_GROUP,
/**MM*/ MONTH_GROUP,
/**MONTH*/ MONTH_GROUP,
/**MON*/ MONTH_GROUP,
/**AM*/ MERIDIAN_INDICATOR_GROUP,
/**AM2*/ MERIDIAN_INDICATOR_GROUP,
/**PM*/ MERIDIAN_INDICATOR_GROUP,
/**PM2*/ MERIDIAN_INDICATOR_GROUP,
/**Q*/ NON_CONFLICT_GROUP,
/**RR*/ YEAR_GROUP,
/**RRRR*/ YEAR_GROUP,
/**SS*/ NON_CONFLICT_GROUP,
/**SSSSS*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**WW*/ NEVER_APPEAR_GROUP,
/**W*/ NEVER_APPEAR_GROUP,
/**YGYYY*/ YEAR_GROUP,
/**YEAR*/ NEVER_APPEAR_GROUP,
/**SYEAR*/ NEVER_APPEAR_GROUP,
/**YYYY*/ YEAR_GROUP,
/**SYYYY*/ YEAR_GROUP,
/**YYY*/ YEAR_GROUP,
/**YY*/ YEAR_GROUP,
/**Y*/ YEAR_GROUP,
/**DS*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**DL*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**TZH*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**TZM*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**TZD*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**TZR*/ RUNTIME_CONFLICT_SOLVE_GROUP,
/**X*/ NON_CONFLICT_GROUP,
/**J*/ DAY_OF_YEAR_GROUP
};
//define the length ,may be less ,but should not max than this
static int64_t EXPECTED_MATCHING_LENGTH[MAX_FLAG_NUMBER] =
{
/**AD*/ 2,
/**AD2*/ 4,
/**BC*/ 2,
/**BC2*/ 4,
/**CC,*/ 0, //never used
/**SCC*/ 0, //never used
/**D*/ 1,
/**DAY*/ 0, //non-numeric, ignored
/**DD*/ 2,
/**DDD*/ 3,
/**DY*/ 0, //non-numeric, ignored
/**FF1*/ 1,
/**FF2*/ 2,
/**FF3*/ 3,
/**FF4*/ 4,
/**FF5*/ 5,
/**FF6*/ 6,
/**FF7*/ 7,
/**FF8*/ 8,
/**FF9*/ 9,
/**FF*/ 9,
/**HH*/ 2,
/**HH24*/ 2,
/**HH12*/ 2,
/**IW*/ 0, //never used
/**I*/ 0, //never used
/**IY*/ 0, //never used
/**IYY*/ 0, //never used
/**IYYY*/ 0, //never used
/**MI*/ 2,
/**MM*/ 2,
/**MONTH*/ 0, //non-numeric, ignored
/**MON*/ 0, //non-numeric, ignored
/**AM*/ 2,
/**AM2*/ 4,
/**PM*/ 2,
/**PM2*/ 4,
/**Q*/ 0, //never used
/**RR*/ 0, //special case
/**RRRR*/ 0, //special case
/**SS*/ 2,
/**SSSSS*/ 5,
/**WW*/ 0, //never used
/**W*/ 0, //never used
/**YGYYY*/ 5,
/**YEAR*/ 0, //never used
/**SYEAR*/ 0, //never used
/**YYYY*/ 4,
/**SYYYY*/ 4,
/**YYY*/ 3,
/**YY*/ 2,
/**Y*/ 1,
/**DS*/ 0, //todo
/**DL*/ 0, //todo
/**TZH*/ 2, //todo
/**TZM*/ 2, //todo
/**TZD*/ 0, //non-numeric, ignored
/**TZR*/ 0, //non-numeric, ignored
/**X*/ 0, //non-numeric, ignored
/**J*/ 7
};
int32_t calc_max_name_length(const struct ObTimeConstStr names[], const int64_t size)
{
int32_t res = 0;
int64_t i;
for (i = 1; i <= size; ++i) {
if (res < names[i].len_) {
res = names[i].len_;
}
}
return res;
}
int databuff_vprintf(char *buf, const int64_t buf_len, int64_t *pos, const char *fmt, va_list args)
{
int ret = 0;
if (NULL != buf && 0 <= *pos && *pos < buf_len) {
int len = vsnprintf(buf + *pos, buf_len - *pos, fmt, args);
if (len < 0) {
ret = 1;
} else if (len < buf_len - *pos) {
*pos += len;
} else {
*pos = buf_len - 1; //skip '\0' written by vsnprintf
ret = 1;
}
} else {
ret = 1;
}
return ret;
}
int databuff_printf(char *buf, const int64_t buf_len, int64_t *pos, const char *fmt, ...)
{
int ret = 0;
va_list args;
va_start(args, fmt);
if (0 != (ret = databuff_vprintf(buf, buf_len, pos, fmt, args))) {
} else {}
va_end(args);
return ret;
}
//PATTERN in windows(wingdi.h)Duplicate definition,So change PATTERN to PATTERNEX
//do not define duplicate pattern
const struct ObTimeConstStr PATTERNEX[MAX_FLAG_NUMBER] =
{
#define ObTimeConstStr(x) {x, sizeof(x) - 1}
ObTimeConstStr("AD"),
ObTimeConstStr("A.D."),
ObTimeConstStr("BC"),
ObTimeConstStr("B.C."),
ObTimeConstStr("CC"),
ObTimeConstStr("SCC"),
ObTimeConstStr("D"),
ObTimeConstStr("DAY"),
ObTimeConstStr("DD"),
ObTimeConstStr("DDD"),
ObTimeConstStr("DY"),
ObTimeConstStr("FF1"),
ObTimeConstStr("FF2"),
ObTimeConstStr("FF3"),
ObTimeConstStr("FF4"),
ObTimeConstStr("FF5"),
ObTimeConstStr("FF6"),
ObTimeConstStr("FF7"),
ObTimeConstStr("FF8"),
ObTimeConstStr("FF9"),
ObTimeConstStr("FF"),
ObTimeConstStr("HH"),
ObTimeConstStr("HH24"),
ObTimeConstStr("HH12"),
ObTimeConstStr("IW"),
ObTimeConstStr("I"),
ObTimeConstStr("IY"),
ObTimeConstStr("IYY"),
ObTimeConstStr("IYYY"),
ObTimeConstStr("MI"),
ObTimeConstStr("MM"),
ObTimeConstStr("MONTH"),
ObTimeConstStr("MON"),
ObTimeConstStr("AM"),
ObTimeConstStr("A.M."),
ObTimeConstStr("PM"),
ObTimeConstStr("P.M."),
ObTimeConstStr("Q"),
ObTimeConstStr("RR"),
ObTimeConstStr("RRRR"),
ObTimeConstStr("SS"),
ObTimeConstStr("SSSSS"),
ObTimeConstStr("WW"),
ObTimeConstStr("W"),
ObTimeConstStr("Y,YYY"),
ObTimeConstStr("YEAR"),
ObTimeConstStr("SYEAR"),
ObTimeConstStr("YYYY"),
ObTimeConstStr("SYYYY"),
ObTimeConstStr("YYY"),
ObTimeConstStr("YY"),
ObTimeConstStr("Y"),
ObTimeConstStr("DS"),
ObTimeConstStr("DL"),
ObTimeConstStr("TZH"),
ObTimeConstStr("TZM"),
ObTimeConstStr("TZD"),
ObTimeConstStr("TZR"),
ObTimeConstStr("X"),
#undef ObTimeConstStr
};
static const struct ObOracleTimeLimiter LIMITER_YEAR = {1, 9999, 1};
static const struct ObOracleTimeLimiter LIMITER_MONTH = {1, 12, 1};
static const struct ObOracleTimeLimiter LIMITER_MONTH_DAY = {1, 31, 1};
static const struct ObOracleTimeLimiter LIMITER_WEEK_DAY = {1, 7, 1};
static const struct ObOracleTimeLimiter LIMITER_YEAR_DAY = {1, 366, 1};
static const struct ObOracleTimeLimiter LIMITER_HOUR12 = {1, 12, 1};
static const struct ObOracleTimeLimiter LIMITER_HOUR24 = {0, 23, 1};
static const struct ObOracleTimeLimiter LIMITER_MINUTE = {0, 59, 1};
static const struct ObOracleTimeLimiter LIMITER_SECOND = {0, 59, 1};
static const struct ObOracleTimeLimiter LIMITER_SECS_PAST_MIDNIGHT = {0, 86399, 1};
static const struct ObOracleTimeLimiter LIMITER_TIMEZONE_HOUR_ABS = {0, 15, 1}; //ORA-01874: time zone hour must be between -15 and 15
static const struct ObOracleTimeLimiter LIMITER_TIMEZONE_MIN_ABS = {0, 59, 1}; //ORA-01875: time zone minute must be between -59 and 59
static const struct ObOracleTimeLimiter LIMITER_JULIAN_DATE = {1, 5373484,1}; // -4712-01-01 ~ 9999-12-31
static inline int check_validate(const struct ObOracleTimeLimiter *limiter, int32_t value)
{
int ret = 0;
if (value < limiter->MIN || value > limiter->MAX) {
ret = limiter->ERROR_CODE;
}
return ret;
}
int get_day_and_month_from_year_day(const int32_t yday, const int32_t year, int32_t *month, int32_t *day)
{
int ret = 0;
int32_t leap_year = IS_LEAP_YEAR(year);
if (yday > DAYS_UNTIL_MON[leap_year][12]) {
ret = 1;
} else {
my_bool stop_flag = FALSE;
int32_t i = LIMITER_MONTH.MIN;
for (; !stop_flag && i <= LIMITER_MONTH.MAX; ++i) {
if (yday <= DAYS_UNTIL_MON[leap_year][i]) {
*month = i;
*day = yday - DAYS_UNTIL_MON[leap_year][i - 1];
stop_flag = TRUE;
}
}
}
return ret;
}
int validate_oracle_date(const struct ObTime *ob_time)
{
const int32_t *parts = ob_time->parts_;
int ret = 0;
int i = 0;
for (; 0 == ret && i < ORACLE_DATE_PART_CNT; ++i) {
if (parts[i] < TZ_PART_MIN[i] || parts[i] > TZ_PART_MAX[i]) {
ret = 1;
}
}
if (0 == ret) {
int is_leap = IS_LEAP_YEAR(parts[DT_YEAR]);
if (parts[DT_MDAY] > DAYS_PER_MON[is_leap][parts[DT_MON]]) {
ret = 1;
}
}
return ret;
}
/*
* if format elements contains TZR
* hour minuts seconds and fracial second can not omit
* Because, I guess, the daylight-saving time may be uncertain
* if the time part is omitted.
* The day
*/
inline my_bool is_element_can_omit(const struct ObDFMElem *elem)
{
int ret_bool = TRUE;
int64_t flag = elem->elem_flag_;
int64_t conf_group = CONFLICT_GROUP_MAP[flag];
if (YEAR_GROUP == conf_group
|| WEEK_OF_DAY_GROUP == conf_group
|| MONTH_GROUP == conf_group
|| DD == flag
|| DS == flag
|| DL == flag) {
ret_bool = FALSE;
} else {
//return true
}
return ret_bool;
}
static inline my_bool is_sign_char(const char ch) {
return '-' == ch || '+' == ch;
}
static inline my_bool is_split_char(const char ch)
{
int ret_bool = FALSE;
if (ch == '\n' || ch == '\t'
|| ((ch >= 0x20 && ch <= 0x7E) &&
!((ch >= '0' && ch <= '9')
|| (ch >='a' && ch <= 'z')
|| (ch >= 'A' && ch <= 'Z')))) {
ret_bool = TRUE;
}
return ret_bool;
}
static int date_to_ob_time(int32_t value, struct ObTime *ob_time)
{
int ret = 0;
int32_t *parts = ob_time->parts_;
if (!HAS_TYPE_ORACLE(ob_time->mode_) && ZERO_DATE == value) {
memset(parts, 0, sizeof(*parts) * DATETIME_PART_CNT);
parts[DT_DATE] = ZERO_DATE;
} else {
int32_t days = value;
int32_t leap_year = 0;
int32_t year = EPOCH_YEAR4;
const int32_t *cur_days_until_mon = NULL;
int32_t month = 1;
parts[DT_DATE] = value;
// year.
while (days < 0 || days >= DAYS_PER_YEAR[leap_year = IS_LEAP_YEAR(year)]) {
int32_t new_year = year + days / DAYS_PER_NYEAR;
new_year -= (days < 0);
days -= (new_year - year) * DAYS_PER_NYEAR + LEAP_YEAR_COUNT(new_year - 1) - LEAP_YEAR_COUNT(year - 1);
year = new_year;
}
parts[DT_YEAR] = year;
parts[DT_YDAY] = days + 1;
parts[DT_WDAY] = WDAY_OFFSET[value % DAYS_PER_WEEK][EPOCH_WDAY];
// month.
cur_days_until_mon = DAYS_UNTIL_MON[leap_year];
for (; month < MONS_PER_YEAR && days >= cur_days_until_mon[month]; ++month) {}
parts[DT_MON] = month;
days -= cur_days_until_mon[month - 1];
// day.
parts[DT_MDAY] = days + 1;
}
return ret;
}
int set_ob_time_part_directly(struct ObTime *ob_time, int64_t *conflict_bitset, const int64_t part_offset, const int32_t part_value)
{
int ret = 0;
if (part_offset >= TOTAL_PART_CNT) {
ret = 1;
} else {
ob_time->parts_[part_offset] = part_value;
*conflict_bitset |= (1 << part_offset);
}
return ret;
}
// DT_YEAR use this interface ,as it should treat special：
// select to_date('5', 'YY') from dual; the result for oracle is 2005-09-01
//
int set_ob_time_year_may_conflict(struct ObTime *ob_time, int32_t *julian_year_value,
int32_t check_year, int32_t set_year,
my_bool overwrite)
{
int ret = 0;
if (ZERO_DATE != *julian_year_value) {
if (*julian_year_value != check_year) {
ret = 1;
} else if (overwrite) {
ob_time->parts_[DT_YEAR] = set_year;
}
} else {
ob_time->parts_[DT_YEAR] = set_year;
*julian_year_value = check_year;
}
return (ret);
}
/*
* element group may cause conflict on parts in ob_time
* 1. SSSSS vs HH, HH24, HH12, MI, SS
* 2. DDD vs DD MM/Mon/Month
*
* while call this function, the part_value must be the final value
*/
int set_ob_time_part_may_conflict(struct ObTime *ob_time, int64_t *conflict_bitset, const int64_t part_offset, const int32_t part_value)
{
int ret = 0;
if (part_offset >= TOTAL_PART_CNT) {
ret = 1;
} else {
if (0 != (*conflict_bitset & (1 << part_offset))) {
//already has data in ob_time.part_[part_name], validate it
if (part_value != ob_time->parts_[part_offset]) {
ret = 1;
}
} else {
*conflict_bitset |= (1 << part_offset);
ob_time->parts_[part_offset] = part_value;
}
}
return (ret);
}
int check_int_value_length(const struct ObDFMParseCtx *ctx,
const int64_t expected_len,
const int64_t real_data_len)
{
int ret = 0;
/*
* format need separate chars but input omit separate chars like:
* to_date('20181225', 'YYYY-MM-DD') input omit '-'
* in this situation, the numeric value are matched in fixed length mode.
* which means real_data_len should be equal to element expected length, or will return with an error
*/
if (0 == ret && ctx->is_matching_by_expected_len_) { //is true only in only in str_to_ob_time_oracle_dfm
my_bool legal = TRUE;
if (RR == ctx->expected_elem_flag_ || RRRR == ctx->expected_elem_flag_) { //one special case
legal = (2 == real_data_len || 4 == real_data_len);
} else if (expected_len > 0) { //usual case, for numeric value
legal = (real_data_len == expected_len);
}
if (!legal) {
ret = 1;
}
}
return ret;
}
static int match_int_value_with_comma(struct ObDFMParseCtx *ctx,
const int64_t expected_len,
int64_t *value_len,
int32_t *result)
{
int ret = 0;
int32_t temp_value = 0;
int64_t real_data_len = 0;
int64_t digits_len = 0;
int64_t continuous_comma_count = 0;
my_bool stop_flag = FALSE;
if (!(ctx->cur_ch_ != NULL && ctx->remain_len_ > 0)) {
ret = 1;
}
while (0 == ret && !stop_flag
&& real_data_len < ctx->remain_len_ && digits_len < expected_len) { //look digits by # of value_len
char cur_char = *(ctx->cur_ch_ + real_data_len);
if (',' == cur_char) {
continuous_comma_count++;
if (continuous_comma_count == 2) {
--real_data_len;
stop_flag = TRUE;
} else {
++real_data_len;
}
} else {
continuous_comma_count = 0;
if (is_split_char(cur_char)) {
stop_flag = TRUE;
} else {
if (!isdigit(cur_char)) {
ret = 1; //ORA-01858: a non-numeric character was found where a numeric was expected
} else {
temp_value *= 10;
temp_value += cur_char - '0';
++real_data_len;
++digits_len;
}
}
}
}
if (0 == ret) {
if (0 != (ret = check_int_value_length(ctx, expected_len, real_data_len))) {
} else {
*value_len = real_data_len;
*result = temp_value;
}
}
return (ret);
}
int match_int_value_with_sign(struct ObDFMParseCtx *ctx,
const int64_t expected_len,
int64_t *value_len,
int32_t *result,
int32_t value_sign)
{
//only unsigned int
int ret = 0;
int32_t temp_value = 0;
int64_t real_data_len = 0;
int64_t date_max_len = 0;
if (!(ctx->cur_ch_ != NULL && ctx->remain_len_ > 0) || (expected_len < 0)
|| (value_sign != -1 && value_sign != 1)) {
ret = 1;
} else if (!isdigit(ctx->cur_ch_[0])) { //check the first char
ret = 1; //ORA-01858: a non-numeric character was found where a numeric was expected
}
date_max_len = MIN(ctx->remain_len_, expected_len);
while (0 == ret
&& real_data_len < date_max_len
&& isdigit(ctx->cur_ch_[real_data_len])) {
int32_t cur_digit = (int32_t)(ctx->cur_ch_[real_data_len] - '0');
if (temp_value * 10LL > INT32_MAX - cur_digit) {
ret = 1;
} else {
temp_value = temp_value * 10 + cur_digit;
++real_data_len;
}
}
if (0 == ret) {
if (0 != (ret = check_int_value_length(ctx, expected_len, real_data_len))) {
} else {
*value_len = real_data_len;
*result = temp_value * value_sign;
}
}
return (ret);
}
int match_int_value(struct ObDFMParseCtx *ctx,
const int64_t expected_len,
int64_t *value_len,
int32_t *result)
{
return match_int_value_with_sign(ctx, expected_len, value_len, result, 1);
}
int match_chars_until_space(struct ObDFMParseCtx *ctx, char **result, int64_t *result_len, int64_t *value_len)
{
int ret = 0;
int32_t str_len = 0;
if (0 == ctx->remain_len_) {
ret = 1;
}
while (0 == ret && str_len < ctx->remain_len_ && !isspace(ctx->cur_ch_[str_len])) {
if (str_len >= *value_len) {
ret = 1;
} else {
++str_len;
}
}
if (0 == ret) {
*result = (char *)ctx->cur_ch_;
*result_len = str_len;
*value_len = str_len;
}
return (ret);
}
int32_t ob_time_to_date(struct ObTime *ob_time)
{
int32_t value = 0;
if (ZERO_DATE == ob_time->parts_[DT_DATE] && !HAS_TYPE_ORACLE(ob_time->mode_)) {
value = ZERO_DATE;
} else {
int32_t days_of_years;
int32_t leap_year_count;
int32_t *parts = ob_time->parts_;
parts[DT_YDAY] = DAYS_UNTIL_MON[IS_LEAP_YEAR(parts[DT_YEAR])][parts[DT_MON] - 1] + parts[DT_MDAY];
days_of_years = (parts[DT_YEAR] - EPOCH_YEAR4) * DAYS_PER_NYEAR;
leap_year_count = LEAP_YEAR_COUNT(parts[DT_YEAR] - 1) - LEAP_YEAR_COUNT(EPOCH_YEAR4 - 1);
value = (int32_t)(days_of_years + leap_year_count + parts[DT_YDAY] - 1);
parts[DT_WDAY] = WDAY_OFFSET[value % DAYS_PER_WEEK ][EPOCH_WDAY];
}
return value;
}
static inline my_bool match_pattern_ignore_case(struct ObDFMParseCtx *ctx, const struct ObTimeConstStr *pattern)
{
my_bool ret_bool = FALSE;
if (ctx->remain_len_ >= pattern->len_) {
ret_bool = (0 == strncasecmp(ctx->cur_ch_, pattern->ptr_, pattern->len_));
} else {
//false
}
return ret_bool;
}
static inline my_bool elem_has_meridian_indicator(OB_BITMAP *flag_bitmap)
{
return ob_bitmap_is_set(flag_bitmap, AM) || ob_bitmap_is_set(flag_bitmap, PM)
|| ob_bitmap_is_set(flag_bitmap, AM2) || ob_bitmap_is_set(flag_bitmap, PM2);
}
int64_t skip_separate_chars_with_limit(struct ObDFMParseCtx *ctx, const int64_t limit, const int64_t except_char)
{
int64_t sep_len = 0;
while (sep_len < ctx->remain_len_ && sep_len < limit
&& is_split_char(ctx->cur_ch_[sep_len])
&& (int64_t)(ctx->cur_ch_[sep_len]) != except_char) {
sep_len++;
}
ctx->cur_ch_ += sep_len;
ctx->remain_len_ -= sep_len;
return sep_len;
}
int64_t skip_separate_chars(struct ObDFMParseCtx *ctx)
{
return skip_separate_chars_with_limit(ctx, MAX_VARCHAR_LENGTH, INT64_MAX);
}
int64_t skip_blank_chars(struct ObDFMParseCtx *ctx)
{
int64_t blank_char_len = 0;
while (blank_char_len < ctx->remain_len_
&& ' ' == ctx->cur_ch_[blank_char_len]) {
blank_char_len++;
}
ctx->cur_ch_ += blank_char_len;
ctx->remain_len_ -= blank_char_len;
return blank_char_len;
}
const char *find_first_separator(struct ObDFMParseCtx *ctx)
{
const char *result = NULL;
int64_t i = 0;
for (; NULL == result && i < ctx->remain_len_; i++) {
if (is_split_char(ctx->cur_ch_[i])) {
result = ctx->cur_ch_ + i;
}
}
return result;
}
static int check_semantic(const DYNAMIC_ARRAY *dfm_elements, OB_BITMAP *flag_bitmap, uint64_t mode)
{
int ret = 0;
int64_t i = 0;
int64_t conflict_group_bitset = 0;
ob_bitmap_clear_all(flag_bitmap);
for (; 0 == ret && i < dfm_elements->elements; ++i) {
struct ObDFMElem *elem = dynamic_element(dfm_elements, i, struct ObDFMElem *);
int64_t flag = elem->elem_flag_;
if (!(flag > INVALID_FLAG && flag < MAX_FLAG_NUMBER)) {
ret = 1;
}
//The following datetime format elements can be used in timestamp and interval format models,
//but not in the original DATE format model: FF, TZD, TZH, TZM, and TZR
if (0 == ret) {
if (flag >= FF1 && flag <= FF && !HAS_TYPE_ORACLE(mode)) {
ret = 1;
} else if (!HAS_TYPE_TIMEZONE(mode) &&
(TZD == flag || TZR ==flag
|| TZH == flag || TZM == flag)) {
ret = 1;
}
}
//check no duplicate elem first
if (0 == ret) {
if ( ob_bitmap_is_set(flag_bitmap, flag)) {
ret = 1; //ORA-01810: format code appears twice
} else {
ob_bitmap_set_bit(flag_bitmap, flag);
}
}
//check conflict in group which the element belongs to
if (0 == ret) {
int64_t conf_group = CONFLICT_GROUP_MAP[flag];
if (conf_group >= 0) {
if (0 != (conflict_group_bitset & (1 << conf_group))) {
ret = 1;
} else {
conflict_group_bitset |= (1 << conf_group);
}
}
}//end if
}//end for
if (0 == ret) {
if ( ob_bitmap_is_set(flag_bitmap, TZM)
&& ! ob_bitmap_is_set(flag_bitmap, TZH)) {
ret = 1;
}
}
return (ret);
}
/* search matched pattern */
int parse_one_elem(struct ObDFMParseCtx *ctx, struct ObDFMElem *elem)
{
int ret = 0;
if (!(ctx->cur_ch_ != NULL && ctx->remain_len_ > 0)) {
ret = 1;
} else {
int64_t winner_flag = INVALID_FLAG;
int64_t max_matched_len = 0;
int64_t flag = 0;
for (;flag < MAX_FLAG_NUMBER; ++flag) {
const struct ObTimeConstStr *pattern = &PATTERNEX[flag];
if (max_matched_len < pattern->len_ && match_pattern_ignore_case(ctx, pattern)) {
winner_flag = flag;
max_matched_len = pattern->len_;
}
}
//uppercase adjust
if (0 == ret) {
if (winner_flag != INVALID_FLAG) {
elem->elem_flag_ = winner_flag;
elem->offset_ = ctx->cur_ch_ - ctx->fmt_str_;
switch (winner_flag) {
case MON:
case MONTH:
case DAY:
case DY:
case AM:
case PM:
case AD:
case BC: {
if (ctx->remain_len_ < 2) {
ret = 1;
} else if (isupper(ctx->cur_ch_[0]) && isupper(ctx->cur_ch_[1])) {
elem->upper_case_mode_ = ALL_CHARACTER;
} else if (isupper(ctx->cur_ch_[0])) {
elem->upper_case_mode_ = ONLY_FIRST_CHARACTER;
} else {
elem->upper_case_mode_ = NON_CHARACTER;
}
break;
}
case AM2:
case PM2:
case AD2:
case BC2: {
if (ctx->remain_len_ < 4) {
ret = 1;
} else if (isupper(ctx->cur_ch_[0])) {
elem->upper_case_mode_ = ALL_CHARACTER;
} else {
elem->upper_case_mode_ = NON_CHARACTER;
}
}
default:
//do nothing
break;
}
ctx->cur_ch_ += max_matched_len;
ctx->remain_len_ -= max_matched_len;
} else {
ret = 1;
}
}
}
return (ret);
}
int parse_datetime_format_string(const char *fmt_str, const int64_t fmt_len, DYNAMIC_ARRAY *array)
{
int ret = 0;
if (fmt_str == NULL || fmt_len == 0) {
//do nothing
} else {
int64_t skipped_len = 0;
struct ObDFMParseCtx parse_ctx;
parse_ctx.fmt_str_ = fmt_str;
parse_ctx.cur_ch_ = fmt_str;
parse_ctx.remain_len_ = fmt_len;
parse_ctx.expected_elem_flag_ = INVALID_FLAG;
parse_ctx.is_matching_by_expected_len_ = FALSE;
while ((0 == ret) && parse_ctx.remain_len_ > 0) {
//skip separate chars
skipped_len = skip_separate_chars(&parse_ctx);
//parse one element from head
if (parse_ctx.remain_len_ > 0) {
struct ObDFMElem value_elem;
value_elem.elem_flag_ = INVALID_FLAG;
value_elem.offset_ = -1;
value_elem.is_single_dot_before_ = FALSE;
value_elem.upper_case_mode_ = NON_CHARACTER;
if((int64_t)(parse_ctx.cur_ch_ - parse_ctx.fmt_str_) > 0) {
value_elem.is_single_dot_before_ = (skipped_len == 1 && '.' == parse_ctx.cur_ch_[-1]);
}
if (0 != (ret = (parse_one_elem(&parse_ctx, &value_elem)))) {
} else if (ma_insert_dynamic(array, &value_elem)) {
ret = 1;
}
}
}
}
return (ret);
}
int special_mode_sprintf(char *buf, const int64_t buf_len, int64_t *pos,
const struct ObTimeConstStr *str, const enum UpperCaseMode mode, int64_t padding)
{
int ret = 0;
if (str->len_ <= 0 || NULL == str->ptr_ || NULL == buf
|| (padding > 0 && padding < str->len_)) {
ret = 1;
} else if (*pos + (padding > 0 ? padding : str->len_) >= buf_len) {
ret = 1;
} else {
int64_t i = 0;
for (i = 0; 0 == ret && i < str->len_; ++i) {
char cur_char = str->ptr_[i];
if ((cur_char >= 'a' && cur_char <= 'z')
|| (cur_char >= 'A' && cur_char <= 'Z')) {
switch (mode) {
case ALL_CHARACTER: {
buf[(*pos)++] = (char)(toupper(cur_char));
break;
}
case ONLY_FIRST_CHARACTER: {
if (i == 0) {
buf[(*pos)++] = (char)(toupper(cur_char));
} else {
buf[(*pos)++] = (char)(tolower(cur_char));
}
break;
}
case NON_CHARACTER: {
buf[(*pos)++] = (char)(tolower(cur_char));
break;
}
default: {
ret = 1;
break;
}
}
} else {
buf[(*pos)++] = cur_char;
}//end if
}//end for
for (i = str->len_; i < padding; ++i) {
buf[(*pos)++] = ' ';
}
}
return (ret);
}
static const char DIGITS[] =
"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
"4041424344454647484950515253545556575859"
"6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899";
char *format_unsigned(struct ObFastFormatInt *ffi, uint64_t value)
{
char *ptr = ffi->buf_ + (MAX_DIGITS10_STR_SIZE - 1);
uint32_t index = 0;
while (value >= 100) {
index = (uint32_t)(value % 100) << 1;
value /= 100;
*--ptr = DIGITS[index + 1];
*--ptr = DIGITS[index];
}
if (value < 10) {
*--ptr = (char)('0' + value);
} else {
index = (uint32_t)(value) << 1;
*--ptr = DIGITS[index + 1];
*--ptr = DIGITS[index];
}
return ptr;
}
static void format_signed(struct ObFastFormatInt *ffi, int64_t value)
{
uint64_t abs_value = (uint64_t)(value);
if (value < 0) {
abs_value = ~abs_value + 1;
ffi->ptr_ = format_unsigned(ffi, abs_value);
*--(ffi->ptr_) = '-';
} else {
ffi->ptr_ = format_unsigned(ffi, abs_value);
}
ffi->len_ = ffi->buf_ - ffi->ptr_ + MAX_DIGITS10_STR_SIZE - 1;
}
int data_fmt_nd(char *buffer, int64_t buf_len, int64_t *pos, const int64_t n, int64_t target)
{
int ret = 0;
if (n <= 0 || target < 0 || target > 999999999) {
ret = 1;
} else if (n > buf_len - *pos) {
ret = 1;
} else {
struct ObFastFormatInt ffi;
memset(&ffi, 0, sizeof(ffi));
format_signed(&ffi, target);
if (ffi.len_ > n) {
ret = 1;
} else {
memset(buffer + *pos, '0', n - ffi.len_);
memcpy(buffer + *pos + n - ffi.len_, ffi.ptr_, ffi.len_);
*pos += n;
}
}
return (ret);
}
static int32_t ob_time_to_week(const struct ObTime *ob_time, ObDTMode mode)
{
const int32_t *parts = ob_time->parts_;
int32_t is_sun_begin = IS_SUN_BEGIN(mode);
int32_t is_zero_begin = IS_ZERO_BEGIN(mode);
int32_t is_ge_4_begin = IS_GE_4_BEGIN(mode);
int32_t week = 0;
if (parts[DT_YDAY] > DAYS_PER_NYEAR - 3 && is_ge_4_begin && !is_zero_begin) {
// maybe the day is in week 1 of next year.
int32_t days_cur_year = DAYS_PER_YEAR[IS_LEAP_YEAR(parts[DT_YEAR])];
int32_t wday_next_yday1 = WDAY_OFFSET[days_cur_year - parts[DT_YDAY] + 1][parts[DT_WDAY]];
int32_t yday_next_week1 = YDAY_WEEK1[wday_next_yday1][is_sun_begin][is_ge_4_begin];
if (parts[DT_YDAY] >= days_cur_year + yday_next_week1) {
week = 1;
}
}
if (0 == week) {
int32_t wday_cur_yday1 = WDAY_OFFSET[(1 - parts[DT_YDAY]) % DAYS_PER_WEEK][parts[DT_WDAY]];
int32_t yday_cur_week1 = YDAY_WEEK1[wday_cur_yday1][is_sun_begin][is_ge_4_begin];
if (parts[DT_YDAY] < yday_cur_week1 && !is_zero_begin) {
// the day is in last week of prev year.
int32_t days_prev_year = DAYS_PER_YEAR[IS_LEAP_YEAR(parts[DT_YEAR] - 1)];
int32_t wday_prev_yday1 = WDAY_OFFSET[(1 - days_prev_year - parts[DT_YDAY]) % DAYS_PER_WEEK][parts[DT_WDAY]];
int32_t yday_prev_week1 = YDAY_WEEK1[wday_prev_yday1][is_sun_begin][is_ge_4_begin];
week = (days_prev_year + parts[DT_YDAY] - yday_prev_week1 + DAYS_PER_WEEK) / DAYS_PER_WEEK;
} else {
week = (parts[DT_YDAY] - yday_cur_week1 + DAYS_PER_WEEK) / DAYS_PER_WEEK;
}
}
return week;
}
int calculate_str_oracle_dfm_length(const struct ObTime *ob_time,
const char *fmt_str, const int64_t fmt_len,
int16_t scale, int64_t *len)
{
int ret = 0;
if (NULL == fmt_str || fmt_len <=0
|| scale > MAX_SCALE_FOR_ORACLE_TEMPORAL) {
ret = 1;
} else {
int64_t last_elem_end_pos = 0;
int64_t i = 0;
int64_t length = 0;
DYNAMIC_ARRAY dfm_elems;
if (scale < 0 ) {
scale = DEFAULT_SCALE_FOR_ORACLE_FRACTIONAL_SECONDS;
}
//1. parse element from format string
if (ma_init_dynamic_array(&dfm_elems, sizeof(struct ObDFMElem), COMMON_ELEMENT_NUMBER, 0)) {
ret = 1;
} else if (0 != (ret = parse_datetime_format_string(fmt_str, fmt_len, &dfm_elems))) {
}
//2. print each element
for (; 0 == ret && i < dfm_elems.elements; ++i) {
struct ObDFMElem *elem = dynamic_element(&dfm_elems, i, struct ObDFMElem *);
//element is valid
if (!(elem->elem_flag_ > INVALID_FLAG && elem->elem_flag_ < MAX_FLAG_NUMBER && elem->offset_ >= 0)) {
ret = 1;
}
//print separate chars between elements
if (0 == ret) {
int64_t separate_chars_len = elem->offset_ - last_elem_end_pos;
if (separate_chars_len > 0) {
length += separate_chars_len;
}
last_elem_end_pos = elem->offset_ + PATTERNEX[elem->elem_flag_].len_;
}
//print current elem
if (0 == ret) {
switch (elem->elem_flag_) {
case AD:
case BC: { //TODO wjh: NLS_LANGUAGE
const struct ObTimeConstStr *target_str = ob_time->parts_[DT_YEAR] > 0 ? &PATTERNEX[AD] : &PATTERNEX[BC];
length += target_str->len_;
break;
}
case AD2:
case BC2: { //TODO wjh: NLS_LANGUAGE
const struct ObTimeConstStr *str = ob_time->parts_[DT_YEAR] > 0 ? &PATTERNEX[AD2] : &PATTERNEX[BC2];
length += str->len_;
break;
}
case CC: {
length += 2;
break;
}
case SCC: {
length += 2;
break;
}
case D: {
length += 1;
break;
}
case DAY: { //TODO wjh: NLS_LANGUAGE
length += MAX_WDAY_NAME_LENGTH;
break;
}
case DD: {
length += 2;
break;
}
case DDD: {
length += 3;
break;
}
case DY: { //TODO wjh: 1. NLS_LANGUAGE
const struct ObTimeConstStr *day_str = &WDAY_ABBR_NAMES[ob_time->parts_[DT_WDAY]];
length += day_str->len_;
break;
}
case DS: { //TODO wjh: 1. NLS_TERRITORY 2. NLS_LANGUAGE
length += 2 + 1 + 2 + 1 + 1;
break;
}
case DL: { //TODO wjh: 1. NLS_DATE_FORMAT 2. NLS_TERRITORY 3. NLS_LANGUAGE
const struct ObTimeConstStr *wday_str = &WDAY_NAMES[ob_time->parts_[DT_WDAY]];
const struct ObTimeConstStr *mon_str = &MON_NAMES[ob_time->parts_[DT_MON]];
length += wday_str->len_ + 2 + mon_str->len_ + 1 + 2 + 2 + 1;
break;
}
case FF: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (0 == scale) {
//print nothing
} else {
length += scale;
}
break;
}
case FF1:
case FF2:
case FF3:
case FF4:
case FF5:
case FF6:
case FF7:
case FF8:
case FF9: {
int64_t scale = elem->elem_flag_ - FF1 + 1;
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
length += scale;
}
break;
}
case HH:
case HH12: {
length += 2;
break;
}
case HH24: {
length += 2;
break;
}
case IW: {
length += 2;
break;
}
case MI: {
length += 2;
break;
}
case MM: {
length += 2;
break;
}
case MONTH: {
length += MAX_MON_NAME_LENGTH;
break;
}
case MON: {
const struct ObTimeConstStr *mon_str = &MON_ABBR_NAMES[ob_time->parts_[DT_MON]];
length += mon_str->len_;
break;
}
case AM:
case PM: {
const struct ObTimeConstStr *str = ob_time->parts_[DT_HOUR] >= 12 ?
&PATTERNEX[PM] : &PATTERNEX[AM];
length += str->len_;
break;
}
case AM2:
case PM2: {
const struct ObTimeConstStr *str = ob_time->parts_[DT_HOUR] >= 12 ?
&PATTERNEX[PM2] : &PATTERNEX[AM2];
length += str->len_;
break;
}
case Q: {
length += 1;
break;
}
case RR: {
length += 2;
break;
}
case RRRR: {
length += 4;
break;
}
case SS: {
length += 2;
break;
}
case SSSSS: {
length += 5;
break;
}
case WW: { //the first complete week of a year
length += 2;
break;
}
case W: { //the first complete week of a month
length += 1;
break;
}
case YGYYY: {
length += 1 + 1 + 3;
break;
}
case YEAR: {
ret = 1;
break;
}
case SYEAR: {
ret = 1;
break;
}
case SYYYY: {
length += 5;
break;
}
case YYYY:
case IYYY: {
length += 4;
break;
break;
}
case YYY:
case IYY: {
length += 3;
break;
}
case YY:
case IY: {
length += 2;
break;
}
case Y:
case I: {
length += 1;
break;
}
case TZD: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (ob_time->time_zone_id_ != -1) {
length += strlen(ob_time->tzd_abbr_);
} else {
//do nothing
}
break;
}
case TZR: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (ob_time->time_zone_id_ != -1) {
length += strlen(ob_time->tz_name_);
} else {
length += 6;
}
break;
}
case TZH: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
length += 3;
}
break;
}
case TZM: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
length += 2;
}
break;
}
case X: {
length += 1;
break;
}
default: {
ret = 1;
break;
}
}
} //end if
}//end for
if (0 == ret) {
//print the rest separate chars
int64_t separate_chars_len = fmt_len - last_elem_end_pos;
if (separate_chars_len > 0) {
length += separate_chars_len;
}
}
ma_delete_dynamic(&dfm_elems);
*len = length;
}//end if
return (ret);
}
int ob_time_to_str_oracle_dfm(const struct ObTime *ob_time,
const char *fmt_str, const int64_t fmt_len,
int16_t scale,
char *buf, int64_t buf_len,
int64_t *pos)
{
int ret = 0;
if (NULL == buf || buf_len <= 0
|| NULL == fmt_str || fmt_len <=0
|| scale > MAX_SCALE_FOR_ORACLE_TEMPORAL) {
ret = 1;
} else {
int64_t last_elem_end_pos = 0;
int64_t i = 0;
DYNAMIC_ARRAY dfm_elems;
if (scale < 0 ) {
scale = DEFAULT_SCALE_FOR_ORACLE_FRACTIONAL_SECONDS;
}
//1. parse element from format string
if (ma_init_dynamic_array(&dfm_elems, sizeof(struct ObDFMElem), COMMON_ELEMENT_NUMBER, 0)) {
ret = 1;
} else if (0 != (ret = parse_datetime_format_string(fmt_str, fmt_len, &dfm_elems))) {
}
//2. print each element
for (; 0 == ret && i < dfm_elems.elements; ++i) {
struct ObDFMElem *elem = dynamic_element(&dfm_elems, i, struct ObDFMElem *);
//element is valid
if (!(elem->elem_flag_ > INVALID_FLAG && elem->elem_flag_ < MAX_FLAG_NUMBER && elem->offset_ >= 0)) {
ret = 1;
}
//print separate chars between elements
if (0 == ret) {
int64_t separate_chars_len = elem->offset_ - last_elem_end_pos;
if (separate_chars_len > 0) {
ret = databuff_printf(buf, buf_len, pos, "%.*s", (int32_t)(separate_chars_len),
fmt_str + last_elem_end_pos);
}
last_elem_end_pos = elem->offset_ + PATTERNEX[elem->elem_flag_].len_;
}
//print current elem
if (0 == ret) {
switch (elem->elem_flag_) {
case AD:
case BC: { //TODO wjh: NLS_LANGUAGE
const struct ObTimeConstStr *target_str = ob_time->parts_[DT_YEAR] > 0 ? &PATTERNEX[AD] : &PATTERNEX[BC];
ret = special_mode_sprintf(buf, buf_len, pos, target_str, elem->upper_case_mode_, -1);
break;
}
case AD2:
case BC2: { //TODO wjh: NLS_LANGUAGE
const struct ObTimeConstStr *str = ob_time->parts_[DT_YEAR] > 0 ? &PATTERNEX[AD2] : &PATTERNEX[BC2];
ret = special_mode_sprintf(buf, buf_len, pos, str, elem->upper_case_mode_, -1);
break;
}
case CC: {
ret = databuff_printf(buf, buf_len, pos, "%02d", (abs(ob_time->parts_[DT_YEAR]) + 99) / 100);
break;
}
case SCC: {
char symbol = ob_time->parts_[DT_YEAR] > 0 ? ' ' : '-';
ret = databuff_printf(buf, buf_len, pos, "%c%02d", symbol, (abs(ob_time->parts_[DT_YEAR]) + 99) / 100);
break;
}
case D: {
ret = databuff_printf(buf, buf_len, pos, "%d", ob_time->parts_[DT_WDAY] % 7 + 1);
break;
}
case DAY: { //TODO wjh: NLS_LANGUAGE
const struct ObTimeConstStr *day_str = &WDAY_NAMES[ob_time->parts_[DT_WDAY]];
ret = special_mode_sprintf(buf, buf_len, pos, day_str, elem->upper_case_mode_, MAX_WDAY_NAME_LENGTH);
break;
}
case DD: {
ret = databuff_printf(buf, buf_len, pos, "%02d", ob_time->parts_[DT_MDAY]);
break;
}
case DDD: {
ret = databuff_printf(buf, buf_len, pos, "%03d", ob_time->parts_[DT_YDAY]);
break;
}
case DY: { //TODO wjh: 1. NLS_LANGUAGE
const struct ObTimeConstStr *day_str = &WDAY_ABBR_NAMES[ob_time->parts_[DT_WDAY]];
ret = special_mode_sprintf(buf, buf_len, pos, day_str, elem->upper_case_mode_, -1);
break;
}
case DS: { //TODO wjh: 1. NLS_TERRITORY 2. NLS_LANGUAGE
ret = databuff_printf(buf, buf_len, pos, "%02d/%02d/%d",
ob_time->parts_[DT_MON], ob_time->parts_[DT_MDAY], ob_time->parts_[DT_YEAR]);
break;
}
case DL: { //TODO wjh: 1. NLS_DATE_FORMAT 2. NLS_TERRITORY 3. NLS_LANGUAGE
const struct ObTimeConstStr *wday_str = &WDAY_NAMES[ob_time->parts_[DT_WDAY]];
const struct ObTimeConstStr *mon_str = &MON_NAMES[ob_time->parts_[DT_MON]];
ret = databuff_printf(buf, buf_len, pos, "%.*s, %.*s %02d, %d",
wday_str->len_, wday_str->ptr_,
mon_str->len_, mon_str->ptr_,
ob_time->parts_[DT_MDAY], ob_time->parts_[DT_YEAR]);
break;
}
case FF: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (0 == scale) {
//print nothing
} else {
ret = data_fmt_nd(buf, buf_len, pos, scale,
ob_time->parts_[DT_USEC] / power_of_10[MAX_SCALE_FOR_ORACLE_TEMPORAL - scale]);
}
break;
}
case FF1:
case FF2:
case FF3:
case FF4:
case FF5:
case FF6:
case FF7:
case FF8:
case FF9: {
int64_t scale = elem->elem_flag_ - FF1 + 1;
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
ret = data_fmt_nd(buf, buf_len, pos, scale,
ob_time->parts_[DT_USEC] / power_of_10[MAX_SCALE_FOR_ORACLE_TEMPORAL - scale]);
}
break;
}
case HH:
case HH12: {
int32_t h = ob_time->parts_[DT_HOUR] % 12;
if (0 == h) {
h = 12;
}
ret = databuff_printf(buf, buf_len, pos, "%02d", h);
break;
}
case HH24: {
int32_t h = ob_time->parts_[DT_HOUR];
ret = databuff_printf(buf, buf_len, pos, "%02d", h);
break;
}
case IW: {
ret = databuff_printf(buf, buf_len, pos, "%02d", ob_time_to_week(ob_time, WEEK_MODE[3]));
break;
}
case J: {
const int32_t base_julian_day = 2378497; // julian day of 1800-01-01
const int32_t base_date = -62091; //ob_time.parts_[DT_DATE] of 1800-01-01
if (ob_time->parts_[DT_DATE] < base_date) {
ret = 1;
} else {
int32_t julian_day = base_julian_day + ob_time->parts_[DT_DATE] - base_date;
ret = databuff_printf(buf, buf_len, pos, "%07d", julian_day);
}
break;
}
case MI: {
ret = databuff_printf(buf, buf_len, pos, "%02d", ob_time->parts_[DT_MIN]);
break;
}
case MM: {
ret = databuff_printf(buf, buf_len, pos, "%02d", ob_time->parts_[DT_MON]);
break;
}
case MONTH: {
const struct ObTimeConstStr *mon_str = &MON_NAMES[ob_time->parts_[DT_MON]];
ret = special_mode_sprintf(buf, buf_len, pos, mon_str, elem->upper_case_mode_, MAX_MON_NAME_LENGTH);
break;
}
case MON: {
const struct ObTimeConstStr *mon_str = &MON_ABBR_NAMES[ob_time->parts_[DT_MON]];
ret = special_mode_sprintf(buf, buf_len, pos, mon_str, elem->upper_case_mode_, -1);
break;
}
case AM:
case PM: {
const struct ObTimeConstStr *str = ob_time->parts_[DT_HOUR] >= 12 ? &PATTERNEX[PM] : &PATTERNEX[AM];
ret = special_mode_sprintf(buf, buf_len, pos, str, elem->upper_case_mode_, -1);
break;
}
case AM2:
case PM2: {
const struct ObTimeConstStr *str = ob_time->parts_[DT_HOUR] >= 12 ? &PATTERNEX[PM2] : &PATTERNEX[AM2];
ret = special_mode_sprintf(buf, buf_len, pos, str, elem->upper_case_mode_, -1);
break;
}
case Q: {
ret = databuff_printf(buf, buf_len, pos, "%d", (ob_time->parts_[DT_MON] + 2) / 3);
break;
}
case RR: {
ret = databuff_printf(buf, buf_len, pos, "%02d", (ob_time->parts_[DT_YEAR]) % 100);
break;
}
case RRRR: {
ret = databuff_printf(buf, buf_len, pos, "%04d", ob_time->parts_[DT_YEAR]);
break;
}
case SS: {
ret = databuff_printf(buf, buf_len, pos, "%02d", ob_time->parts_[DT_SEC]);
break;
}
case SSSSS: {
ret = databuff_printf(buf, buf_len, pos, "%05d",
ob_time->parts_[DT_HOUR] * 3600 + ob_time->parts_[DT_MIN] * 60 + ob_time->parts_[DT_SEC]);
break;
}
case WW: { //the first complete week of a year
ret = databuff_printf(buf, buf_len, pos, "%02d", (ob_time->parts_[DT_YDAY] - 1) / 7 + 1);
break;
}
case W: { //the first complete week of a month
ret = databuff_printf(buf, buf_len, pos, "%d", (ob_time->parts_[DT_MDAY] - 1) / 7 + 1);
break;
}
case YGYYY: {
ret = databuff_printf(buf, buf_len, pos, "%d,%03d",
abs(ob_time->parts_[DT_YEAR]) / 1000, abs(ob_time->parts_[DT_YEAR]) % 1000);
break;
}
case YEAR: {
ret = 1;
break;
}
case SYEAR: {
ret = 1;
break;
}
case SYYYY: {
const char* fmt_str = ob_time->parts_[DT_YEAR] < 0 ? "-%04d" : " %04d";
ret = databuff_printf(buf, buf_len, pos, fmt_str, abs(ob_time->parts_[DT_YEAR]));
break;
}
case YYYY:
case IYYY: {
ret = databuff_printf(buf, buf_len, pos, "%04d", abs(ob_time->parts_[DT_YEAR]));
break;
}
case YYY:
case IYY: {
ret = databuff_printf(buf, buf_len, pos, "%03d", abs(ob_time->parts_[DT_YEAR] % 1000));
break;
}
case YY:
case IY: {
ret = databuff_printf(buf, buf_len, pos, "%02d", abs(ob_time->parts_[DT_YEAR] % 100));
break;
}
case Y:
case I: {
ret = databuff_printf(buf, buf_len, pos, "%01d", abs(ob_time->parts_[DT_YEAR] % 10));
break;
}
case TZD: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (ob_time->time_zone_id_ != -1) {
ret = databuff_printf(buf, buf_len, pos, "%.*s", (int)strlen(ob_time->tzd_abbr_), ob_time->tzd_abbr_);
} else {
//do nothing
}
break;
}
case TZR: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else if (ob_time->time_zone_id_ != -1) {
ret = databuff_printf(buf, buf_len, pos, "%.*s", (int)strlen(ob_time->tz_name_), ob_time->tz_name_);
} else {
const char* fmt_str = ob_time->parts_[DT_OFFSET_MIN] < 0 ? "-%02d:%02d" : "+%02d:%02d";
ret = databuff_printf(buf, buf_len, pos, fmt_str,
abs(ob_time->parts_[DT_OFFSET_MIN]) / 60, abs(ob_time->parts_[DT_OFFSET_MIN]) % 60);
}
break;
}
case TZH: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
const char* fmt_str = ob_time->parts_[DT_OFFSET_MIN] < 0 ? "-%02d" : "+%02d";
ret = databuff_printf(buf, buf_len, pos, fmt_str, abs(ob_time->parts_[DT_OFFSET_MIN]) / 60);
}
break;
}
case TZM: {
if (!HAS_TYPE_ORACLE(ob_time->mode_)) {
ret = 1;
} else {
ret = databuff_printf(buf, buf_len, pos, "%02d", abs(ob_time->parts_[DT_OFFSET_MIN]) % 60);
}
break;
}
case X: {
ret = databuff_printf(buf, buf_len, pos, ".");
break;
}
default: {
ret = 1;
break;
}
} //end switch
if (0 != ret) {
}
} //end if
}//end for
if (0 == ret) {
//print the rest separate chars
int64_t separate_chars_len = fmt_len - last_elem_end_pos;
if (separate_chars_len > 0) {
if (0 != (ret = databuff_printf(buf, buf_len, pos, "%.*s", (int32_t)(separate_chars_len),
fmt_str + last_elem_end_pos))) {
}
}
}
ma_delete_dynamic(&dfm_elems);
}//end if
return (ret);
}
//TODO be delete, not to use
/**
* @brief convert string to ob_time struct according to oracle datetime format model
* @param in: str input string
* @param in: format format string
* @param out: ob_time memory struct of datetime
* @param out: scale scale of fractional seconds
*/
int str_to_ob_time_oracle_dfm(const char *str, const int64_t str_len,
const char *fmt_str, const int64_t fmt_len,
struct ObTime *ob_time,
int16_t scale)
{
int ret = 0;
if (NULL == str || str_len <= 0
|| NULL == fmt_str || fmt_len <=0
|| scale > MAX_SCALE_FOR_ORACLE_TEMPORAL) {
ret = 1;
} else {
memset(ob_time, 0, sizeof(struct ObTime));
ob_time->mode_ |= DT_TYPE_DATETIME;
ob_time->mode_ |= DT_TYPE_ORACLE;
ob_time->mode_ |= DT_TYPE_TIMEZONE;
}
if (0 == ret) {
DYNAMIC_ARRAY dfm_elems;
OB_BITMAP elem_flags = {.bitmap = NULL, .n_bits = 0};
int32_t temp_tzh_value = -1; //positive value is legal
int32_t temp_tzm_value = -1; //positive value is legal
int32_t temp_tz_factor = 0;
int32_t tz_hour = 0; //will be negetive when time zone offset < 0
int32_t tz_min = 0; //will be negetive when time zone offset < 0
//1. parse element from format string
if (ma_init_dynamic_array(&dfm_elems, sizeof(struct ObDFMElem), COMMON_ELEMENT_NUMBER, 0)) {
ret = 1;
} else if (ob_bitmap_init(&elem_flags, MAX_FLAG_NUMBER)) {
ret = 1;
} else if (0 != (ret = parse_datetime_format_string(fmt_str, fmt_len, &dfm_elems))) {
} else if (0 != (ret = check_semantic(&dfm_elems, &elem_flags, ob_time->mode_))) {
} else {
//3. go through each element, set and check conflict for ob_time parts: Year, Month, Day, Hour, Minute, Second
int64_t last_elem_end_pos = 0;
int64_t conflict_part_bitset = 0;
int64_t elem_idx = 0;
int64_t input_sep_len = 0;
int64_t part_blank1_len = 0;
int64_t part_sep_len = 0;
int64_t part_blank2_len = 0;
int64_t format_sep_len = 0;
//static_assert((1 << TOTAL_PART_CNT) < INT64_MAX, "for time_part_conflict_bitset");
int32_t yday_temp_value = ZERO_DATE; //as invalid value
int32_t wday_temp_value = ZERO_DATE; //as invalid value
int32_t date_temp_value = ZERO_DATE; //as invalid value
int32_t hh12_temp_value = ZERO_TIME;
int32_t julian_year_value = ZERO_DATE; //as invalid value
my_bool is_after_noon = FALSE;
my_bool is_before_christ = FALSE;
my_bool has_digit_tz_in_TZR = FALSE;
int64_t first_non_space_sep_char = INT64_MAX;
int64_t ignore_fs_flag = FALSE;
struct ObDFMParseCtx ctx;
ctx.fmt_str_ = str;
ctx.cur_ch_ = str;
ctx.remain_len_ = str_len;
ctx.expected_elem_flag_ = INVALID_FLAG;
ctx.is_matching_by_expected_len_ = FALSE;
for (elem_idx = 0; 0 == ret && elem_idx < dfm_elems.elements; ++elem_idx) {
struct ObDFMElem *elem = dynamic_element(&dfm_elems, elem_idx, struct ObDFMElem *);
//element is valid
if (!(elem->elem_flag_ > INVALID_FLAG && elem->elem_flag_ < MAX_FLAG_NUMBER && elem->offset_ >= 0)) {
ret = 1;
} else {
}
//1. check separate chars and skip blank chars first
if (0 == ret) {
//get format sep chars len
format_sep_len = elem->offset_ - last_elem_end_pos;
last_elem_end_pos = elem->offset_ + PATTERNEX[elem->elem_flag_].len_;
//parse input string and skip them
part_blank1_len = skip_blank_chars(&ctx);
//The # of skipped non-blank chars is according to format_str
first_non_space_sep_char = (0 == ctx.remain_len_) ? INT64_MAX : ctx.cur_ch_[0];
if (X == elem->elem_flag_) {
/* 特殊情况, 不考虑X前面的非空白分隔符 */
part_sep_len = 0;
} else {
part_sep_len = skip_separate_chars_with_limit(&ctx, format_sep_len, INT64_MAX);
}
part_blank2_len = skip_blank_chars(&ctx);
input_sep_len = part_blank1_len + part_sep_len + part_blank2_len;
}
if (0 == ret && (0 == ctx.remain_len_)) {
break; //if all the input chars has beeen processed, break this loop
}
//2. next, parse the current element
if (0 == ret) {
int64_t parsed_elem_len = 0;
const int64_t expected_elem_len = EXPECTED_MATCHING_LENGTH[elem->elem_flag_];
ctx.expected_elem_flag_ = elem->elem_flag_;
ctx.is_matching_by_expected_len_ = (format_sep_len > 0 && input_sep_len == 0);
switch (elem->elem_flag_) {
case AD:
case BC:
case AD2:
case BC2: { //TODO wjh: NLS_LANGUAGE
my_bool is_with_dot = (AD2 == elem->elem_flag_|| BC2 == elem->elem_flag_);
my_bool is_ad = FALSE;
my_bool is_bc = FALSE;
parsed_elem_len = is_with_dot ? PATTERNEX[AD2].len_ : PATTERNEX[AD].len_;
is_ad = match_pattern_ignore_case(&ctx, is_with_dot ?
&PATTERNEX[AD2] : &PATTERNEX[AD]);
is_bc = match_pattern_ignore_case(&ctx, is_with_dot ?
&PATTERNEX[BC2] : &PATTERNEX[BC]);
if (!is_ad && !is_bc) {
ret = 1;
} else {
is_before_christ = is_bc;
}
break;
}
case D: {
int32_t wday = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &wday))) {
} else if (0 != (ret = check_validate(&LIMITER_WEEK_DAY, wday))) {
} else {
//oracle numbered sunday as 1 in territory of CHINA
//TODO wjh: hard code for now, need look up NLS_TERRITORIES
wday_temp_value = (wday + 5) % 7 + 1;
}
break;
}
case DY:
case DAY: { //TODO wjh: NLS_LANGUAGE NLS_TERRITORIES
int32_t wday = 0;
for (wday = 1; wday <= DAYS_PER_WEEK; ++wday) {
const struct ObTimeConstStr *day_str = (elem->elem_flag_ == DAY) ? &WDAY_NAMES[wday] : &WDAY_ABBR_NAMES[wday];
if (match_pattern_ignore_case(&ctx, day_str)) {
parsed_elem_len = day_str->len_;
break;
}
}
if (0 != (ret = check_validate(&LIMITER_WEEK_DAY, wday))) {
} else {
wday_temp_value = wday;
}
break;
}
case DD: {
int32_t mday = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &mday))) {
} else if (0 != (ret = check_validate(&LIMITER_MONTH_DAY, mday))) {
} else {
//may conflict with DDD
ret = set_ob_time_part_directly(ob_time, &conflict_part_bitset, DT_MDAY, mday);
}
break;
}
case DDD: {
int32_t yday = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &yday))) {
} else if (0 != (ret = check_validate(&LIMITER_YEAR_DAY, yday))) {
} else {
yday_temp_value = yday;
}
break;
}
case DS: { //TODO wjh: impl it NEED NLS_DATE_FORMAT NLS_TERRITORY NLS_LANGUAGE
ret = 1;
break;
}
case DL: { //TODO wjh: impl it NEED NLS_DATE_FORMAT NLS_TERRITORY NLS_LANGUAGE
ret = 1;
break;
}
case FF:
case FF1:
case FF2:
case FF3:
case FF4:
case FF5:
case FF6:
case FF7:
case FF8:
case FF9: {
int32_t usec = 0;
//format string has '.' or 'X', but input string does not contain '.'
//do nothing, skip element FF and revert ctx by the length of parsed chars
if (ignore_fs_flag) {
ctx.cur_ch_ -= (part_blank1_len + part_sep_len + part_blank2_len);
ctx.remain_len_ += (part_blank1_len + part_sep_len + part_blank2_len);
} else if (elem->is_single_dot_before_ && '.' != first_non_space_sep_char) {
ctx.cur_ch_ -= (part_sep_len + part_blank2_len);
ctx.remain_len_ += (part_sep_len + part_blank2_len);
} else if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &usec))) {
} else {
scale = (int16_t)(parsed_elem_len);
usec = (int32_t)(usec * power_of_10[MAX_SCALE_FOR_ORACLE_TEMPORAL - parsed_elem_len]);
ob_time->parts_[DT_USEC] = usec;
}
break;
}
case TZH:
case TZM: {
if ( ob_bitmap_is_set(&elem_flags, TZR) || ob_bitmap_is_set(&elem_flags, TZD)) {
ret = 1;
} else {
int32_t value = 0;
int32_t local_tz_factor = 1;
/*
* SQL> alter session set NLS_TIMESTAMP_TZ_FORMAT='DD-MON-RR HH.MI.SS AM TZH:TZM';
* SQL> alter session set time_zone='Asia/Shanghai';
* SQL> select cast('01-SEP-20 11.11.11' as timestamp with time zone) from dual;
* 01-SEP-20 11.11.11 AM +08:00
*/
ob_time->is_tz_name_valid_ = FALSE;
if (TZH == elem->elem_flag_) {
if (is_sign_char(ctx.cur_ch_[0])) {
local_tz_factor = ('-' == ctx.cur_ch_[0] ? -1 : 1);
ctx.cur_ch_ += 1;
ctx.remain_len_ -= 1;
} else {
if (((int64_t)(ctx.cur_ch_ - ctx.fmt_str_)) > 0 && input_sep_len > format_sep_len) {
//if the input valid separate chars > format separate chars
//the superfluous '-' will be regarded as minus sign
local_tz_factor = ((int64_t)('-') == ctx.cur_ch_[-1] ? -1 : 1);
}
}
temp_tz_factor = local_tz_factor; //1 or -1, but never be 0
}
if (0 == ctx.remain_len_) {
//do nothing
} else if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &value))) {
} else if (0 != (ret = (elem->elem_flag_ == TZH ? check_validate(&LIMITER_TIMEZONE_HOUR_ABS, value) : check_validate(&LIMITER_TIMEZONE_MIN_ABS, value)))) {
} else {
if (elem->elem_flag_ == TZH) {
temp_tzh_value = value;
} else {
temp_tzm_value = value;
}
}
}
break;
}
case TZR: {
if ( ob_bitmap_is_set(&elem_flags, TZH) || ob_bitmap_is_set(&elem_flags, TZM)) {
ret = 1;
} else {
int32_t local_tz_factor = 1;
if (isdigit(ctx.cur_ch_[0]) || is_sign_char(ctx.cur_ch_[0])) { //case1: digits
int32_t tmp_tz_hour = 0;
int32_t tmp_tz_min = 0;
char *digits_timezone;
int64_t digits_timezone_len;
if (is_sign_char(ctx.cur_ch_[0])) {
local_tz_factor = ('-' == ctx.cur_ch_[0] ? -1 : 1);
ctx.cur_ch_ += 1;
ctx.remain_len_ -= 1;
} else if (part_blank1_len + part_sep_len > format_sep_len
&& is_sign_char(ctx.cur_ch_[-1])) {
local_tz_factor = ('-' == ctx.cur_ch_[-1] ? -1 : 1);
}
parsed_elem_len = UNKNOWN_LENGTH_OF_ELEMENT;
if (!(0 == ctx.remain_len_)) {
ob_time->is_tz_name_valid_ = FALSE;
}
if (0 == ctx.remain_len_) {
//do nothing
} else if (0 != (ret = match_chars_until_space(&ctx, &digits_timezone, &digits_timezone_len, &parsed_elem_len))) {
//do nothing
} else {
const char *local_sep = NULL;
struct ObDFMParseCtx local_ctx;
local_ctx.fmt_str_ = digits_timezone;
local_ctx.cur_ch_ = digits_timezone;
local_ctx.remain_len_ = digits_timezone_len;
local_ctx.expected_elem_flag_ = INVALID_FLAG;
local_ctx.is_matching_by_expected_len_ = FALSE;
local_sep = find_first_separator(&local_ctx);
if (NULL == local_sep) {
} else {
int64_t hour_expected_len = local_sep - digits_timezone;
int64_t local_parsed_len = 0;
if (0 != (ret = match_int_value_with_sign(&local_ctx, hour_expected_len, &local_parsed_len,
&tmp_tz_hour, local_tz_factor))) {
} else if (0 != (ret = check_validate(&LIMITER_TIMEZONE_HOUR_ABS, tmp_tz_hour))) {
} else if (hour_expected_len != local_parsed_len) {
ret = 1; //invalid time zone
} else {
local_ctx.cur_ch_ += hour_expected_len + 1;
local_ctx.remain_len_ -= hour_expected_len + 1;
if (0 == local_ctx.remain_len_) {
has_digit_tz_in_TZR = TRUE;
tz_hour = tmp_tz_hour;
tz_min = tmp_tz_min;
} else if (0 != (ret = match_int_value_with_sign(&local_ctx, parsed_elem_len - hour_expected_len - 1,
&local_parsed_len, &tmp_tz_min, local_tz_factor))) {
} else if (0 != (ret = check_validate(&LIMITER_TIMEZONE_MIN_ABS, tmp_tz_min))) {
} else if (parsed_elem_len != hour_expected_len + local_parsed_len + 1) {
ret = 1; //invalid time zone
} else {
has_digit_tz_in_TZR = TRUE;
tz_hour = tmp_tz_hour;
tz_min = tmp_tz_min;
}
}
}
}
} else { //case2: strings
char *tzr_str;
int64_t tzr_str_len;
parsed_elem_len = OB_MAX_TZ_NAME_LEN - 1;
if (0 != (ret = match_chars_until_space(&ctx, &tzr_str, &tzr_str_len, &parsed_elem_len))) {
} else {
memcpy(ob_time->tz_name_, tzr_str, tzr_str_len);
ob_time->tz_name_[tzr_str_len] = '\0';
ob_time->is_tz_name_valid_ = TRUE;
}
}
}
break;
}
case TZD: {
if ( ob_bitmap_is_set(&elem_flags, TZH) || ob_bitmap_is_set(&elem_flags, TZM)) {
ret = 1;
} else if (has_digit_tz_in_TZR) {
ret = 1;
} else {
char *tzd_str;
int64_t tzd_str_len;
parsed_elem_len = OB_MAX_TZ_ABBR_LEN - 1;
if (0 != (ret = match_chars_until_space(&ctx, &tzd_str, &tzd_str_len, &parsed_elem_len))) {
} else {
memcpy(ob_time->tzd_abbr_, tzd_str, tzd_str_len);
ob_time->tzd_abbr_[tzd_str_len] = '\0';
}
}
break;
}
case J: {
const int32_t base_julian_day = 2378497; // julian day of 1800-01-01
const int32_t base_date = -62091; //ob_time.parts_[DT_DATE] of 1800-01-01
int32_t julian_day = 0;
int32_t ob_time_date = 0;
struct ObTime tmp_ob_time;
if (0 != (ret = match_int_value(&ctx, expected_elem_len,
&parsed_elem_len, &julian_day))) {
} else if (0 != (ret = check_validate(&LIMITER_JULIAN_DATE, julian_day))) {
} else if (julian_day < base_julian_day) {
ret = 1;
} else {
ob_time_date = julian_day - base_julian_day + base_date;
if (0 != (ret = date_to_ob_time(ob_time_date, &tmp_ob_time))) {
} else if (0 != (ret = set_ob_time_year_may_conflict(ob_time, &julian_year_value,
tmp_ob_time.parts_[DT_YEAR],
tmp_ob_time.parts_[DT_YEAR],
TRUE /* overwrite */))) {
} else {
yday_temp_value = tmp_ob_time.parts_[DT_YDAY];
}
}
break;
}
case HH:
case HH12: {
int32_t hour = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &hour))) {
} else if (0 != (ret = check_validate(&LIMITER_HOUR12, hour))) {
} else if (!elem_has_meridian_indicator(&elem_flags)) {
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_HOUR, hour);
} else {
hh12_temp_value = hour;
}
break;
}
case HH24: {
int32_t hour = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &hour))) {
} else if (0 != (ret = check_validate(&LIMITER_HOUR24, hour))) {
} else if (elem_has_meridian_indicator(&elem_flags)) {
ret = 1;
} else {
//may conflict with SSSSS
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_HOUR, hour);
}
break;
}
case MI: {
int32_t min = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &min))) {
} else if (0 != (ret = check_validate(&LIMITER_MINUTE, min))) {
} else {
//may conflict with SSSSS
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_MIN, min);
}
break;
}
case MM: {
int32_t mon = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &mon))) {
} else if (0 != (ret = check_validate(&LIMITER_MONTH_DAY, mon))) {
} else {
//may conflict with DDD
ret = set_ob_time_part_directly(ob_time, &conflict_part_bitset, DT_MON, mon);
}
break;
}
case MON:
case MONTH: {
int32_t mon = 0;
for (mon = LIMITER_MONTH.MIN; mon <= LIMITER_MONTH.MAX; ++mon) {
const struct ObTimeConstStr *mon_str = (elem->elem_flag_ == MONTH) ? &MON_NAMES[mon] : &MON_ABBR_NAMES[mon];
if (match_pattern_ignore_case(&ctx, mon_str)) {
parsed_elem_len = mon_str->len_;
break;
}
}
if (0 != (ret = check_validate(&LIMITER_MONTH, mon))) {
} else {
//may conflict with DDD
ret = set_ob_time_part_directly(ob_time, &conflict_part_bitset, DT_MON, mon);
}
break;
}
case AM:
case PM:
case AM2:
case PM2: {
my_bool is_with_dot = (AM2 == elem->elem_flag_|| PM2 == elem->elem_flag_);
my_bool is_am = FALSE;
my_bool is_pm = FALSE;
parsed_elem_len = is_with_dot ? PATTERNEX[AM2].len_ : PATTERNEX[AM].len_;
is_am = match_pattern_ignore_case(&ctx,
is_with_dot ? &PATTERNEX[AM2] : &PATTERNEX[AM]);
is_pm = match_pattern_ignore_case(&ctx,
is_with_dot ? &PATTERNEX[PM2] : &PATTERNEX[PM]);
if (!is_am && !is_pm) {
ret = 1;
} else {
is_after_noon = is_pm;
}
break;
}
case RR:
case RRRR: {
int32_t round_year = 0;
int32_t conflict_check_year = 0;
if (0 != (ret = match_int_value(&ctx, 4, &parsed_elem_len, &round_year))) {
} else if (parsed_elem_len > 2) {
conflict_check_year = round_year;
//do nothing
} else {
int32_t first_two_digits_of_current_year = (ob_time->parts_[DT_YEAR] / 100) % 100;
int32_t last_two_digits_of_current_year = ob_time->parts_[DT_YEAR] % 100;
conflict_check_year = round_year;
if (round_year < 50) { //0~49
if (last_two_digits_of_current_year < 50) {
round_year += first_two_digits_of_current_year * 100;
} else {
round_year += (first_two_digits_of_current_year + 1) * 100;
}
} else if (round_year < 100) { //50~99
if (last_two_digits_of_current_year < 50) {
round_year += (first_two_digits_of_current_year - 1) * 100;
} else {
round_year += first_two_digits_of_current_year * 100;
}
}
}
if (0 == ret) {
if (0 != (ret = check_validate(&LIMITER_YEAR, round_year))) { //TODO wjh: negetive year number
} else if (0 != (ret = set_ob_time_year_may_conflict(ob_time, &julian_year_value,
conflict_check_year, round_year,
FALSE /* overwrite */))) {
}
}
break;
}
case SS: {
int32_t sec = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &sec))) {
} else if (0 != (ret = check_validate(&LIMITER_SECOND, sec))) {
} else {
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_SEC, sec);
}
break;
}
case SSSSS: {
int32_t sec_past_midnight = 0;
if (0 != (ret = match_int_value(&ctx, expected_elem_len, &parsed_elem_len, &sec_past_midnight))) {
} else if (0 != (ret = check_validate(&LIMITER_SECS_PAST_MIDNIGHT, sec_past_midnight))) {
} else {
int32_t secs = sec_past_midnight % (int32_t)(SECS_PER_MIN);
int32_t mins = (sec_past_midnight / (int32_t)(SECS_PER_MIN)) % (int32_t)(MINS_PER_HOUR);
int32_t hours = sec_past_midnight / (int32_t)(SECS_PER_MIN) / (int32_t)(MINS_PER_HOUR);
if (0 != (ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_SEC, secs))) {
} else if (0 != (ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_MIN, mins))) {
} else if (0 != (ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_HOUR, hours))) {
}
}
break;
}
case YGYYY: {
int32_t years = 0;
if (0 != (ret = match_int_value_with_comma(&ctx, expected_elem_len, &parsed_elem_len, &years))) {
} else if (0 != (ret = check_validate(&LIMITER_YEAR, years))) {
} else if (0 != (ret = set_ob_time_year_may_conflict(ob_time, &julian_year_value,
years, years, FALSE /* overwrite */))) {
}
break;
}
case SYYYY:
case YYYY:
case YYY:
case YY:
case Y: {
int32_t years = 0;
int32_t conflict_check_year = 0;
int32_t sign = 1;
if (SYYYY == elem->elem_flag_) {
if (is_sign_char(ctx.cur_ch_[0])) {
sign = ('-' == ctx.cur_ch_[0] ? -1 : 1);
ctx.cur_ch_ += 1;
ctx.remain_len_ -= 1;
} else if (part_blank1_len + part_sep_len > format_sep_len
&& is_sign_char(ctx.cur_ch_[-1])) {
sign = ('-' == ctx.cur_ch_[-1] ? -1 : 1);
}
}
if (!(ctx.cur_ch_ != NULL && ctx.remain_len_ > 0)) {
} else if (0 != (ret = match_int_value_with_sign(&ctx, expected_elem_len, &parsed_elem_len, &years, sign))) {
}
if (0 == ret) {
conflict_check_year = years;
if (expected_elem_len < 4) {
years += (ob_time->parts_[DT_YEAR] / (int32_t)(power_of_10[parsed_elem_len]))
* (int32_t)(power_of_10[parsed_elem_len]);
}
if (0 != (ret = check_validate(&LIMITER_YEAR, years))) {
} else if (0 != (ret = set_ob_time_year_may_conflict(ob_time, &julian_year_value,
conflict_check_year, years,
FALSE /* overwrite */))) {
}
}
break;
}
case X: {
if ('.' != ctx.cur_ch_[0]) {
ignore_fs_flag = TRUE;
ctx.cur_ch_ -= (part_blank1_len + part_sep_len + part_blank2_len);
ctx.remain_len_ += (part_blank1_len + part_sep_len + part_blank2_len);
} else {
parsed_elem_len = 1;
}
break;
}
case CC:
case SCC:
case IW:
case W:
case WW:
case YEAR:
case SYEAR:
case Q:
case I:
case IY:
case IYY:
case IYYY: {
ret = 1;
break;
}
default: {
ret = 1;
break;
}
} //end switch
if (0 == ret) {
ctx.cur_ch_ += parsed_elem_len;
ctx.remain_len_ -= parsed_elem_len;
}
}//end if
if (0 != ret) {
} else {
}
} //end for
//check if the unprocessed elems has permission to be omitted
if (0 == ret) {
for (; elem_idx < dfm_elems.elements; ++elem_idx) {
struct ObDFMElem *elem = dynamic_element(&dfm_elems, elem_idx, struct ObDFMElem *);
if (!is_element_can_omit(elem)) {
ret = 1;
}
}
}
if (0 == ret) {
//all elems has finished, is there anything else in str? the rest must be separators, do check.
int64_t str_remain_sep_len = 0;
while (str_remain_sep_len < ctx.remain_len_
&& is_split_char(ctx.cur_ch_[str_remain_sep_len])) {
str_remain_sep_len++;
}
ctx.cur_ch_ += str_remain_sep_len;
ctx.remain_len_ -= str_remain_sep_len;
if (ctx.remain_len_ > 0) {
ret = 1;
}
}
//after noon conflict: AM PM vs HH12 HH
if (0 == ret) {
if (hh12_temp_value != ZERO_TIME) {
//when hour value, varied by meridian indicators
//if HH12 = 12, when meridian indicator 'AM' exists, the real time is hour = 0
//if HH12 = 12, when meridian indicator 'PM' exists, the real time is hour = 12
if (is_after_noon) {
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_HOUR, hh12_temp_value % 12 + 12);
} else {
ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_HOUR, hh12_temp_value % 12);
}
}
}
//before christ conflict: BC AD vs YEAR //TODO wjh: change this when ob_time support negetive years
if (0 == ret) {
if (is_before_christ) {
ret = 1;
}
}
//year cannot changed after this line
//feed/validate yday + YEAR to MON and DAY
if (0 == ret) {
if (yday_temp_value != ZERO_DATE) {
int32_t month = 0;
int32_t day = 0;
if (0 != (ret = get_day_and_month_from_year_day(yday_temp_value, ob_time->parts_[DT_YEAR], &month, &day))) {
} else if (0 != (ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_MON, month))) {
} else if (0 != (ret = set_ob_time_part_may_conflict(ob_time, &conflict_part_bitset, DT_MDAY, day))) {
}
}
}
//calc and validate: YDAY WDAY vs YEAR MON DAY
if (0 == ret) {
if (0 != (ret = validate_oracle_date(ob_time))) {
} else {
//ob_time_to_date func is to calc YDAY and WDAY and return DATE
date_temp_value = ob_time_to_date(ob_time); //TODO: shanting
if (yday_temp_value != ZERO_DATE && ob_time->parts_[DT_YDAY] != yday_temp_value) {
ret = 1;
} else if (wday_temp_value != ZERO_DATE && ob_time->parts_[DT_WDAY] != wday_temp_value) {
ret = 1;
} else {
ob_time->parts_[DT_DATE] = date_temp_value;
}
}
}
//for time zone info
if (0 == ret && !ob_time->is_tz_name_valid_) {
//B. timezone defined by time zone hour and minute
int32_t tz_offset_value = 0;
if ( ob_bitmap_is_set(&elem_flags, TZH)) {
my_bool has_tzh_value = (temp_tzh_value >= 0);
my_bool has_tzm_value = (temp_tzm_value >= 0);
if (!has_tzh_value && has_tzm_value) {
ret = 1;
} else if (!has_tzh_value && !has_tzm_value) {
//do nothing
} else if (has_tzh_value && !has_tzm_value) {
tz_hour = temp_tz_factor * temp_tzh_value;
tz_min = temp_tz_factor * abs(tz_min);
} else {
tz_hour = temp_tz_factor * temp_tzh_value;
tz_min = temp_tz_factor * temp_tzm_value;
}
} else if ( ob_bitmap_is_set(&elem_flags, TZR)) {
//do nothing
} else {
//no time zone info in elem_flags
}
//calc offset
if (0 == ret) {
if (tz_hour * tz_min < 0) {
ret = 1;
} else {
tz_offset_value = (int32_t)(tz_hour * MINS_PER_HOUR + tz_min);
}
}
//final validate
if (0 == ret) {
if (!(MIN_OFFSET_MINUTES <= tz_offset_value && tz_offset_value <= MAX_OFFSET_MINUTES)) {
ret = 1;
} else {
ob_time->parts_[DT_OFFSET_MIN] = tz_offset_value;
}
}
}
if (0 != ret) {
} else {
}
}//end if
ob_bitmap_free(&elem_flags);
ma_delete_dynamic(&dfm_elems);
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink