TEST_F(TestMutatorParamDecoder, test_decode) { ObSchemaManagerV2 schema(100); tbsys::CConfig config; EXPECT_TRUE(schema.parse_from_file("schema.ini", config)); ObCellInfo cell; ObCellInfo out_cell; char * no_name = (char*)"test_not_exist"; char * tablename = (char*)"collect_info"; char * columnname = (char*)"item_price"; char * rowkey = (char*)"row_key"; ObString table_name; ObString column_name; ObString row_key; table_name.assign(tablename, static_cast<int32_t>(strlen(tablename))); column_name.assign(columnname, static_cast<int32_t>(strlen(columnname))); row_key.assign(rowkey, static_cast<int32_t>(strlen(rowkey))); ObMutator mutator; int64_t count = 20; mutator.del_row(table_name, row_key); for (int64_t i = 0; i < count; ++i) { mutator.add(table_name, row_key, column_name, (int64_t)1, ObMutator::RETURN_NO_RESULT); mutator.add(table_name, row_key, column_name, i + 10, ObMutator::RETURN_UPDATE_RESULT); } mutator.del_row(table_name, row_key); ObUpdateCondition & cond = mutator.get_update_condition(); ObObj obj; obj.set_int(1234); EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, column_name, LT, obj)); EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, false)); obj.set_int(1230); EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, column_name, GT, obj)); EXPECT_TRUE(OB_SUCCESS == cond.add_cond(table_name, row_key, false)); // succ ObMutator decode_mutator; ObGetParam org_param; ObGetParam decode_param; EXPECT_TRUE(OB_SUCCESS == ObMutatorParamDecoder::decode(mutator, schema, decode_mutator, org_param, decode_param)); // decode mutator EXPECT_TRUE(decode_mutator.get_update_condition().get_count() == cond.get_count()); // need return EXPECT_TRUE(org_param.get_cell_size() == count); // need prefetch EXPECT_TRUE(decode_param.get_cell_size() == (count + cond.get_count())); // failed table_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); for (int64_t i = 0; i < count; ++i) { mutator.add(table_name, row_key, column_name, (int64_t)1, ObMutator::RETURN_NO_RESULT); mutator.add(table_name, row_key, column_name, i + 10, ObMutator::RETURN_UPDATE_RESULT); } org_param.reset(); decode_param.reset(); decode_mutator.reset(); EXPECT_TRUE(OB_SUCCESS != ObMutatorParamDecoder::decode(mutator, schema, decode_mutator, org_param, decode_param)); }
TEST_F(ObRowUtilTest, basic_test1) { char buf[1024]; ObCompactCellWriter cell_writer; OK(cell_writer.init(buf, 1024, SPARSE)); ObObj value; ObRowDesc row_desc; for(int64_t i=0;i<10;i++) { row_desc.add_column_desc(TABLE_ID, i); value.set_int(i); OK(cell_writer.append(i, value)); } OK(cell_writer.row_finish()); ObString compact_row; compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size()); ObRow row; row.set_row_desc(row_desc); OK(ObRowUtil::convert(compact_row, row)); const ObObj *cell = NULL; uint64_t column_id = OB_INVALID_ID; uint64_t table_id = OB_INVALID_ID; int64_t int_value = 0; for(int64_t i=0;i<10;i++) { OK(row.raw_get_cell(i, cell, table_id, column_id)); cell->get_int(int_value); ASSERT_EQ(i, int_value); } }
/* only support integer and string */ void ObScannerLoader::auto_set_val(ObObj &val, char *buf) { if (NULL == buf) { TBSYS_LOG(ERROR, "invalid scanner data input"); } else { int len = static_cast<int32_t>(strlen(buf)); int i = 0; ObString tmpstr; bool is_num = true; for(i = 0; i < len; i++) { if (!isdigit(buf[i])) { is_num = false; break; } } if (is_num) { val.set_int(atoi(buf)); } else { tmpstr.assign(buf, static_cast<int32_t>(strlen(buf))); val.set_varchar(tmpstr); } //val.dump(); } }
TEST(TestObInsertDBSemFilter, child_not_empty) { ObInsertDBSemFilter dbi; ObRowDesc row_desc; row_desc.add_column_desc(1001, 16); row_desc.add_column_desc(1001, 17); row_desc.add_column_desc(1001, 101); row_desc.add_column_desc(1001, 102); ObRowDescExt row_desc_ext; ObObj type; type.set_int(0); row_desc_ext.add_column_desc(1001, 16, type); row_desc_ext.add_column_desc(1001, 17, type); row_desc_ext.add_column_desc(1001, 101, type); row_desc_ext.add_column_desc(1001, 102, type); ObValues cc; dbi.get_values().set_row_desc(row_desc, row_desc_ext); cc.set_row_desc(row_desc); build_values(10, row_desc, dbi.get_values(), cc); dbi.set_child(0, cc); int ret = dbi.open(); EXPECT_EQ(OB_ERR_PRIMARY_KEY_DUPLICATE, ret); const ObRow *row = NULL; ret = dbi.get_next_row(row); EXPECT_EQ(OB_ITER_END, ret); ret = dbi.close(); EXPECT_EQ(OB_SUCCESS, ret); }
int CellinfoBuilder::get_mutator(const ObString &row_key, const ObSchema &schema, int64_t &cur_seed, ObMutator &mutator, PageArena<char> &allocer) { int ret = OB_SUCCESS; int64_t sign = ob_crc64(row_key.ptr(), row_key.length()); uint64_t table_id = schema.get_table_id(); sign = ob_crc64(sign, &table_id, sizeof(uint64_t)); struct drand48_data rand_data; cur_seed += 1; srand48_r(sign + cur_seed, &rand_data); int64_t rand = 0; lrand48_r(&rand_data, &rand); int64_t op_num = range_rand(1, max_op_num_, rand); for (int64_t i = 0; i < op_num; i++) { ret = build_operator_(rand_data, row_key, schema, mutator, allocer); if (OB_SUCCESS != ret) { break; } } ObString table_name; table_name.assign_ptr(const_cast<char*>(schema.get_table_name()), strlen(schema.get_table_name())); ObString column_name; column_name.assign_ptr(SEED_COLUMN_NAME, strlen(SEED_COLUMN_NAME)); ObObj obj; obj.set_int(cur_seed); mutator.update(table_name, row_key, column_name, obj); return ret; }
TEST(ObObj,int_boundary) { int64_t need_len = 0; int64_t data[] = {1,28,-1,INT32_MIN,static_cast<int64_t>(UINT32_MAX),INT64_MAX,INT64_MIN,UINT64_MAX,124543900}; for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i) { need_len += serialization::encoded_length_int(data[i]); } char *buf = (char *)malloc(need_len); ObObj t; int64_t pos = 0; for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i) { t.reset(); t.set_int(data[i]); ASSERT_EQ(t.serialize(buf,need_len,pos),OB_SUCCESS); } pos = 0; int64_t v = 0; for(uint32_t i=0;i<sizeof(data)/sizeof(data[0]);++i) { t.reset(); ASSERT_EQ(t.deserialize(buf,need_len,pos),OB_SUCCESS); ASSERT_EQ(t.get_int(v),OB_SUCCESS); ASSERT_EQ(v,data[i]); } free(buf); }
void build_values(const int64_t row_count, ObRowDesc &row_desc, ObExprValues &values1, ObValues &values2) { for (int64_t i = 0; i < row_count; i++) { ObRow row; row.set_row_desc(row_desc); for (int64_t j = 0; j < row_desc.get_column_num(); j++) { uint64_t table_id = OB_INVALID_ID; uint64_t column_id = OB_INVALID_ID; row_desc.get_tid_cid(j, table_id, column_id); ObObj obj; obj.set_int(i + j); row.set_cell(table_id, column_id, obj); ObSqlExpression se; se.set_tid_cid(table_id, column_id); ExprItem ei; ei.type_ = T_INT; ei.value_.int_ = i + j; se.add_expr_item(ei); //ei.type_ = T_REF_COLUMN; //ei.value_.cell_.tid = table_id; //ei.value_.cell_.cid = column_id; //se.add_expr_item(ei); se.add_expr_item_end(); values1.add_value(se); } //values1.add_values(row); values2.add_values(row); } }
TEST(ObObj,Serialize_int_add) { ObObj t; t.set_int(9900); int64_t len = t.get_serialize_size(); ASSERT_EQ(len,3); char *buf = (char *)malloc(len); int64_t pos = 0; ASSERT_EQ(t.serialize(buf,len,pos),OB_SUCCESS); ASSERT_EQ(pos,len); ObObj f; pos = 0; ASSERT_EQ(f.deserialize(buf,len,pos),OB_SUCCESS); ASSERT_EQ(pos,len); int64_t r = 0; int64_t l = 0; ASSERT_EQ(f.get_type(),t.get_type()); f.get_int(r); t.get_int(l); ASSERT_EQ(r,l); free(buf); }
TEST_F(TestParamDecoder, test_decode_cond_cell) { ObSchemaManagerV2 schema(100); tbsys::CConfig config; EXPECT_TRUE(schema.parse_from_file("schema.ini", config)); ObCondInfo cond; ObCellInfo out_cell; char * no_name = (char*)"test_not_exist"; char * tablename = (char*)"collect_info"; char * columnname = (char*)"item_price"; char * rowkey = (char*)"rowkey_test"; ObString table_name; ObString column_name; ObRowkey row_key; // NORMAL TYPE // table name not exist and column not exist table_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); column_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); row_key = make_rowkey(rowkey, &allocator_); ObObj obj; obj.set_int(1234); cond.set(NE, table_name, row_key, column_name, obj); EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); // table name not exist but column exist table_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); column_name.assign(columnname, static_cast<int32_t>(strlen(columnname))); cond.set(NE, table_name, row_key, column_name, obj); EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); // table name exist but column not exist table_name.assign(tablename, static_cast<int32_t>(strlen(tablename))); column_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); cond.set(NE, table_name, row_key, column_name, obj); EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); // table name exist and column exist table_name.assign(tablename, static_cast<int32_t>(strlen(tablename))); column_name.assign(columnname, static_cast<int32_t>(strlen(columnname))); cond.set(NE, table_name, row_key, column_name, obj); EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); // EXIST TYPE // table name not exist table_name.assign(no_name, static_cast<int32_t>(strlen(no_name))); row_key = make_rowkey(rowkey, &allocator_); cond.set(table_name, row_key, false); EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); cond.set(table_name, row_key, true); EXPECT_TRUE(OB_SUCCESS != ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); // table name exist table_name.assign(tablename, static_cast<int32_t>(strlen(tablename))); cond.set(table_name, row_key, true); EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); cond.set(table_name, row_key, false); EXPECT_TRUE(OB_SUCCESS == ObParamDecoder::decode_cond_cell(cond, schema, out_cell)); }
int set_int_obj_value(char * buf, const int64_t buf_len, int64_t & pos, const int64_t value) { int ret = OB_SUCCESS; ObObj obj; obj.set_int(value); ret = obj.serialize(buf, buf_len, pos); return ret; }
ScanConds::ScanConds(const char* column_name, const ObLogicOperator& cond_op, int64_t value) { ObString name; name.assign_ptr(const_cast<char*>(column_name), static_cast<int32_t>(strlen(column_name))); ObObj obj; obj.set_int(value); EasyArray<ObSimpleCond>(ObSimpleCond(name, cond_op, obj)); }
int64_t ObReadParam::get_reserve_param_serialize_size(void) const { ObObj obj; // reserve for read master obj.set_ext(ObActionFlag::RESERVE_PARAM_FIELD); int64_t total_size = obj.get_serialize_size(); obj.set_int(get_is_read_consistency()); total_size += obj.get_serialize_size(); return total_size; }
int ObSqlGetParam::serialize_int(char* buf, const int64_t buf_len, int64_t& pos, const int64_t value) const { int ret = OB_SUCCESS; ObObj obj; obj.set_int(value); ret = obj.serialize(buf, buf_len, pos); return ret; }
int ObReadParam::serialize_reserve_param(char * buf, const int64_t buf_len, int64_t & pos) const { ObObj obj; // serialize RESERVER PARAM FIELD obj.set_ext(ObActionFlag::RESERVE_PARAM_FIELD); int ret = obj.serialize(buf, buf_len, pos); if (ret == OB_SUCCESS) { obj.set_int(get_is_read_consistency()); ret = obj.serialize(buf, buf_len, pos); } return ret; }
int64_t ObSqlScanParam::get_basic_param_serialize_size(void) const { int64_t total_size = 0; ObObj obj; // BASIC_PARAM_FIELD obj.set_ext(ObActionFlag::BASIC_PARAM_FIELD); total_size += obj.get_serialize_size(); // scan range obj.set_int(range_.table_id_); total_size += obj.get_serialize_size(); obj.set_int(range_.border_flag_.get_data()); total_size += obj.get_serialize_size(); // start_key_ total_size += get_rowkey_obj_array_size( range_.start_key_.get_obj_ptr(), range_.start_key_.get_obj_cnt()); // end_key_ total_size += get_rowkey_obj_array_size( range_.end_key_.get_obj_ptr(), range_.end_key_.get_obj_cnt()); obj.set_int(scan_flag_.flag_); total_size += obj.get_serialize_size(); return total_size; }
TEST(ObObj, test_bug) { ObObj obj; obj.set_int(100, false); char buf[2048]; int64_t len = 2048; int64_t pos = 0; ASSERT_EQ(obj.serialize(buf, len, pos), OB_SUCCESS); pos = 0; ObObj temp; temp.set_int(200, true); temp.reset(); ASSERT_EQ(temp.deserialize(buf, len, pos), OB_SUCCESS); ASSERT_EQ(temp == obj, true); ObObj test; test.set_int(300, true); test = temp; ASSERT_EQ(test == temp, true); }
int64_t get_rowkey_obj_array_size(const ObObj* array, const int64_t size) { int64_t total_size = 0; ObObj obj; obj.set_int(size); total_size += obj.get_serialize_size(); for (int64_t i = 0; i < size; ++i) { total_size += array[i].get_serialize_size(); } return total_size; }
TEST_F(ObRowFuseTest, assign) { uint64_t TABLE_ID = 1000; ObRowDesc row_desc; for(int i=0;i<8;i++) { row_desc.add_column_desc(TABLE_ID, OB_APP_MIN_COLUMN_ID + i); } ObRow row; row.set_row_desc(row_desc); ObObj value; for(int i=0;i<8;i++) { value.set_int(i); OK(row.raw_set_cell(i, value)); } ObRowDesc ups_row_desc; for(int i=0;i<4;i++) { ups_row_desc.add_column_desc(TABLE_ID, OB_APP_MIN_COLUMN_ID + i); } ObUpsRow ups_row; ups_row.set_row_desc(ups_row_desc); for(int i=0;i<4;i++) { value.set_ext(ObActionFlag::OP_NOP); OK(ups_row.raw_set_cell(i, value)); } ups_row.set_delete_row(true); OK(ObRowFuse::assign(ups_row, row)); const ObObj *cell = NULL; uint64_t table_id = OB_INVALID_ID; uint64_t column_id = OB_INVALID_ID; for(int i=0;i<4;i++) { OK(row.raw_get_cell(i, cell, table_id, column_id)); ASSERT_EQ(ObNullType, cell->get_type()); } ASSERT_TRUE(OB_SUCCESS != row.raw_get_cell(4, cell, table_id, column_id)); }
int64_t ObSqlReadParam::get_basic_param_serialize_size(void) const { int64_t total_size = 0; ObObj obj; // consistency obj.set_int(get_is_read_consistency()); total_size += obj.get_serialize_size(); // result cached obj.set_int(get_is_result_cached()); total_size += obj.get_serialize_size(); // data version obj.set_int(get_data_version()); total_size += obj.get_serialize_size(); // table id obj.set_int(table_id_); total_size += obj.get_serialize_size(); // renamed table id obj.set_int(renamed_table_id_); total_size += obj.get_serialize_size(); // only_static_data obj.set_bool(only_static_data_); total_size += obj.get_serialize_size(); return total_size; }
int64_t ObSqlGetParam::get_obj_serialize_size(const int64_t value, bool is_ext) const { ObObj obj; if (is_ext) { obj.set_ext(value); } else { obj.set_int(value); } return obj.get_serialize_size(); }
TEST_F(ObRowUtilTest, basic_test) { char buf[1024]; ObCompactCellWriter cell_writer; OK(cell_writer.init(buf, 1024, DENSE_SPARSE)); ObRowkey rowkey; ObObj rowkey_obj[OB_MAX_ROWKEY_COLUMN_NUMBER]; rowkey_obj[0].set_int(3); rowkey_obj[1].set_int(30); rowkey.assign(rowkey_obj, 2); OK(cell_writer.append_rowkey(rowkey)); ObObj value; ObRowDesc row_desc; for(int64_t i=0;i<10;i++) { row_desc.add_column_desc(TABLE_ID, i); value.set_int(i); OK(cell_writer.append(i, value)); } OK(cell_writer.row_finish()); ObString compact_row; compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size()); ObRow row; ObRowkey rk; ObObj rk_obj[OB_MAX_ROWKEY_COLUMN_NUMBER]; row.set_row_desc(row_desc); OK(ObRowUtil::convert(compact_row, row, &rk, rk_obj)); ASSERT_TRUE( rowkey == rk ); const ObObj *cell = NULL; uint64_t column_id = OB_INVALID_ID; uint64_t table_id = OB_INVALID_ID; int64_t int_value = 0; for(int64_t i=0;i<10;i++) { OK(row.raw_get_cell(i, cell, table_id, column_id)); cell->get_int(int_value); ASSERT_EQ(i, int_value); } }
TEST_F(ObRowUtilTest, basic_test) { char buf[1024]; ObCompactCellWriter cell_writer; OK(cell_writer.init(buf, 1024, DENSE_SPARSE)); const char *rowkey = "rowkey_00001"; ObString rowkey_str; rowkey_str.assign_ptr(const_cast<char *>(rowkey), (int32_t)(strlen(rowkey))); ObObj rowkey_obj; rowkey_obj.set_varchar(rowkey_str); OK(cell_writer.append(rowkey_obj)); OK(cell_writer.rowkey_finish()); ObObj value; ObRowDesc row_desc; for(int64_t i=0;i<10;i++) { row_desc.add_column_desc(TABLE_ID, i); value.set_int(i); OK(cell_writer.append(i, value)); } OK(cell_writer.row_finish()); ObString compact_row; compact_row.assign_ptr(cell_writer.get_buf(), (int32_t)cell_writer.size()); ObRow row; ObString rk; row.set_row_desc(row_desc); OK(ObRowUtil::convert(compact_row, row, &rk)); ASSERT_EQ(0, strncmp(rowkey, rk.ptr(), rk.length())); const ObObj *cell = NULL; uint64_t column_id = OB_INVALID_ID; uint64_t table_id = OB_INVALID_ID; int64_t int_value = 0; for(int64_t i=0;i<10;i++) { OK(row.raw_get_cell(i, cell, table_id, column_id)); cell->get_int(int_value); ASSERT_EQ(i, int_value); } }
TEST(TestObInsertDBSemFilter, iter_succ) { ObInsertDBSemFilter dbi; ObRowDesc row_desc; row_desc.add_column_desc(1001, 16); row_desc.add_column_desc(1001, 17); row_desc.add_column_desc(1001, 101); row_desc.add_column_desc(1001, 102); ObRowDescExt row_desc_ext; ObObj type; type.set_int(0); row_desc_ext.add_column_desc(1001, 16, type); row_desc_ext.add_column_desc(1001, 17, type); row_desc_ext.add_column_desc(1001, 101, type); row_desc_ext.add_column_desc(1001, 102, type); ObValues cc; dbi.get_values().set_row_desc(row_desc, row_desc_ext); cc.set_row_desc(row_desc); build_values(10, row_desc, dbi.get_values(), cc); ObValues empty_values; dbi.set_child(0, empty_values); int ret = dbi.open(); EXPECT_EQ(OB_SUCCESS, ret); cc.open(); const ObRow *row1 = NULL; const ObRow *row2 = NULL; while (OB_SUCCESS == cc.get_next_row(row1)) { ret = dbi.get_next_row(row2); EXPECT_EQ(OB_SUCCESS, ret); EXPECT_EQ(true, equal(*row1, *row2)); } ret = cc.get_next_row(row1); EXPECT_EQ(OB_ITER_END, ret); ret = dbi.get_next_row(row2); EXPECT_EQ(OB_ITER_END, ret); ret = dbi.close(); EXPECT_EQ(OB_SUCCESS, ret); }
TEST_F(TestSimpleFilter, test_index) { ObLogicOperator operate = LIKE; char * ptr = "test_test"; ObString sub_string; sub_string.assign(ptr, strlen(ptr)); ObObj operand; operand.set_varchar(sub_string); ObSimpleFilter filter; ObSimpleCond cond1; EXPECT_TRUE(cond1.set(2, operate, operand) == OB_SUCCESS); EXPECT_TRUE(filter.add_cond(2, operate, operand) == OB_SUCCESS); operate = GE; operand.set_int(23); ObSimpleCond cond2; EXPECT_TRUE(cond2.set(1, operate, operand) == OB_SUCCESS); EXPECT_TRUE(filter.add_cond(1, operate, operand) == OB_SUCCESS); operate = NE; operand.set_varchar(sub_string); ObSimpleCond cond3; EXPECT_TRUE(cond3.set(3, operate, operand) == OB_SUCCESS); EXPECT_TRUE(filter.add_cond(3, operate, operand) == OB_SUCCESS); const ObSimpleCond * cond = NULL; cond = filter[-1]; EXPECT_TRUE(cond == NULL); cond = filter[3]; EXPECT_TRUE(cond == NULL); cond = filter[0]; EXPECT_TRUE(*cond == cond1); cond = filter[1]; EXPECT_TRUE(cond != NULL); EXPECT_TRUE(*cond == cond2); cond = filter[2]; EXPECT_TRUE(cond != NULL); EXPECT_TRUE(*cond == cond3); }
void build_values(const int64_t row_count, ObRowDesc &row_desc, ObValues &values1, ObValues &values2) { values1.set_row_desc(row_desc); values2.set_row_desc(row_desc); for (int64_t i = 0; i < row_count; i++) { ObRow row; row.set_row_desc(row_desc); for (int64_t j = 0; j < row_desc.get_column_num(); j++) { uint64_t table_id = OB_INVALID_ID; uint64_t column_id = OB_INVALID_ID; row_desc.get_tid_cid(j, table_id, column_id); ObObj obj; obj.set_int(i + j); row.set_cell(table_id, column_id, obj); } values1.add_values(row); values2.add_values(row); } }
TEST(ObObj, performance) { // int64_t start_time = tbsys::CTimeUtil::getTime(); //const int64_t MAX_COUNT = 10 * 1000 * 1000L; const int64_t MAX_COUNT = 1000L; ObObj obj; char buf[2048]; int64_t len = 2048; int64_t pos = 0; int64_t data = 0; for (int64_t i = 0; i < MAX_COUNT; ++i) { obj.set_int(i); pos = 0; ASSERT_EQ(obj.serialize(buf, len, pos), OB_SUCCESS); pos = 0; ASSERT_EQ(obj.deserialize(buf, len, pos), OB_SUCCESS); ASSERT_EQ(obj.get_int(data), OB_SUCCESS); ASSERT_EQ(data, i); } const char *tmp = "Hello12344556666777777777777545352454254254354354565463241242354345345345235345"; ObObj obj2; ObString string; ObString string2; string.assign_ptr(const_cast<char *>(tmp), 1024); obj2.set_varchar(string); for (register int64_t i = 0; i < MAX_COUNT; ++i ) { pos = 0; ASSERT_EQ(obj2.serialize(buf, len, pos), OB_SUCCESS); pos = 0; ASSERT_EQ(obj2.deserialize(buf, len, pos), OB_SUCCESS); ASSERT_EQ(obj2.get_varchar(string2), OB_SUCCESS); } // int64_t end_time = tbsys::CTimeUtil::getTime(); //printf("using time:%ld\n", end_time - start_time); }
////////////////////// SERIALIZATION /////////////////////// int ObSqlReadParam::serialize_basic_param(char * buf, const int64_t buf_len, int64_t & pos) const { ObObj obj; int ret = OB_SUCCESS; // read consistency if (ret == OB_SUCCESS) { obj.set_int(get_is_read_consistency()); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret); } } // result cached if (ret == OB_SUCCESS) { obj.set_int(get_is_result_cached()); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret); } } // data version if (ret == OB_SUCCESS) { obj.set_int(get_data_version()); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize basic param. buf=%p, buf_len=%ld, pos=%ld, ret=%d", buf, buf_len, pos, ret); } } // table id if (OB_SUCCESS == ret) { if (OB_INVALID_ID != table_id_) { obj.set_int(table_id_); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize table id = %lu", table_id_); } } else { TBSYS_LOG(WARN, "Invalid table_id_. table_id_=%ld", table_id_); ret = OB_INVALID_ARGUMENT; } } // renamed table id if (OB_SUCCESS == ret) { if (OB_INVALID_ID != renamed_table_id_) { obj.set_int(renamed_table_id_); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize renamed table id = %lu", renamed_table_id_); } } else { TBSYS_LOG(WARN, "Invalid renamed_table_id_. renamed_table_id_=%ld", renamed_table_id_); ret = OB_INVALID_ARGUMENT; } } if (OB_SUCCESS == ret) { obj.set_bool(only_static_data_); if (OB_SUCCESS != (ret = obj.serialize(buf, buf_len, pos))) { TBSYS_LOG(WARN, "fail to serialize bool:ret[%d]", ret); } } return ret; }
int gen_sst(const gen_param ¶m) { ObSSTableSchema *sst_schema = new(std::nothrow)ObSSTableSchema; ObSSTableWriter sst_writer; ObSSTableRow sst_row; tbsys::CConfig config; ObSchemaManagerV2 *mgr = new(std::nothrow) ObSchemaManagerV2; int err = OB_SUCCESS; if ((NULL == mgr) || (NULL == sst_schema)) { err = OB_ALLOCATE_MEMORY_FAILED; TBSYS_LOG(WARN,"fail to allocate memory for ObSchemaManagerV2"); } if ((OB_SUCCESS == err) && (!mgr->parse_from_file(param.schema_,config))) { TBSYS_LOG(WARN,"fail to load schema from file [err:%d,schema.ini:%s]", err, param.schema_); err = OB_INVALID_ARGUMENT; } if ((OB_SUCCESS == err) && (OB_SUCCESS != (err = fill_sstable_schema(*mgr,msolap::target_table_id,*sst_schema)))) { TBSYS_LOG(WARN,"fail to fill sst schema [err:%d, table_id:%lu]", err, msolap::target_table_id); } ObTrailerParam trailer_param; trailer_param.block_size_ = msolap::ups_sst_block_size; trailer_param.compressor_name_.assign((char*)msolap::ups_sst_compressor_name, static_cast<int32_t>(strlen(msolap::ups_sst_compressor_name))); trailer_param.frozen_time_ = tbsys::CTimeUtil::getTime(); trailer_param.store_type_ = msolap::ups_sst_store_type; trailer_param.table_version_ = msolap::ups_sst_version; ObString sst_path(static_cast<int32_t>(strlen(param.sst_name_)), static_cast<int32_t>(strlen(param.sst_name_)),(char*)param.sst_name_); if ((OB_SUCCESS == err) && (OB_SUCCESS != sst_writer.create_sstable(*sst_schema,sst_path, trailer_param))) { TBSYS_LOG(WARN,"fail to create sst [err:%d,sst_path:%s]", err, param.sst_name_); } uint32_t big_endian_row_key = 0; int64_t space_usage = 0; ObString row_key_str(sizeof(big_endian_row_key), sizeof(big_endian_row_key), (char*)&big_endian_row_key); if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_row.set_obj_count(msolap::max_column_id - msolap::min_column_id + 1)))) { TBSYS_LOG(WARN,"fail to call sst_row.set_obj_count [err:%d]", err); } for (uint32_t row_key = param.start_include_; (OB_SUCCESS == err) && (row_key <= param.end_include_); row_key++) { big_endian_row_key = htonl(row_key); sst_row.clear(); if ((OB_SUCCESS == err) &&(OB_SUCCESS != (err = sst_row.set_rowkey(TestRowkeyHelper(row_key_str, &allocator_))))) { TBSYS_LOG(WARN,"fail to set sst row rowkey [err:%d]", err); } if((OB_SUCCESS == err) && (OB_SUCCESS !=(err = sst_row.set_table_id(msolap::target_table_id)))) { TBSYS_LOG(WARN,"fail to set sst row table id [err:%d]", err); } if((OB_SUCCESS == err) && (OB_SUCCESS !=(err = sst_row.set_column_group_id(msolap::ups_sst_column_group_id)))) { TBSYS_LOG(WARN,"fail to set sst row group id [err:%d]", err); } for (uint64_t column_id = msolap::min_column_id; (OB_SUCCESS == err)&&(column_id <= msolap::max_column_id); column_id ++) { ObObj val; val.set_int(msolap::olap_get_column_val(column_id,big_endian_row_key)); if (OB_SUCCESS != (err = sst_row.add_obj(val))) { TBSYS_LOG(WARN,"fail to add obj to sst row [err:%d]", err); } } assert(OB_SUCCESS == sst_row.check_schema(*sst_schema)); if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_writer.append_row(sst_row,space_usage)))) { TBSYS_LOG(WARN,"fail to append row to sst writer [err:%d]", err); } } int64_t trailer_offset = 0; int64_t sst_size = 0; if((OB_SUCCESS == err) && (OB_SUCCESS != (err = sst_writer.close_sstable(trailer_offset, sst_size)))) { TBSYS_LOG(WARN,"fail to close sst [err:%d]", err); } else { TBSYS_LOG(INFO, "sst write success [trailer_offset:%ld,sst_size:%ld]", trailer_offset, sst_size); } delete sst_schema; delete mgr; return err; }
int ObStatManager::get_scanner(ObNewScanner &scanner) const { int ret = OB_SUCCESS; int64_t last_used_mod = OB_INVALID_ID; char ipbuf[OB_IP_STR_BUFF] = {0}; server_.ip_to_string(ipbuf, sizeof (ipbuf)); ObString ipstr = ObString::make_string(ipbuf); const int32_t port = server_.get_port(); ObString server_name = ObString::make_string(print_role(get_server_type())); int64_t total_stat_cnt = 0; /* create row_desc */ ObRowDesc row_desc; int32_t column_id = OB_APP_MIN_COLUMN_ID; row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++); row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++); row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++); row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++); row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++); row_desc.set_rowkey_cell_count(4); ObRow row; ObObj obj; // drop mod id info for (int32_t mod = 0; mod < OB_MAX_MOD_NUMBER; mod++) { ObStat stat; total_stat_cnt += stat_cnt_[mod]; // drop table id info for (int32_t i = 0; i < table_stats_[mod].get_array_index(); i++) { for (int32_t j = 0; j < stat_cnt_[mod]; j++) { stat.inc(j, table_stats_[mod].at(i)->get_value(j)); } } for (int32_t i = 0; i < stat_cnt_[mod]; i++) { column_id = OB_APP_MIN_COLUMN_ID; row.set_row_desc(row_desc); row.reset(false, ObRow::DEFAULT_NULL); /* server type */ obj.set_type(ObVarcharType); obj.set_varchar(server_name); row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj); /* server ip */ obj.set_type(ObVarcharType); obj.set_varchar(ipstr); row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj); /* port */ obj.set_type(ObIntType); obj.set_int(port); row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj); /* key */ obj.set_type(ObVarcharType); obj.set_varchar(ObString::make_string(get_name(mod, i))); row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj); /* value */ obj.set_type(ObIntType); obj.set_int(stat.get_value(i)); row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj); scanner.add_row(row); // for last rowkey last_used_mod = mod; } } /* last rowkey */ if (total_stat_cnt > 0) { static ObObj rk_objs[4]; rk_objs[0].set_type(ObVarcharType); rk_objs[0].set_varchar(server_name); rk_objs[1].set_type(ObVarcharType); rk_objs[1].set_varchar(ipstr); rk_objs[2].set_type(ObIntType); rk_objs[2].set_int(port); rk_objs[3].set_type(ObVarcharType); rk_objs[3].set_varchar(ObString::make_string(get_name(last_used_mod, stat_cnt_[last_used_mod] - 1))); ObRowkey rowkey(rk_objs, 4); scanner.set_last_row_key(rowkey); } /* fullfilled */ scanner.set_is_req_fullfilled(true, total_stat_cnt); return ret; }
ObObj gen_int_obj(int64_t int_value, bool is_add = false) { ObObj value; value.set_int(int_value, is_add); return value; }