int get_ext_obj_value(char * buf, const int64_t buf_len, int64_t & pos, int64_t& value)
{
int ret = OB_SUCCESS;
ObObj obj;
if ( OB_SUCCESS == (ret = obj.deserialize(buf, buf_len, pos))
&& ObExtendType == obj.get_type())
{
ret = obj.get_ext(value);
}
return ret;
}
TEST(ObObj,extend_type)
{
ObObj t1;
t1.set_ext(90);
int64_t len = t1.get_serialize_size();
ASSERT_EQ(len,2);
char *buf = (char *)malloc(len);
int64_t pos = 0;
ASSERT_EQ(t1.serialize(buf,len,pos),OB_SUCCESS);
ObObj f;
pos = 0;
ASSERT_EQ(f.deserialize(buf,len,pos),OB_SUCCESS);
int64_t e = 0;
ASSERT_EQ(f.get_ext(e),0);
ASSERT_EQ(e,90);
free(buf);
}
int ObObj::apply(const ObObj &mutation)
{
int64_t org_type = get_type();
int64_t org_ext = get_ext();
int err = OB_SUCCESS;
ObCreateTime create_time = 0;
ObModifyTime modify_time = 0;
bool is_add = false;
bool org_is_add = false;
if (ObSeqType == mutation.get_type()
|| ObMinType >= mutation.get_type()
|| ObMaxType <= mutation.get_type())
{
TBSYS_LOG(WARN,"unsupported type [type:%d]", static_cast<int32_t>(mutation.get_type()));
err = OB_INVALID_ARGUMENT;
}
if (OB_SUCCESS == err
&& ObExtendType != get_type()
&& ObNullType != get_type()
&& ObExtendType != mutation.get_type()
&& ObNullType != mutation.get_type()
&& get_type() != mutation.get_type())
{
TBSYS_LOG(WARN,"type not coincident [this->type:%d,mutation.type:%d]",
static_cast<int>(get_type()), static_cast<int>(mutation.get_type()));
err = OB_INVALID_ARGUMENT;
}
_ObjValue value, mutation_value;
if (OB_SUCCESS == err)
{
bool ext_val_can_change = (ObActionFlag::OP_ROW_DOES_NOT_EXIST == get_ext()) || (ObNullType == get_type());
bool org_is_nop = (ObActionFlag::OP_NOP == get_ext());
switch (mutation.get_type())
{
case ObNullType:
set_null();
break;
case ObVarcharType:
*this = mutation;
break;
case ObIntType:
if (ext_val_can_change || org_is_nop)
{
set_int(0);
}
err = get_int(value.int_val,org_is_add);
if (OB_SUCCESS == err)
{
err = mutation.get_int(mutation_value.int_val,is_add);
}
if (OB_SUCCESS == err)
{
if (is_add)
{
value.int_val += mutation_value.int_val;
}
else
{
value.int_val = mutation_value.int_val;
}
set_int(value.int_val, (org_is_add || org_is_nop) && is_add);
}
break;
case ObFloatType:
if (ext_val_can_change || org_is_nop)
{
set_float(0);
}
err = get_float(value.float_val,org_is_add);
if (OB_SUCCESS == err)
{
err = mutation.get_float(mutation_value.float_val, is_add);
}
if (OB_SUCCESS == err)
{
if (is_add)
{
value.float_val += mutation_value.float_val;
}
else
{
value.float_val = mutation_value.float_val;
}
set_float(value.float_val,is_add && (org_is_add || org_is_nop));
}
break;
case ObDoubleType:
if (ext_val_can_change || org_is_nop)
{
set_double(0);
}
err = get_double(value.double_val,org_is_add);
if (OB_SUCCESS == err)
{
err = mutation.get_double(mutation_value.double_val,is_add);
}
if (OB_SUCCESS == err)
{
if (is_add)
{
value.double_val += mutation_value.double_val;
}
else
{
value.double_val = mutation_value.double_val;
}
set_double(value.double_val, (org_is_add || org_is_nop) && is_add);
}
break;
case ObDateTimeType:
if (ext_val_can_change || org_is_nop)
{
set_datetime(0);
}
err = get_datetime(value.second_val,org_is_add);
if (OB_SUCCESS == err)
{
err = mutation.get_datetime(mutation_value.second_val,is_add);
}
if (OB_SUCCESS == err)
{
if (is_add)
{
value.second_val += mutation_value.second_val;
}
else
{
value.second_val = mutation_value.second_val;
}
set_datetime(value.second_val,is_add && (org_is_add || org_is_nop));
}
break;
case ObPreciseDateTimeType:
if (ext_val_can_change || org_is_nop)
{
set_precise_datetime(0);
}
err = get_precise_datetime(value.microsecond_val,org_is_add);
if (OB_SUCCESS == err)
{
err = mutation.get_precise_datetime(mutation_value.microsecond_val,is_add);
}
if (OB_SUCCESS == err)
{
if (is_add)
{
value.microsecond_val += mutation_value.microsecond_val;
}
else
{
value.microsecond_val = mutation_value.microsecond_val;
}
set_precise_datetime(value.microsecond_val,is_add && (org_is_add || org_is_nop));
}
break;
case ObExtendType:
switch (mutation.get_ext())
{
case ObActionFlag::OP_DEL_ROW:
case ObActionFlag::OP_DEL_TABLE:
/// used for join, if right row was deleted, set the cell to null
set_null();
break;
case ObActionFlag::OP_ROW_DOES_NOT_EXIST:
/// do nothing
break;
case ObActionFlag::OP_NOP:
if (get_ext() == ObActionFlag::OP_ROW_DOES_NOT_EXIST
|| get_ext() == ObActionFlag::OP_DEL_ROW)
{
set_null();
}
break;
default:
TBSYS_LOG(ERROR,"unsupported ext value [value:%ld]", mutation.get_ext());
err = OB_INVALID_ARGUMENT;
break;
}
break;
case ObCreateTimeType:
err = mutation.get_createtime(create_time);
if (OB_SUCCESS == err)
{
if (ext_val_can_change || org_is_nop)
{
set_createtime(create_time);
}
}
if (OB_SUCCESS == err)
{
err = get_createtime(value.create_time_val);
}
if (OB_SUCCESS == err)
{
err = mutation.get_createtime(mutation_value.create_time_val);
}
if (OB_SUCCESS == err)
{
set_createtime(std::min<ObCreateTime>(value.create_time_val,mutation_value.create_time_val));
}
break;
case ObModifyTimeType:
err = mutation.get_modifytime(modify_time);
if (OB_SUCCESS == err)
{
if (ext_val_can_change || org_is_nop)
{
set_modifytime(modify_time);
}
}
if (OB_SUCCESS == err)
{
err = get_modifytime(value.modify_time_val);
}
if (OB_SUCCESS == err)
{
err = mutation.get_modifytime(mutation_value.modify_time_val);
}
if (OB_SUCCESS == err)
{
set_modifytime(std::max<ObCreateTime>(value.modify_time_val,mutation_value.modify_time_val));
}
break;
default:
/* case ObSeqType: */
TBSYS_LOG(ERROR,"unsupported type [type:%d]", static_cast<int32_t>(mutation.get_type()));
err = OB_INVALID_ARGUMENT;
break;
}
}
if(OB_SUCCESS != err)
{
TBSYS_LOG(WARN,"fail to apply [this->type:%ld,this->ext:%ld,mutation->type:%d,mutation->ext:%ld, err:%d]",
org_type, org_ext, mutation.get_type(), mutation.get_ext(), err);
}
return err;
}
