diff --git a/src/storage/blocksstable/ob_datum_rowkey_vector.cpp b/src/storage/blocksstable/ob_datum_rowkey_vector.cpp
index 8a32f7a36..0b9bd44f4 100644
--- a/src/storage/blocksstable/ob_datum_rowkey_vector.cpp
+++ b/src/storage/blocksstable/ob_datum_rowkey_vector.cpp
@@ -738,6 +738,38 @@ int compare_column_row_idx<ObStorageDatum>(
   return ret;
 }
 
+template<typename T>
+int compare_column_datum_row_idx(
+    ObColumnVector &left_vector,
+    ObStorageDatum &right_datum,
+    const int64_t left_row_idx,
+    const bool is_oracle_mode,
+    int &cmp_ret)
+{
+  int ret = OB_SUCCESS;
+  ObRVIntegerWithNullComparor<int64_t> comparor(!is_oracle_mode);
+  ObRVIntegerCell<int64_t> left(left_vector.signed_ints_[left_row_idx], left_vector.nulls_[left_row_idx]);
+  ObRVIntegerCell<int64_t> right(right_datum.get_int(), right_datum.is_null());
+  cmp_ret = comparor.compare(left, right);
+  return ret;
+}
+
+template<>
+int compare_column_datum_row_idx<uint64_t>(
+    ObColumnVector &left_vector,
+    ObStorageDatum &right_datum,
+    const int64_t left_row_idx,
+    const bool is_oracle_mode,
+    int &cmp_ret)
+{
+  int ret = OB_SUCCESS;
+  ObRVIntegerWithNullComparor<uint64_t> comparor(!is_oracle_mode);
+  ObRVIntegerCell<uint64_t> left(left_vector.unsigned_ints_[left_row_idx], left_vector.nulls_[left_row_idx]);
+  ObRVIntegerCell<uint64_t> right(right_datum.get_uint(), right_datum.is_null());
+  cmp_ret = comparor.compare(left, right);
+  return ret;
+}
+
 typedef int (*compare_column_value_func) (
     ObColumnVector &left_vector,
     ObColumnVector &right_vector,
@@ -749,6 +781,15 @@ typedef int (*compare_column_value_func) (
 static compare_column_value_func COMPARE_COLUMN_VALUE_FUNCS[(int8_t)ObColumnVectorType::MAX_TYPE + 1] =
 { compare_column_row_idx<ObStorageDatum>, compare_column_row_idx<int64_t>, compare_column_row_idx<uint64_t> };
 
+typedef int (*compare_column_value_datum_func) (
+    ObColumnVector &left_vector,
+    ObStorageDatum &right_datum,
+    const int64_t left_row_idx,
+    const bool is_oracle_mode,
+    int &cmp_ret);
+static compare_column_value_datum_func COMPARE_COLUMN_VALUE_DATUM_FUNCS[(int8_t)ObColumnVectorType::MAX_TYPE + 1] =
+{ nullptr, compare_column_datum_row_idx<int64_t>, compare_column_datum_row_idx<uint64_t> };
+
 int ObRowkeyVector::compare_rowkey(
     const ObDiscreteDatumRowkey &rowkey,
     const int64_t row_idx,
@@ -772,12 +813,26 @@ int ObRowkeyVector::compare_rowkey(
     const bool is_oracle_mode = datum_utils.is_oracle_mode();
     cmp_ret = 0;
     for (int64_t i = 0; OB_SUCC(ret) && i < col_cnt_ && 0 == cmp_ret; ++i) {
-      compare_column_value_func func = COMPARE_COLUMN_VALUE_FUNCS[(int8_t)columns_[i].type_];
-      if (OB_UNLIKELY(columns_[i].type_ != rowkey.rowkey_vector_->columns_[i].type_)) {
+      if (OB_LIKELY(columns_[i].type_ == rowkey.rowkey_vector_->columns_[i].type_)) {
+        compare_column_value_func func = COMPARE_COLUMN_VALUE_FUNCS[(int8_t)columns_[i].type_];
+        if (OB_FAIL(func(columns_[i], rowkey.rowkey_vector_->columns_[i], row_idx, rowkey.row_idx_, cmp_funcs.at(i), is_oracle_mode, cmp_ret))) {
+          LOG_WARN("Failed to compare key", K(ret));
+        }
+      } else if (ObColumnVectorType::DATUM_TYPE == rowkey.rowkey_vector_->columns_[i].type_) {
+        compare_column_value_datum_func func = COMPARE_COLUMN_VALUE_DATUM_FUNCS[(int8_t)columns_[i].type_];
+        if (OB_FAIL(func(columns_[i], rowkey.rowkey_vector_->columns_[i].datums_[rowkey.row_idx_], row_idx, is_oracle_mode, cmp_ret))) {
+          LOG_WARN("Failed to compare key", K(ret));
+        }
+      } else if (ObColumnVectorType::DATUM_TYPE == columns_[i].type_) {
+        compare_column_value_datum_func func = COMPARE_COLUMN_VALUE_DATUM_FUNCS[(int8_t)rowkey.rowkey_vector_->columns_[i].type_];
+        if (OB_FAIL(func(rowkey.rowkey_vector_->columns_[i], columns_[i].datums_[row_idx], rowkey.row_idx_, is_oracle_mode, cmp_ret))) {
+          LOG_WARN("Failed to compare key", K(ret));
+        } else {
+          cmp_ret = -cmp_ret;
+        }
+      } else {
         ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("Unexpected not equal column type", K(ret), K(columns_[i]), K(rowkey.rowkey_vector_->columns_[i]));
-      } else if (OB_FAIL(func(columns_[i], rowkey.rowkey_vector_->columns_[i], row_idx, rowkey.row_idx_, cmp_funcs.at(i), is_oracle_mode, cmp_ret))) {
-        LOG_WARN("Failed to compare key", K(ret));
+        LOG_WARN("Unexpected not equal column type", K(ret), K(i), K(columns_[i]), K(rowkey.rowkey_vector_->columns_[i]));
       }
     }
   }
diff --git a/unittest/storage/blocksstable/test_datum_rowkey_vector.cpp b/unittest/storage/blocksstable/test_datum_rowkey_vector.cpp
index f55fdfe3a..f8b6259f9 100644
--- a/unittest/storage/blocksstable/test_datum_rowkey_vector.cpp
+++ b/unittest/storage/blocksstable/test_datum_rowkey_vector.cpp
@@ -841,6 +841,131 @@ TEST_F(ObDatumRowkeyVectorTest, rowkey_vector_compare_rowkey)
   ASSERT_EQ(int_val, 2);
 }
 
+TEST_F(ObDatumRowkeyVectorTest, rowkey_vector_compare_rowkey_datum)
+{
+  int ret = 0;
+  ObStorageDatumUtils datum_utils;
+  prepare_datum_util(2, datum_utils);
+
+  int64_t row_count = 13;
+  int64_t int_arr0[13] =   {1,1,1,2,2,2,2,2,3,3,4,5,7};
+  bool bool_arr0[13] = {false,false,false,false,false,false,false,false,false,false,false,false,false};
+  uint64_t uint_arr1[13] = {2,3,4,1,1,1,2,3,4,5,6,6,8};
+  bool bool_arr1[13] = {false,false,false,false,false,false,false,false,false,false,false,false,false};
+  ObColumnVector int_vec0;
+  int_vec0.type_ = ObColumnVectorType::SIGNED_INTEGER_TYPE;
+  int_vec0.row_cnt_ = row_count;
+  int_vec0.has_null_ = false;
+  int_vec0.signed_ints_ = int_arr0;
+  int_vec0.nulls_ = bool_arr0;
+  ObColumnVector uint_vec1;
+  uint_vec1.type_ = ObColumnVectorType::UNSIGNED_INTEGER_TYPE;
+  uint_vec1.row_cnt_ = row_count;
+  uint_vec1.has_null_ = false;
+  uint_vec1.unsigned_ints_ = uint_arr1;
+  uint_vec1.nulls_ = bool_arr1;
+
+  ObColumnVector col_vectors1[2];
+  col_vectors1[0] = int_vec0;
+  col_vectors1[1] = uint_vec1;
+  ObRowkeyVector rowkey_vector1;
+  rowkey_vector1.columns_ = col_vectors1;
+  rowkey_vector1.col_cnt_ = 2;
+  rowkey_vector1.row_cnt_ = row_count;
+
+  void *buf = allocator_.alloc(sizeof(ObStorageDatum) * row_count);
+  ASSERT_TRUE(buf != nullptr);
+  ObStorageDatum *datums = new (buf) ObStorageDatum[row_count];
+  ObColumnVector datum_vec0;
+  datum_vec0.type_ = ObColumnVectorType::DATUM_TYPE;
+  datum_vec0.row_cnt_ = row_count;
+  datum_vec0.datums_ = datums;
+  for (int64_t i = 0; i < row_count; ++i) {
+    datums[i].set_int(i);
+  }
+
+  buf = allocator_.alloc(sizeof(ObStorageDatum) *row_count);
+  ASSERT_TRUE(buf != nullptr);
+  datums = new (buf) ObStorageDatum[row_count];
+  ObColumnVector datum_vec1;
+  datum_vec1.type_ = ObColumnVectorType::DATUM_TYPE;
+  datum_vec1.row_cnt_ = row_count;
+  datum_vec1.datums_ = datums;
+  for (int64_t i = 0; i < row_count; ++i) {
+    datums[i].set_uint(i);
+  }
+
+  ObColumnVector col_vectors2[2];
+  col_vectors2[0] = datum_vec0;
+  col_vectors2[1] = datum_vec1;
+  ObRowkeyVector rowkey_vector2;
+  rowkey_vector2.columns_ = col_vectors2;
+  rowkey_vector2.col_cnt_ = 2;
+  rowkey_vector2.row_cnt_ = row_count;
+  rowkey_vector2.is_datum_vectors_ = 1;
+
+  ObDiscreteDatumRowkey discrete_rowkey;
+  discrete_rowkey.row_idx_ = 0;
+  discrete_rowkey.rowkey_vector_ = &rowkey_vector2;
+  int cmp_ret = 0;
+  bool compare_datum_cnt = true;
+  ret = rowkey_vector1.compare_rowkey(discrete_rowkey, 0, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret > 0);
+
+  discrete_rowkey.row_idx_ = 2;
+  ret = rowkey_vector1.compare_rowkey(discrete_rowkey, 6, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret == 0);
+
+  discrete_rowkey.row_idx_ = 3;
+  ret = rowkey_vector1.compare_rowkey(discrete_rowkey, 3, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret < 0);
+
+  discrete_rowkey.row_idx_ = 12;
+  discrete_rowkey.rowkey_vector_ = &rowkey_vector1;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 9, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret > 0);
+
+  discrete_rowkey.row_idx_ = 6;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 2, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret == 0);
+
+  discrete_rowkey.row_idx_ = 8;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 3, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret < 0);
+
+  discrete_rowkey.row_idx_ = 12;
+  discrete_rowkey.rowkey_vector_ = &rowkey_vector2;
+  for (int64_t i = 0; i < row_count; ++i) {
+    datum_vec0.datums_[i].set_null();
+  }
+  ret = rowkey_vector1.compare_rowkey(discrete_rowkey, 0, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret > 0);
+
+  bool_arr0[0] = bool_arr0[1] = true;
+  discrete_rowkey.row_idx_ = 1;
+  discrete_rowkey.rowkey_vector_ = &rowkey_vector1;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 3, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret == 0);
+
+  discrete_rowkey.row_idx_ = 1;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 4, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret > 0);
+
+  discrete_rowkey.row_idx_ = 1;
+  ret = rowkey_vector2.compare_rowkey(discrete_rowkey, 1, datum_utils, cmp_ret, compare_datum_cnt);
+  ASSERT_EQ(ret, OB_SUCCESS);
+  ASSERT_TRUE(cmp_ret < 0);
+}
+
 TEST_F(ObDatumRowkeyVectorTest, rowkey_vector_deep_copy)
 {
   int ret = 0;