diff --git a/pkg/import_sstpb/import_sstpb.pb.go b/pkg/import_sstpb/import_sstpb.pb.go
index 4d22cf0a2..3cb7cb19d 100644
--- a/pkg/import_sstpb/import_sstpb.pb.go
+++ b/pkg/import_sstpb/import_sstpb.pb.go
@@ -56,7 +56,7 @@ func (x SwitchMode) String() string {
 	return proto.EnumName(SwitchMode_name, int32(x))
 }
 func (SwitchMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{0}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{0}
 }
 
 type SwitchModeRequest struct {
@@ -70,7 +70,7 @@ func (m *SwitchModeRequest) Reset()         { *m = SwitchModeRequest{} }
 func (m *SwitchModeRequest) String() string { return proto.CompactTextString(m) }
 func (*SwitchModeRequest) ProtoMessage()    {}
 func (*SwitchModeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{0}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{0}
 }
 func (m *SwitchModeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -116,7 +116,7 @@ func (m *SwitchModeResponse) Reset()         { *m = SwitchModeResponse{} }
 func (m *SwitchModeResponse) String() string { return proto.CompactTextString(m) }
 func (*SwitchModeResponse) ProtoMessage()    {}
 func (*SwitchModeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{1}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{1}
 }
 func (m *SwitchModeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -157,7 +157,7 @@ func (m *Range) Reset()         { *m = Range{} }
 func (m *Range) String() string { return proto.CompactTextString(m) }
 func (*Range) ProtoMessage()    {}
 func (*Range) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{2}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{2}
 }
 func (m *Range) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -208,6 +208,7 @@ type SSTMeta struct {
 	CfName               string              `protobuf:"bytes,5,opt,name=cf_name,json=cfName,proto3" json:"cf_name,omitempty"`
 	RegionId             uint64              `protobuf:"varint,6,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
 	RegionEpoch          *metapb.RegionEpoch `protobuf:"bytes,7,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"`
+	EndKeyExclusive      bool                `protobuf:"varint,8,opt,name=end_key_exclusive,json=endKeyExclusive,proto3" json:"end_key_exclusive,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
 	XXX_unrecognized     []byte              `json:"-"`
 	XXX_sizecache        int32               `json:"-"`
@@ -217,7 +218,7 @@ func (m *SSTMeta) Reset()         { *m = SSTMeta{} }
 func (m *SSTMeta) String() string { return proto.CompactTextString(m) }
 func (*SSTMeta) ProtoMessage()    {}
 func (*SSTMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{3}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{3}
 }
 func (m *SSTMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -295,6 +296,13 @@ func (m *SSTMeta) GetRegionEpoch() *metapb.RegionEpoch {
 	return nil
 }
 
+func (m *SSTMeta) GetEndKeyExclusive() bool {
+	if m != nil {
+		return m.EndKeyExclusive
+	}
+	return false
+}
+
 // A rewrite rule is applied on the *encoded* keys (the internal storage
 // representation).
 type RewriteRule struct {
@@ -310,7 +318,7 @@ func (m *RewriteRule) Reset()         { *m = RewriteRule{} }
 func (m *RewriteRule) String() string { return proto.CompactTextString(m) }
 func (*RewriteRule) ProtoMessage()    {}
 func (*RewriteRule) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{4}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{4}
 }
 func (m *RewriteRule) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -374,7 +382,7 @@ func (m *UploadRequest) Reset()         { *m = UploadRequest{} }
 func (m *UploadRequest) String() string { return proto.CompactTextString(m) }
 func (*UploadRequest) ProtoMessage()    {}
 func (*UploadRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{5}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{5}
 }
 func (m *UploadRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -520,7 +528,7 @@ func (m *UploadResponse) Reset()         { *m = UploadResponse{} }
 func (m *UploadResponse) String() string { return proto.CompactTextString(m) }
 func (*UploadResponse) ProtoMessage()    {}
 func (*UploadResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{6}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{6}
 }
 func (m *UploadResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -561,7 +569,7 @@ func (m *IngestRequest) Reset()         { *m = IngestRequest{} }
 func (m *IngestRequest) String() string { return proto.CompactTextString(m) }
 func (*IngestRequest) ProtoMessage()    {}
 func (*IngestRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{7}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{7}
 }
 func (m *IngestRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -615,7 +623,7 @@ func (m *IngestResponse) Reset()         { *m = IngestResponse{} }
 func (m *IngestResponse) String() string { return proto.CompactTextString(m) }
 func (*IngestResponse) ProtoMessage()    {}
 func (*IngestResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{8}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{8}
 }
 func (m *IngestResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -666,7 +674,7 @@ func (m *CompactRequest) Reset()         { *m = CompactRequest{} }
 func (m *CompactRequest) String() string { return proto.CompactTextString(m) }
 func (*CompactRequest) ProtoMessage()    {}
 func (*CompactRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{9}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{9}
 }
 func (m *CompactRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -719,7 +727,7 @@ func (m *CompactResponse) Reset()         { *m = CompactResponse{} }
 func (m *CompactResponse) String() string { return proto.CompactTextString(m) }
 func (*CompactResponse) ProtoMessage()    {}
 func (*CompactResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{10}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{10}
 }
 func (m *CompactResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -771,6 +779,7 @@ type DownloadRequest struct {
 	// same order, otherwise the RPC request will fail.
 	RewriteRule          RewriteRule            `protobuf:"bytes,13,opt,name=rewrite_rule,json=rewriteRule" json:"rewrite_rule"`
 	StorageBackend       *backup.StorageBackend `protobuf:"bytes,14,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"`
+	IsRawKv              bool                   `protobuf:"varint,15,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
 	XXX_unrecognized     []byte                 `json:"-"`
 	XXX_sizecache        int32                  `json:"-"`
@@ -780,7 +789,7 @@ func (m *DownloadRequest) Reset()         { *m = DownloadRequest{} }
 func (m *DownloadRequest) String() string { return proto.CompactTextString(m) }
 func (*DownloadRequest) ProtoMessage()    {}
 func (*DownloadRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{11}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{11}
 }
 func (m *DownloadRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -837,6 +846,13 @@ func (m *DownloadRequest) GetStorageBackend() *backup.StorageBackend {
 	return nil
 }
 
+func (m *DownloadRequest) GetIsRawKv() bool {
+	if m != nil {
+		return m.IsRawKv
+	}
+	return false
+}
+
 // For now it is just used for distinguishing the error of the request with the error
 // of gRPC, add more concrete types if it is necessary later.
 type Error struct {
@@ -850,7 +866,7 @@ func (m *Error) Reset()         { *m = Error{} }
 func (m *Error) String() string { return proto.CompactTextString(m) }
 func (*Error) ProtoMessage()    {}
 func (*Error) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{12}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{12}
 }
 func (m *Error) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -909,7 +925,7 @@ func (m *DownloadResponse) Reset()         { *m = DownloadResponse{} }
 func (m *DownloadResponse) String() string { return proto.CompactTextString(m) }
 func (*DownloadResponse) ProtoMessage()    {}
 func (*DownloadResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{13}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{13}
 }
 func (m *DownloadResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -985,7 +1001,7 @@ func (m *SetDownloadSpeedLimitRequest) Reset()         { *m = SetDownloadSpeedLi
 func (m *SetDownloadSpeedLimitRequest) String() string { return proto.CompactTextString(m) }
 func (*SetDownloadSpeedLimitRequest) ProtoMessage()    {}
 func (*SetDownloadSpeedLimitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{14}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{14}
 }
 func (m *SetDownloadSpeedLimitRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1031,7 +1047,7 @@ func (m *SetDownloadSpeedLimitResponse) Reset()         { *m = SetDownloadSpeedL
 func (m *SetDownloadSpeedLimitResponse) String() string { return proto.CompactTextString(m) }
 func (*SetDownloadSpeedLimitResponse) ProtoMessage()    {}
 func (*SetDownloadSpeedLimitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_import_sstpb_8e442ba0a01591dd, []int{15}
+	return fileDescriptor_import_sstpb_789900542ce0f450, []int{15}
 }
 func (m *SetDownloadSpeedLimitResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1506,6 +1522,16 @@ func (m *SSTMeta) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n2
 	}
+	if m.EndKeyExclusive {
+		dAtA[i] = 0x40
+		i++
+		if m.EndKeyExclusive {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
@@ -1799,6 +1825,16 @@ func (m *DownloadRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n11
 	}
+	if m.IsRawKv {
+		dAtA[i] = 0x78
+		i++
+		if m.IsRawKv {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
@@ -2013,6 +2049,9 @@ func (m *SSTMeta) Size() (n int) {
 		l = m.RegionEpoch.Size()
 		n += 1 + l + sovImportSstpb(uint64(l))
 	}
+	if m.EndKeyExclusive {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -2148,6 +2187,9 @@ func (m *DownloadRequest) Size() (n int) {
 		l = m.StorageBackend.Size()
 		n += 1 + l + sovImportSstpb(uint64(l))
 	}
+	if m.IsRawKv {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -2671,6 +2713,26 @@ func (m *SSTMeta) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EndKeyExclusive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.EndKeyExclusive = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipImportSstpb(dAtA[iNdEx:])
@@ -3495,6 +3557,26 @@ func (m *DownloadRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowImportSstpb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsRawKv = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipImportSstpb(dAtA[iNdEx:])
@@ -3995,68 +4077,71 @@ var (
 	ErrIntOverflowImportSstpb   = fmt.Errorf("proto: integer overflow")
 )
 
-func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_import_sstpb_8e442ba0a01591dd) }
-
-var fileDescriptor_import_sstpb_8e442ba0a01591dd = []byte{
-	// 946 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xdb, 0x72, 0xdb, 0x44,
-	0x18, 0xb6, 0xb0, 0x7c, 0xfa, 0x7d, 0x88, 0xbb, 0xa4, 0x45, 0x75, 0xdb, 0x24, 0x15, 0x1d, 0x30,
-	0x29, 0x38, 0x33, 0xee, 0x4c, 0x6f, 0x3b, 0xb8, 0x64, 0x68, 0xe8, 0x61, 0x60, 0x1d, 0xae, 0x98,
-	0x41, 0xa3, 0x48, 0x1b, 0x47, 0x63, 0x49, 0x2b, 0x76, 0x57, 0x71, 0x73, 0xc3, 0x73, 0xf0, 0x08,
-	0xbc, 0x01, 0xaf, 0xd0, 0x4b, 0x2e, 0xb9, 0x62, 0x98, 0xd0, 0x97, 0xe0, 0x8e, 0xd9, 0x83, 0x7c,
-	0x1a, 0x9b, 0x70, 0xe5, 0xff, 0xf0, 0xe9, 0xfb, 0xff, 0xfd, 0x4f, 0x06, 0x14, 0x25, 0x19, 0x65,
-	0xc2, 0xe3, 0x5c, 0x64, 0x67, 0x83, 0x8c, 0x51, 0x41, 0x51, 0x6b, 0xd9, 0xd6, 0x6b, 0x25, 0x44,
-	0xf8, 0x85, 0xaf, 0xd7, 0x26, 0x8c, 0x51, 0xb6, 0x50, 0xa7, 0x97, 0x2c, 0x0b, 0xe6, 0xea, 0xee,
-	0x84, 0x4e, 0xa8, 0x12, 0x8f, 0xa4, 0x64, 0xac, 0x3b, 0x2c, 0xe7, 0x42, 0x89, 0xc6, 0xd0, 0x3a,
-	0xf3, 0x83, 0x69, 0x9e, 0x69, 0xcd, 0xfd, 0x12, 0x6e, 0x8d, 0x67, 0x91, 0x08, 0x2e, 0x5e, 0xd3,
-	0x90, 0x60, 0xf2, 0x53, 0x4e, 0xb8, 0x40, 0x9f, 0x83, 0x9d, 0xd0, 0x90, 0x38, 0xd6, 0x81, 0xd5,
-	0xef, 0x0c, 0x9d, 0xc1, 0x4a, 0x9a, 0x4b, 0x70, 0x85, 0x72, 0x77, 0x01, 0x2d, 0x53, 0xf0, 0x8c,
-	0xa6, 0x9c, 0xb8, 0x47, 0x50, 0xc1, 0x7e, 0x3a, 0x21, 0x68, 0x17, 0x2a, 0x5c, 0xf8, 0x4c, 0x28,
-	0xb6, 0x16, 0xd6, 0x0a, 0xea, 0x42, 0x99, 0xa4, 0xa1, 0xf3, 0x81, 0xb2, 0x49, 0xd1, 0x7d, 0x6f,
-	0x41, 0x6d, 0x3c, 0x3e, 0x7d, 0x4d, 0x84, 0x8f, 0x10, 0xd8, 0x79, 0x1e, 0x85, 0xe6, 0x13, 0x25,
-	0xa3, 0xcf, 0xa0, 0xc2, 0x24, 0xa1, 0xfa, 0xa6, 0x39, 0xfc, 0x70, 0x35, 0x2b, 0x15, 0x0b, 0x6b,
-	0x84, 0x0c, 0x19, 0xb0, 0xe0, 0xc9, 0xd0, 0x29, 0x1f, 0x58, 0xfd, 0x36, 0xd6, 0x0a, 0xba, 0x03,
-	0xd5, 0x98, 0xa4, 0x13, 0x71, 0xe1, 0xd8, 0x07, 0x56, 0xdf, 0xc6, 0x46, 0x43, 0x1f, 0x41, 0x2d,
-	0x38, 0xf7, 0x52, 0x3f, 0x21, 0x4e, 0xe5, 0xc0, 0xea, 0x37, 0x70, 0x35, 0x38, 0x7f, 0xe3, 0x27,
-	0x04, 0xdd, 0x83, 0x06, 0x23, 0x93, 0x88, 0xa6, 0x5e, 0x14, 0x3a, 0x55, 0xf5, 0x4d, 0x5d, 0x1b,
-	0x4e, 0x42, 0xf4, 0x14, 0x5a, 0xc6, 0x49, 0x32, 0x1a, 0x5c, 0x38, 0x35, 0x93, 0x95, 0x69, 0x18,
-	0x56, 0xbe, 0x63, 0xe9, 0xc2, 0x4d, 0xb6, 0x50, 0xdc, 0x9f, 0xa1, 0x89, 0xc9, 0x8c, 0x45, 0x82,
-	0xe0, 0x3c, 0x26, 0xe8, 0x11, 0x74, 0x68, 0x1c, 0x7a, 0x53, 0x72, 0xe5, 0x65, 0x8c, 0x9c, 0x47,
-	0x6f, 0xcd, 0x9b, 0x5b, 0x34, 0x0e, 0x5f, 0x92, 0xab, 0x6f, 0x95, 0x4d, 0xa2, 0x52, 0x32, 0x5b,
-	0x46, 0xe9, 0xc2, 0xb5, 0x52, 0x32, 0x5b, 0xa0, 0x3e, 0x86, 0xb6, 0x44, 0x89, 0x28, 0x21, 0x5c,
-	0xf8, 0x49, 0xa6, 0x9e, 0x6f, 0x2b, 0xd0, 0x69, 0x61, 0x73, 0x7f, 0x80, 0xf6, 0xf7, 0x59, 0x4c,
-	0xfd, 0xb0, 0x68, 0xf6, 0x63, 0xb0, 0x65, 0xce, 0x2a, 0x6e, 0x73, 0x78, 0x7b, 0xad, 0xd9, 0xba,
-	0x21, 0x2f, 0x4a, 0x58, 0x81, 0xd0, 0x2e, 0xd8, 0xa1, 0x2f, 0x7c, 0x1d, 0x5e, 0x5a, 0xa5, 0x36,
-	0xaa, 0x41, 0x25, 0xb8, 0xc8, 0xd3, 0xa9, 0xdb, 0x85, 0x4e, 0x41, 0x6e, 0xc6, 0x20, 0x84, 0xf6,
-	0x49, 0x3a, 0x21, 0x5c, 0x14, 0xe1, 0x0e, 0xa1, 0x16, 0xd0, 0x54, 0x90, 0xb7, 0xc2, 0x44, 0xec,
-	0x0e, 0x8a, 0x31, 0x7e, 0xae, 0xed, 0xb8, 0x00, 0xa0, 0x4f, 0xa1, 0xcc, 0xb9, 0x30, 0x0d, 0xdf,
-	0x9c, 0x19, 0x96, 0x08, 0xf7, 0x29, 0x74, 0x8a, 0x28, 0x3a, 0x2e, 0x7a, 0x04, 0x15, 0xb5, 0x2c,
-	0x26, 0x48, 0x67, 0x50, 0xac, 0xce, 0xb1, 0xfc, 0xc5, 0xda, 0xe9, 0xfe, 0x08, 0x9d, 0xe7, 0x34,
-	0xc9, 0xfc, 0x60, 0x9e, 0xde, 0x7c, 0xca, 0xac, 0x1b, 0xa7, 0xec, 0x21, 0xb4, 0x68, 0x2e, 0xb2,
-	0x5c, 0x78, 0x31, 0xb9, 0x24, 0xb1, 0x4a, 0xb3, 0x82, 0x9b, 0xda, 0xf6, 0x4a, 0x9a, 0xdc, 0x5b,
-	0xb0, 0x33, 0xe7, 0x37, 0x05, 0x79, 0x6f, 0xc1, 0xce, 0x57, 0x74, 0x96, 0x2e, 0xb7, 0xe0, 0x8b,
-	0x9b, 0xdf, 0x39, 0xb2, 0xdf, 0xfd, 0xb9, 0x5f, 0x52, 0xaf, 0x95, 0xdb, 0xa1, 0xa6, 0xb5, 0xa1,
-	0xa6, 0x55, 0xc9, 0x68, 0x24, 0xc7, 0x51, 0x8d, 0x95, 0xc7, 0xf2, 0x98, 0x38, 0x6d, 0xc5, 0x75,
-	0x77, 0x2d, 0xfd, 0xc5, 0xe0, 0x19, 0xbe, 0x26, 0x5b, 0x9a, 0xc5, 0x67, 0xb0, 0xc3, 0x05, 0x65,
-	0xfe, 0x84, 0x78, 0xf2, 0x46, 0xc8, 0xfd, 0xec, 0x28, 0x9a, 0x3b, 0x03, 0x73, 0x33, 0xc6, 0xda,
-	0x3d, 0xd2, 0x5e, 0xdc, 0xe1, 0x2b, 0xfa, 0x37, 0x76, 0xbd, 0xde, 0x6d, 0xe0, 0x72, 0xce, 0x62,
-	0xf7, 0x21, 0x54, 0x54, 0xa5, 0x91, 0x03, 0xb5, 0x84, 0x70, 0xee, 0x9b, 0x92, 0x36, 0x70, 0xa1,
-	0xba, 0xbf, 0x59, 0xd0, 0x5d, 0x54, 0xc2, 0xf4, 0xed, 0xe8, 0xe6, 0xfa, 0x9b, 0xd4, 0x4d, 0x17,
-	0xee, 0x42, 0x3d, 0xe2, 0x1e, 0x49, 0x32, 0x71, 0xa5, 0x0a, 0x58, 0xc7, 0xb5, 0x88, 0x1f, 0x4b,
-	0x55, 0xf6, 0x52, 0xcf, 0x40, 0x79, 0x13, 0xd7, 0xf2, 0x20, 0x2c, 0x2e, 0x86, 0xbd, 0xf9, 0x62,
-	0x54, 0x96, 0x2f, 0x86, 0xfb, 0x0c, 0xee, 0x8f, 0x89, 0x28, 0x72, 0x1f, 0x67, 0x84, 0x84, 0xaf,
-	0xa2, 0x24, 0x9a, 0x0f, 0xd1, 0x3e, 0x34, 0xb9, 0x34, 0x7a, 0xb1, 0xb4, 0xaa, 0xa7, 0xd8, 0x18,
-	0xf8, 0x1c, 0xe7, 0xee, 0xc3, 0x83, 0x2d, 0x04, 0xba, 0x0c, 0x87, 0x8f, 0x00, 0x16, 0x37, 0x15,
-	0x01, 0x54, 0xdf, 0x50, 0x96, 0xf8, 0x71, 0xb7, 0x24, 0xe5, 0x13, 0xf5, 0x8c, 0xae, 0x35, 0xfc,
-	0xa7, 0x0c, 0x0d, 0xad, 0x8c, 0xc7, 0xa7, 0xe8, 0xbb, 0x95, 0x6f, 0xf6, 0xb7, 0x5e, 0x6d, 0x9d,
-	0x64, 0xef, 0x60, 0x3b, 0xc0, 0x8c, 0x6a, 0x09, 0x7d, 0x0d, 0x55, 0xbd, 0xcf, 0xe8, 0xde, 0x2a,
-	0x7a, 0xe5, 0x84, 0xf4, 0xee, 0x6f, 0x76, 0x16, 0x34, 0x7d, 0x0b, 0x1d, 0x43, 0x55, 0x2f, 0xe8,
-	0x3a, 0xd1, 0xca, 0x71, 0x58, 0x27, 0x5a, 0xdd, 0x69, 0xb7, 0x84, 0x5e, 0x40, 0xcd, 0xec, 0x13,
-	0x5a, 0x83, 0xae, 0xae, 0x71, 0xef, 0xc1, 0x16, 0xef, 0x9c, 0x89, 0xc1, 0xed, 0x8d, 0x1d, 0x40,
-	0x87, 0x6b, 0x65, 0xf9, 0x8f, 0x3e, 0xf7, 0x1e, 0xff, 0x2f, 0xec, 0x3c, 0xe6, 0x4b, 0xa8, 0x17,
-	0x7e, 0xb4, 0x96, 0xe0, 0xda, 0x45, 0xe8, 0xed, 0x6d, 0x73, 0x17, 0x64, 0xa3, 0x4f, 0xfe, 0xf8,
-	0xb5, 0x6e, 0xbd, 0xbb, 0xde, 0xb3, 0x7e, 0xbf, 0xde, 0xb3, 0xfe, 0xba, 0xde, 0xb3, 0x7e, 0xf9,
-	0x7b, 0xaf, 0x04, 0x5d, 0xca, 0x26, 0x03, 0x11, 0x4d, 0x2f, 0x07, 0xd3, 0x4b, 0xf5, 0x07, 0x7f,
-	0x56, 0x55, 0x3f, 0x4f, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xd4, 0x6a, 0x6c, 0x6c, 0x08,
+func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_import_sstpb_789900542ce0f450) }
+
+var fileDescriptor_import_sstpb_789900542ce0f450 = []byte{
+	// 994 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x56, 0xcd, 0x6e, 0x1c, 0x45,
+	0x10, 0xde, 0xf1, 0xfe, 0xd7, 0xfe, 0xba, 0x71, 0xc2, 0x64, 0x93, 0xd8, 0x9b, 0xc1, 0x82, 0xc5,
+	0x81, 0xb5, 0xe4, 0x48, 0xb9, 0x46, 0x38, 0x58, 0xc4, 0x38, 0x89, 0xa0, 0xd7, 0x9c, 0x90, 0x18,
+	0x8d, 0x67, 0xda, 0xeb, 0xd1, 0xce, 0x4c, 0x0f, 0xdd, 0x3d, 0xbb, 0xf6, 0x05, 0xf1, 0x08, 0x1c,
+	0x79, 0x04, 0xde, 0x80, 0x57, 0xc8, 0x91, 0x23, 0x27, 0x84, 0xcc, 0x53, 0x70, 0x43, 0xfd, 0x33,
+	0xfb, 0x27, 0x1b, 0xe7, 0x34, 0x5d, 0x55, 0x5f, 0x57, 0x55, 0x57, 0x7d, 0x55, 0x1a, 0x40, 0x61,
+	0x9c, 0x52, 0x26, 0x5c, 0xce, 0x45, 0x7a, 0x36, 0x4c, 0x19, 0x15, 0x14, 0x35, 0x97, 0x75, 0xbd,
+	0x66, 0x4c, 0x84, 0x97, 0xdb, 0x7a, 0x2d, 0xc2, 0x18, 0x65, 0x0b, 0x71, 0x32, 0x65, 0xa9, 0x3f,
+	0x17, 0xb7, 0xc6, 0x74, 0x4c, 0xd5, 0x71, 0x5f, 0x9e, 0x8c, 0xb6, 0xc3, 0x32, 0x2e, 0xd4, 0xd1,
+	0x28, 0x9a, 0x67, 0x9e, 0x3f, 0xc9, 0x52, 0x2d, 0x39, 0x5f, 0xc0, 0xe6, 0x68, 0x16, 0x0a, 0xff,
+	0xe2, 0x0d, 0x0d, 0x08, 0x26, 0x3f, 0x66, 0x84, 0x0b, 0xf4, 0x19, 0x94, 0x62, 0x1a, 0x10, 0xdb,
+	0xea, 0x5b, 0x83, 0xf6, 0x81, 0x3d, 0x5c, 0x49, 0x73, 0x09, 0xae, 0x50, 0xce, 0x16, 0xa0, 0x65,
+	0x17, 0x3c, 0xa5, 0x09, 0x27, 0xce, 0x3e, 0x94, 0xb1, 0x97, 0x8c, 0x09, 0xda, 0x82, 0x32, 0x17,
+	0x1e, 0x13, 0xca, 0x5b, 0x13, 0x6b, 0x01, 0x75, 0xa1, 0x48, 0x92, 0xc0, 0xde, 0x50, 0x3a, 0x79,
+	0x74, 0x7e, 0xd9, 0x80, 0xea, 0x68, 0x74, 0xfa, 0x86, 0x08, 0x0f, 0x21, 0x28, 0x65, 0x59, 0x18,
+	0x98, 0x2b, 0xea, 0x8c, 0x3e, 0x85, 0x32, 0x93, 0x0e, 0xd5, 0x9d, 0xc6, 0xc1, 0x07, 0xab, 0x59,
+	0xa9, 0x58, 0x58, 0x23, 0x64, 0x48, 0x9f, 0xf9, 0xcf, 0x0e, 0xec, 0x62, 0xdf, 0x1a, 0xb4, 0xb0,
+	0x16, 0xd0, 0x7d, 0xa8, 0x44, 0x24, 0x19, 0x8b, 0x0b, 0xbb, 0xd4, 0xb7, 0x06, 0x25, 0x6c, 0x24,
+	0xf4, 0x21, 0x54, 0xfd, 0x73, 0x37, 0xf1, 0x62, 0x62, 0x97, 0xfb, 0xd6, 0xa0, 0x8e, 0x2b, 0xfe,
+	0xf9, 0x5b, 0x2f, 0x26, 0xe8, 0x21, 0xd4, 0x19, 0x19, 0x87, 0x34, 0x71, 0xc3, 0xc0, 0xae, 0xa8,
+	0x3b, 0x35, 0xad, 0x38, 0x0e, 0xd0, 0x73, 0x68, 0x1a, 0x23, 0x49, 0xa9, 0x7f, 0x61, 0x57, 0x4d,
+	0x56, 0xa6, 0x61, 0x58, 0xd9, 0x8e, 0xa4, 0x09, 0x37, 0xd8, 0x42, 0x40, 0x7b, 0xb0, 0x49, 0x92,
+	0xc0, 0x9d, 0x90, 0x2b, 0x97, 0x5c, 0xfa, 0x51, 0xc6, 0xc3, 0x29, 0xb1, 0x6b, 0x7d, 0x6b, 0x50,
+	0xc3, 0x1d, 0x92, 0x04, 0x27, 0xe4, 0xea, 0x28, 0x57, 0x3b, 0x3f, 0x41, 0x03, 0x93, 0x19, 0x0b,
+	0x05, 0xc1, 0x59, 0x44, 0xd0, 0x2e, 0xb4, 0x69, 0xa4, 0xaf, 0xa6, 0x8c, 0x9c, 0x87, 0x97, 0xa6,
+	0x3e, 0x4d, 0x1a, 0xc9, 0x7b, 0xdf, 0x28, 0x9d, 0x44, 0x25, 0x64, 0xb6, 0x8c, 0xd2, 0x45, 0x6e,
+	0x26, 0x64, 0xb6, 0x40, 0x7d, 0x04, 0x2d, 0x89, 0x12, 0x61, 0x4c, 0xb8, 0xf0, 0xe2, 0x54, 0x95,
+	0xaa, 0xa4, 0x40, 0xa7, 0xb9, 0xce, 0xf9, 0x1e, 0x5a, 0xdf, 0xa5, 0x11, 0xf5, 0x82, 0x9c, 0x18,
+	0x4f, 0xa1, 0x24, 0xdf, 0xa7, 0xe2, 0x36, 0x0e, 0xee, 0xad, 0x11, 0x43, 0x37, 0xef, 0x55, 0x01,
+	0x2b, 0x10, 0xda, 0x82, 0x52, 0xe0, 0x09, 0x4f, 0x87, 0x97, 0x5a, 0x29, 0x1d, 0x56, 0xa1, 0xec,
+	0x5f, 0x64, 0xc9, 0xc4, 0xe9, 0x42, 0x3b, 0x77, 0x6e, 0x28, 0x13, 0x40, 0xeb, 0x38, 0x19, 0x13,
+	0x2e, 0xf2, 0x70, 0x7b, 0x50, 0xf5, 0x69, 0x22, 0xc8, 0xa5, 0x30, 0x11, 0xbb, 0xc3, 0x9c, 0xf2,
+	0x2f, 0xb5, 0x1e, 0xe7, 0x00, 0xf4, 0x09, 0x14, 0x39, 0x17, 0x86, 0x1c, 0x37, 0x67, 0x86, 0x25,
+	0xc2, 0x79, 0x0e, 0xed, 0x3c, 0x8a, 0x8e, 0x8b, 0x76, 0xa1, 0xac, 0x06, 0xcb, 0x04, 0x69, 0x0f,
+	0xf3, 0x31, 0x3b, 0x92, 0x5f, 0xac, 0x8d, 0xce, 0x0f, 0xd0, 0x7e, 0x49, 0xe3, 0xd4, 0xf3, 0xe7,
+	0xe9, 0xcd, 0x19, 0x69, 0xdd, 0xc9, 0xc8, 0x27, 0xd0, 0xa4, 0x99, 0x48, 0x33, 0xe1, 0x46, 0x64,
+	0x4a, 0x22, 0x95, 0x66, 0x19, 0x37, 0xb4, 0xee, 0xb5, 0x54, 0x39, 0x9b, 0xd0, 0x99, 0xfb, 0x37,
+	0x05, 0xf9, 0x79, 0x03, 0x3a, 0x5f, 0xd2, 0x59, 0xb2, 0xdc, 0x82, 0xcf, 0xef, 0x7e, 0xe7, 0x61,
+	0xe9, 0xdd, 0x5f, 0x3b, 0x05, 0xf5, 0x5a, 0x39, 0x49, 0x8a, 0xd9, 0x75, 0xc5, 0x6c, 0x75, 0x46,
+	0x87, 0x92, 0xba, 0x8a, 0x56, 0x2e, 0xcb, 0x22, 0x62, 0xb7, 0x94, 0xaf, 0x07, 0x6b, 0xe9, 0x2f,
+	0x88, 0x67, 0xfc, 0x35, 0xd8, 0x12, 0x17, 0x5f, 0x40, 0x87, 0x0b, 0xca, 0xbc, 0x31, 0x71, 0xe5,
+	0x3e, 0x91, 0xb3, 0xdc, 0x56, 0x6e, 0xee, 0x0f, 0xcd, 0x7e, 0x19, 0x69, 0xf3, 0xa1, 0xb6, 0xe2,
+	0x36, 0x5f, 0x91, 0x51, 0x0f, 0xea, 0x21, 0x77, 0x99, 0x37, 0x73, 0x27, 0x53, 0xbb, 0xa3, 0xf8,
+	0x5f, 0x0d, 0x39, 0xf6, 0x66, 0x27, 0xd3, 0xaf, 0x4b, 0xb5, 0x5a, 0xb7, 0x8e, 0x8b, 0x19, 0x8b,
+	0x9c, 0x27, 0x50, 0x56, 0x5d, 0x40, 0x36, 0x54, 0x63, 0xc2, 0xb9, 0x67, 0xca, 0x5d, 0xc7, 0xb9,
+	0xe8, 0xfc, 0x6e, 0x41, 0x77, 0x51, 0x25, 0xd3, 0xd3, 0xfd, 0xbb, 0x7b, 0x63, 0x9e, 0x65, 0x3a,
+	0xf4, 0x00, 0x6a, 0x21, 0x77, 0x49, 0x9c, 0x8a, 0x2b, 0x55, 0x5c, 0x95, 0xce, 0x91, 0x14, 0x65,
+	0x9f, 0x35, 0x3f, 0x8a, 0x37, 0xf9, 0x5a, 0x26, 0xc9, 0x62, 0xf3, 0x94, 0x6e, 0xde, 0x3c, 0xe5,
+	0xe5, 0xcd, 0xe3, 0xbc, 0x80, 0x47, 0x23, 0x22, 0xf2, 0xdc, 0x47, 0x29, 0x21, 0xc1, 0xeb, 0x30,
+	0x0e, 0xe7, 0x04, 0xdb, 0x81, 0x06, 0x97, 0x4a, 0x37, 0x92, 0x5a, 0xf5, 0x94, 0x12, 0x06, 0x3e,
+	0xc7, 0x39, 0x3b, 0xf0, 0xf8, 0x16, 0x07, 0xba, 0x0c, 0x7b, 0xbb, 0x00, 0x8b, 0xdd, 0x8c, 0x00,
+	0x2a, 0x6f, 0x29, 0x8b, 0xbd, 0xa8, 0x5b, 0x90, 0xe7, 0x63, 0xf5, 0x8c, 0xae, 0x75, 0xf0, 0x6f,
+	0x11, 0xea, 0x5a, 0x18, 0x8d, 0x4e, 0xd1, 0xb7, 0x2b, 0x77, 0x76, 0x6e, 0xdd, 0xfe, 0x3a, 0xc9,
+	0x5e, 0xff, 0x76, 0x80, 0xa1, 0x71, 0x01, 0x7d, 0x05, 0x15, 0x3d, 0xeb, 0xe8, 0xe1, 0x2a, 0x7a,
+	0x65, 0xbd, 0xf4, 0x1e, 0xdd, 0x6c, 0xcc, 0xdd, 0x0c, 0x2c, 0x74, 0x04, 0x15, 0x3d, 0xbc, 0xeb,
+	0x8e, 0x56, 0x16, 0xc7, 0xba, 0xa3, 0xd5, 0x79, 0x77, 0x0a, 0xe8, 0x15, 0x54, 0xcd, 0xac, 0xa1,
+	0x35, 0xe8, 0xea, 0x88, 0xf7, 0x1e, 0xdf, 0x62, 0x9d, 0x7b, 0x62, 0x70, 0xef, 0xc6, 0x0e, 0xa0,
+	0xbd, 0xb5, 0xb2, 0xfc, 0x4f, 0x9f, 0x7b, 0x4f, 0xdf, 0x0b, 0x3b, 0x8f, 0x79, 0x02, 0xb5, 0xdc,
+	0x8e, 0xd6, 0x12, 0x5c, 0xdb, 0x16, 0xbd, 0xed, 0xdb, 0xcc, 0xb9, 0xb3, 0xc3, 0x8f, 0xff, 0xfc,
+	0xad, 0x66, 0xbd, 0xbb, 0xde, 0xb6, 0xfe, 0xb8, 0xde, 0xb6, 0xfe, 0xbe, 0xde, 0xb6, 0x7e, 0xfd,
+	0x67, 0xbb, 0x00, 0x5d, 0xca, 0xc6, 0x43, 0x11, 0x4e, 0xa6, 0xc3, 0xc9, 0x54, 0xfd, 0x28, 0x9c,
+	0x55, 0xd4, 0xe7, 0xd9, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x04, 0xa2, 0x06, 0xd6, 0xb4, 0x08,
 	0x00, 0x00,
 }
diff --git a/proto/import_sstpb.proto b/proto/import_sstpb.proto
index d4336443e..775656ea8 100644
--- a/proto/import_sstpb.proto
+++ b/proto/import_sstpb.proto
@@ -72,6 +72,7 @@ message SSTMeta {
     string cf_name = 5;
     uint64 region_id = 6;
     metapb.RegionEpoch region_epoch = 7;
+    bool end_key_exclusive = 8;
 }
 
 // A rewrite rule is applied on the *encoded* keys (the internal storage
@@ -141,6 +142,8 @@ message DownloadRequest {
     RewriteRule rewrite_rule = 13 [(gogoproto.nullable) = false];
 
     backup.StorageBackend storage_backend = 14;
+
+    bool is_raw_kv = 15;
 }
 
 // For now it is just used for distinguishing the error of the request with the error