diff --git a/frameworks/native/appdatafwk/src/shared_block.cpp b/frameworks/native/appdatafwk/src/shared_block.cpp index a70e6329a335d9c95e4c2f57707eab8ff9866ade..043b8a53a1c89fb0b379f737e398a6b4d9a9f0ca 100644 --- a/frameworks/native/appdatafwk/src/shared_block.cpp +++ b/frameworks/native/appdatafwk/src/shared_block.cpp @@ -46,16 +46,6 @@ SharedBlock::~SharedBlock() } } -std::u16string SharedBlock::ToUtf16(std::string str) -{ - return OHOS::Str8ToStr16(str); -} - -std::string SharedBlock::ToUtf8(std::u16string str16) -{ - return OHOS::Str16ToStr8(str16); -} - bool SharedBlock::Init() { mData = static_cast(const_cast(ashmem_->ReadFromAshmem(sizeof(SharedBlockHeader), 0))); @@ -112,12 +102,12 @@ int SharedBlock::Create(const std::string &name, size_t size, SharedBlock *&outS int SharedBlock::WriteMessageParcel(MessageParcel &parcel) { - return parcel.WriteString16(ToUtf16(mName)) && parcel.WriteAshmem(ashmem_); + return parcel.WriteString16(OHOS::Str8ToStr16(mName)) && parcel.WriteAshmem(ashmem_); } int SharedBlock::ReadMessageParcel(MessageParcel &parcel, SharedBlock *&block) { - std::string name = ToUtf8(parcel.ReadString16()); + std::string name = OHOS::Str16ToStr8(parcel.ReadString16()); sptr ashmem = parcel.ReadAshmem(); if (UNLIKELY(ashmem == nullptr)) { LOG_ERROR("ReadMessageParcel: No ashmem in the parcel."); @@ -153,25 +143,19 @@ int SharedBlock::Clear() if (UNLIKELY(mReadOnly)) { return SHARED_BLOCK_INVALID_OPERATION; } - if (mHeader == nullptr) { - LOG_ERROR("SharedBlock::Clear mHeader is nullptr"); - return SHARED_BLOCK_BAD_VALUE; - } - mHeader->unusedOffset = sizeof(SharedBlockHeader) + sizeof(RowGroupHeader); - mHeader->firstRowGroupOffset = sizeof(SharedBlockHeader); - mHeader->rowNums = 0; - mHeader->columnNums = 0; - mHeader->startPos_ = 0; - mHeader->lastPos_ = 0; - mHeader->blockPos_ = 0; - - RowGroupHeader *firstGroup = static_cast(OffsetToPtr(mHeader->firstRowGroupOffset)); - if (UNLIKELY(!firstGroup)) { - LOG_ERROR("Failed to get group in clear()."); - return SHARED_BLOCK_BAD_VALUE; + if (LIKELY(mHeader != nullptr)) { + mHeader->unusedOffset = sizeof(SharedBlockHeader) + sizeof(RowGroupHeader); + mHeader->rowNums = 0; + mHeader->columnNums = 0; + mHeader->startPos_ = 0; + mHeader->lastPos_ = 0; + mHeader->blockPos_ = 0; + memset_s(mHeader->groupOffset, sizeof(mHeader->groupOffset), 0, sizeof(mHeader->groupOffset)); + mHeader->groupOffset[0] = sizeof(SharedBlockHeader); + return SHARED_BLOCK_OK; } - firstGroup->nextGroupOffset = 0; - return SHARED_BLOCK_OK; + LOG_ERROR("SharedBlock::Clear mHeader is nullptr"); + return SHARED_BLOCK_BAD_VALUE; } int SharedBlock::SetColumnNum(uint32_t numColumns) @@ -209,10 +193,10 @@ int SharedBlock::AllocRow() size_t fieldDirSize = mHeader->columnNums * sizeof(CellUnit); /* Aligned */ - uint32_t fieldDirOffset = Alloc(fieldDirSize, true); + uint32_t fieldDirOffset = Alloc(fieldDirSize); if (UNLIKELY(!fieldDirOffset)) { mHeader->rowNums--; - LOG_INFO("Alloc the row failed, so back out the new row accounting from allocRowoffset %{public}" PRIu32 "", + LOG_INFO("Alloc the row size %{public}u failed, roll back row number %{public}u", fieldDirOffset, mHeader->rowNums); return SHARED_BLOCK_NO_MEMORY; } @@ -221,11 +205,6 @@ int SharedBlock::AllocRow() if (UNLIKELY(fieldDir == nullptr)) { return SHARED_BLOCK_BAD_VALUE; } - int result = memset_s(fieldDir, fieldDirSize, 0, fieldDirSize); - if (UNLIKELY(result != 0)) { - LOG_ERROR("Set memory failed"); - return SHARED_BLOCK_NO_MEMORY; - } *rowOffset = fieldDirOffset; return SHARED_BLOCK_OK; @@ -244,82 +223,58 @@ int SharedBlock::FreeLastRow() return SHARED_BLOCK_OK; } -uint32_t SharedBlock::Alloc(size_t size, bool aligned) +uint32_t SharedBlock::Alloc(size_t size) { /* Number of unused offsets in the header */ uint32_t offsetDigit = 3; - uint32_t padding = aligned ? (~mHeader->unusedOffset + 1) & offsetDigit : 0; - uint32_t offset = mHeader->unusedOffset + padding; - uint32_t nextFreeOffset; - - if (UNLIKELY(offset + size > mSize)) { + uint32_t offset = mHeader->unusedOffset + ((~mHeader->unusedOffset + 1) & offsetDigit); + uint32_t nextFreeOffset = offset + size; + if (UNLIKELY(nextFreeOffset > mSize)) { LOG_ERROR("SharedBlock is full: requested allocation %{public}zu bytes," " free space %{public}zu bytes, block size %{public}zu bytes", size, mSize - mHeader->unusedOffset, mSize); return 0; } - nextFreeOffset = offset + size; mHeader->unusedOffset = nextFreeOffset; return offset; } -uint32_t *SharedBlock::GetRowOffset(uint32_t row) +uint32_t SharedBlock::GetRowOffset(uint32_t row) { - RowGroupHeader *group = static_cast(OffsetToPtr(mHeader->firstRowGroupOffset)); + uint32_t groupPos = row / ROW_NUM_IN_A_GROUP; + uint32_t rowPos = row % ROW_NUM_IN_A_GROUP; + RowGroupHeader *group = static_cast(OffsetToPtr(mHeader->groupOffset[groupPos])); if (UNLIKELY(group == nullptr)) { - LOG_ERROR("Failed to get group in getRowOffset()."); - return nullptr; - } - - while (row >= ROW_OFFSETS_NUM) { - group = static_cast(OffsetToPtr(group->nextGroupOffset)); - if (UNLIKELY(group == nullptr)) { - LOG_ERROR("Failed to get group in OffsetToPtr(group->nextGroupOffset) when while loop."); - return nullptr; - } - row -= ROW_OFFSETS_NUM; + LOG_ERROR("Failed to get group %{public}u, offset %{public}u", groupPos, mHeader->groupOffset[groupPos]); + return 0; } - return group->rowOffsets + row; + return group->rowOffsets[rowPos]; } uint32_t *SharedBlock::AllocRowOffset() { - uint32_t rowPos = mHeader->rowNums; - - RowGroupHeader *group = static_cast(OffsetToPtr(mHeader->firstRowGroupOffset)); - if (group == nullptr) { - LOG_ERROR("Failed to get group in allocRowOffset()."); + uint32_t groupPos = mHeader->rowNums / ROW_NUM_IN_A_GROUP; + if (UNLIKELY(groupPos >= GROUP_NUM)) { + LOG_ERROR("rows is full. row number %{public}u, groupPos %{public}u", mHeader->rowNums, groupPos); return nullptr; } - - while (rowPos > ROW_OFFSETS_NUM) { - group = static_cast(OffsetToPtr(group->nextGroupOffset)); - if (UNLIKELY(group == nullptr)) { - LOG_ERROR("Failed to get group in OffsetToPtr(group->nextGroupOffset) when while loop."); - return nullptr; - } - rowPos -= ROW_OFFSETS_NUM; - } - if (rowPos == ROW_OFFSETS_NUM) { - if (!group->nextGroupOffset) { - /* Aligned */ - group->nextGroupOffset = Alloc(sizeof(RowGroupHeader), true); - if (UNLIKELY(!group->nextGroupOffset)) { - return nullptr; - } - } - group = static_cast(OffsetToPtr(group->nextGroupOffset)); - if (UNLIKELY(group == nullptr)) { - LOG_ERROR("Failed to get group in OffsetToPtr(group->nextGroupOffset)."); + if (mHeader->groupOffset[groupPos] == 0) { + mHeader->groupOffset[groupPos] = Alloc(sizeof(RowGroupHeader)); + if (UNLIKELY(mHeader->groupOffset[groupPos] == 0)) { return nullptr; } - group->nextGroupOffset = 0; - rowPos = 0; + } + + uint32_t rowPos = mHeader->rowNums % ROW_NUM_IN_A_GROUP; + RowGroupHeader *group = static_cast(OffsetToPtr(mHeader->groupOffset[groupPos])); + if (UNLIKELY(group == nullptr)) { + LOG_ERROR("Failed to get group %{public}u, offset %{public}u", groupPos, mHeader->groupOffset[groupPos]); + return nullptr; } mHeader->rowNums += 1; - return &group->rowOffsets[rowPos]; + return group->rowOffsets + rowPos; } SharedBlock::CellUnit *SharedBlock::GetCellUnit(uint32_t row, uint32_t column) @@ -330,20 +285,7 @@ SharedBlock::CellUnit *SharedBlock::GetCellUnit(uint32_t row, uint32_t column) row, column, mHeader->rowNums, mHeader->columnNums); return nullptr; } - - uint32_t *rowOffset = GetRowOffset(row); - if (UNLIKELY(!rowOffset)) { - LOG_ERROR("Failed to find rowOffset for row %{public}" PRIu32 ".", row); - return nullptr; - } - - CellUnit *cellUnit = static_cast(OffsetToPtr(*rowOffset)); - if (UNLIKELY(!cellUnit)) { - LOG_ERROR("Failed to find cellUnit for rowOffset %{public}" PRIu32 ".", *rowOffset); - return nullptr; - } - - return &cellUnit[column]; + return static_cast(OffsetToPtr(GetRowOffset(row))) + column; } int SharedBlock::PutBlob(uint32_t row, uint32_t column, const void *value, size_t size) @@ -378,7 +320,7 @@ int SharedBlock::PutBlobOrString(uint32_t row, uint32_t column, const void *valu row, column, mHeader->rowNums, mHeader->columnNums); return SHARED_BLOCK_BAD_VALUE; } - CellUnit *cellUnit = static_cast(OffsetToPtr(*GetRowOffset(row))) + column; + CellUnit *cellUnit = static_cast(OffsetToPtr(GetRowOffset(row))) + column; uint32_t offset = mHeader->unusedOffset; uint32_t end = offset + size; if (UNLIKELY(end > mSize)) { @@ -386,9 +328,9 @@ int SharedBlock::PutBlobOrString(uint32_t row, uint32_t column, const void *valu } mHeader->unusedOffset = end; - if (UNLIKELY(size != 0)) { + if (size != 0) { errno_t result = memcpy_s(mData + offset, size, value, size); - if (result != EOK) { + if (UNLIKELY(result != EOK)) { return SHARED_BLOCK_NO_MEMORY; } } @@ -412,7 +354,7 @@ int SharedBlock::PutLong(uint32_t row, uint32_t column, int64_t value) return SHARED_BLOCK_BAD_VALUE; } - CellUnit *cellUnit = static_cast(OffsetToPtr(*GetRowOffset(row))) + column; + CellUnit *cellUnit = static_cast(OffsetToPtr(GetRowOffset(row))) + column; cellUnit->type = CELL_UNIT_TYPE_INTEGER; cellUnit->cell.longValue = value; return SHARED_BLOCK_OK; @@ -468,10 +410,5 @@ size_t SharedBlock::SetRawData(const void *rawData, size_t size) } return SHARED_BLOCK_OK; } - -uint32_t SharedBlock::OffsetFromPtr(void *ptr) -{ - return static_cast(ptr) - mData; -} } // namespace AppDataFwk } // namespace OHOS diff --git a/frameworks/native/rdb/include/shared_block_serializer_info.h b/frameworks/native/rdb/include/shared_block_serializer_info.h index f68047851a808258210ed496f94d50df5e1b1a4b..465729b2f9463439656d7f16f961874233520e46 100644 --- a/frameworks/native/rdb/include/shared_block_serializer_info.h +++ b/frameworks/native/rdb/include/shared_block_serializer_info.h @@ -32,15 +32,35 @@ public: int AddRow(int addedRows); int Reset(int startPos); int Finish(int addedRows, int totalRows); - int PutString(int row, int column, const char *text, int sizeIncludingNull); int PutLong(int row, int column, sqlite3_int64 value); int PutDouble(int row, int column, double value); int PutBlob(int row, int column, const void *blob, int len); int PutNull(int row, int column); int PutOther(int row, int column); - int GetTotalRows() const; - int GetAddedRows() const; - int GetStartPos() const; + int PutString(int row, int column, const char *text, int sizeIncludingNull) + { + int status = sharedBlock_->PutString(row, column, text, sizeIncludingNull); + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + return SQLITE_OK; + } + sharedBlock_->FreeLastRow(); + return SQLITE_FULL; + } + + int GetTotalRows() const + { + return atotalRows; + } + + int GetAddedRows() const + { + return raddedRows; + } + + int GetStartPos() const + { + return astartPos; + } private: AppDataFwk::SharedBlock *sharedBlock_; sqlite3_stmt *statement_ = nullptr; @@ -48,7 +68,6 @@ private: int atotalRows; int astartPos; int raddedRows; - bool risFull; }; struct Sqlite3SharedBlockMethods { diff --git a/frameworks/native/rdb/src/abs_shared_result_set.cpp b/frameworks/native/rdb/src/abs_shared_result_set.cpp index 83ada7e7e3eec5274f8191e078e06dddc7de9d44..0956c7b7359a2b86f12939618f1c3bc8cb8feec6 100644 --- a/frameworks/native/rdb/src/abs_shared_result_set.cpp +++ b/frameworks/native/rdb/src/abs_shared_result_set.cpp @@ -66,20 +66,15 @@ void AbsSharedResultSet::FillBlock(int startRowIndex, AppDataFwk::SharedBlock *b return; } -void AbsSharedResultSet::InitBlock() -{ - if (sharedBlock_ == nullptr) { - AppDataFwk::SharedBlock::Create(sharedBlockName_, DEFAULT_BLOCK_SIZE, sharedBlock_); - } - return; -} - /** * Get current shared block */ AppDataFwk::SharedBlock *AbsSharedResultSet::GetBlock() { - InitBlock(); + if (sharedBlock_ != nullptr) { + return sharedBlock_; + } + AppDataFwk::SharedBlock::Create(sharedBlockName_, DEFAULT_BLOCK_SIZE, sharedBlock_); return sharedBlock_; } diff --git a/frameworks/native/rdb/src/share_block.cpp b/frameworks/native/rdb/src/share_block.cpp index 7f30cf695d4f562a0891c35b269c73852f02dd06..a367f2ca4996d67cbe95a70ab6e3b9ad732e8f64 100644 --- a/frameworks/native/rdb/src/share_block.cpp +++ b/frameworks/native/rdb/src/share_block.cpp @@ -120,22 +120,17 @@ void FillSharedBlockOpt(SharedBlockInfo *info) return; } int retryCount = 0; - bool gotException = false; - while (!gotException) { + while (true) { int err = sqlite3_step(info->statement); - if (err == SQLITE_DONE) { - break; - } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { + if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { LOG_WARN("Database locked, retrying"); - if (retryCount > RETRY_TIME) { - gotException = true; - } else { + if (retryCount <= RETRY_TIME) { usleep(SLEEP_TIME); retryCount++; + continue; } - } else { - gotException = true; } + break; } info->totalRows = serializer.GetTotalRows(); info->startPos = serializer.GetStartPos(); diff --git a/frameworks/native/rdb/src/shared_block_serializer_info.cpp b/frameworks/native/rdb/src/shared_block_serializer_info.cpp index 622c19fe7276046e2619b271195dbae699f555de..9a3a918ab5a312507eafe4981ab6dc8fcbe4a5c9 100644 --- a/frameworks/native/rdb/src/shared_block_serializer_info.cpp +++ b/frameworks/native/rdb/src/shared_block_serializer_info.cpp @@ -25,7 +25,7 @@ using namespace OHOS::Rdb; SharedBlockSerializerInfo::SharedBlockSerializerInfo(AppDataFwk::SharedBlock *sharedBlock, sqlite3_stmt *stat, int numColumns, int startPos) : sharedBlock_(sharedBlock), statement_(stat), anumColumns(numColumns), atotalRows(0), astartPos(startPos), - raddedRows(0), risFull(false) + raddedRows(0) { } @@ -35,13 +35,11 @@ int SharedBlockSerializerInfo::AddRow(int addedRows) { // Allocate a new field directory for the row. int status = sharedBlock_->AllocRow(); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - risFull = true; - return SQLITE_FULL; + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + raddedRows = addedRows + 1; + return SQLITE_OK; } - - raddedRows = addedRows + 1; - return SQLITE_OK; + return SQLITE_FULL; } int SharedBlockSerializerInfo::Reset(int startPos) @@ -57,7 +55,6 @@ int SharedBlockSerializerInfo::Reset(int startPos) } astartPos = startPos; raddedRows = 0; - risFull = false; return SQLITE_OK; } @@ -68,40 +65,24 @@ int SharedBlockSerializerInfo::Finish(int addedRows, int totalRows) return SQLITE_OK; } -int SharedBlockSerializerInfo::PutString(int row, int column, const char *text, int sizeIncludingNull) -{ - int status = sharedBlock_->PutString(row, column, text, sizeIncludingNull); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - sharedBlock_->FreeLastRow(); - risFull = true; - return SQLITE_FULL; - } - - return SQLITE_OK; -} - int SharedBlockSerializerInfo::PutLong(int row, int column, sqlite3_int64 value) { int status = sharedBlock_->PutLong(row, column, value); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - sharedBlock_->FreeLastRow(); - risFull = true; - return SQLITE_FULL; + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + return SQLITE_OK; } - - return SQLITE_OK; + sharedBlock_->FreeLastRow(); + return SQLITE_FULL; } int SharedBlockSerializerInfo::PutDouble(int row, int column, double value) { int status = sharedBlock_->PutDouble(row, column, value); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - sharedBlock_->FreeLastRow(); - risFull = true; - return SQLITE_FULL; + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + return SQLITE_OK; } - - return SQLITE_OK; + sharedBlock_->FreeLastRow(); + return SQLITE_FULL; } int SharedBlockSerializerInfo::PutBlob(int row, int column, const void *blob, int len) @@ -117,26 +98,22 @@ int SharedBlockSerializerInfo::PutBlob(int row, int column, const void *blob, in } int status = (sharedBlock_->*action)(row, column, blob, len); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - sharedBlock_->FreeLastRow(); - risFull = true; - return SQLITE_FULL; + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + return SQLITE_OK; } - - return SQLITE_OK; + sharedBlock_->FreeLastRow(); + return SQLITE_FULL; } int SharedBlockSerializerInfo::PutNull(int row, int column) { int status = sharedBlock_->PutNull(row, column); - if (status != AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { - sharedBlock_->FreeLastRow(); - risFull = true; - LOG_ERROR("Failed allocating space for a null in column %{public}d, error=%{public}d", column, status); - return SQLITE_FULL; + if (status == AppDataFwk::SharedBlock::SHARED_BLOCK_OK) { + return SQLITE_OK; } - - return SQLITE_OK; + sharedBlock_->FreeLastRow(); + LOG_ERROR("Failed allocating space for a null in column %{public}d, error=%{public}d", column, status); + return SQLITE_FULL; } int SharedBlockSerializerInfo::PutOther(int row, int column) @@ -144,20 +121,5 @@ int SharedBlockSerializerInfo::PutOther(int row, int column) sharedBlock_->FreeLastRow(); return SQLITE_ERROR; } - -int SharedBlockSerializerInfo::GetTotalRows() const -{ - return atotalRows; -} - -int SharedBlockSerializerInfo::GetAddedRows() const -{ - return raddedRows; -} - -int SharedBlockSerializerInfo::GetStartPos() const -{ - return astartPos; -} } // namespace NativeRdb } // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/rdb/src/sqlite_shared_result_set.cpp b/frameworks/native/rdb/src/sqlite_shared_result_set.cpp index ea73ab96d3a8aff11c76753aadce085e712a7966..247b62b74bc118a327c3c3b63f7021e6ea3161e6 100644 --- a/frameworks/native/rdb/src/sqlite_shared_result_set.cpp +++ b/frameworks/native/rdb/src/sqlite_shared_result_set.cpp @@ -152,32 +152,34 @@ int SqliteSharedResultSet::PickFillBlockStartPosition(int resultSetPosition, int void SqliteSharedResultSet::FillSharedBlock(int requiredPos) { ClearBlock(); - SqliteConnection* connection = connectionPool_->AcquireConnection(true); if (connection == nullptr) { return; } - + AppDataFwk::SharedBlock *sharedBlock = GetBlock(); + if (sharedBlock == nullptr) { + return; + } if (rowNum == NO_COUNT) { - connection->ExecuteForSharedBlock(rowNum, qrySql, bindArgs_, GetBlock(), requiredPos, requiredPos, true); - resultSetBlockCapacity = static_cast(GetBlock()->GetRowNum()); + connection->ExecuteForSharedBlock(rowNum, qrySql, bindArgs_, sharedBlock, requiredPos, requiredPos, true); + resultSetBlockCapacity = static_cast(sharedBlock->GetRowNum()); if (resultSetBlockCapacity > 0) { - GetBlock()->SetStartPos(requiredPos); - GetBlock()->SetBlockPos(0); - GetBlock()->SetLastPos(requiredPos + resultSetBlockCapacity); + sharedBlock->SetStartPos(requiredPos); + sharedBlock->SetBlockPos(0); + sharedBlock->SetLastPos(requiredPos + resultSetBlockCapacity); } } else { int blockRowNum = rowNum; int startPos = isOnlyFillResultSetBlock ? requiredPos : PickFillBlockStartPosition(requiredPos, resultSetBlockCapacity); - connection->ExecuteForSharedBlock(blockRowNum, qrySql, bindArgs_, GetBlock(), startPos, requiredPos, false); - int currentBlockCapacity = static_cast(GetBlock()->GetRowNum()); - GetBlock()->SetStartPos((uint32_t)startPos); - GetBlock()->SetBlockPos(requiredPos - startPos); - GetBlock()->SetLastPos(startPos + currentBlockCapacity); + connection->ExecuteForSharedBlock(blockRowNum, qrySql, bindArgs_, sharedBlock, startPos, requiredPos, false); + int currentBlockCapacity = static_cast(sharedBlock->GetRowNum()); + sharedBlock->SetStartPos((uint32_t)startPos); + sharedBlock->SetBlockPos(requiredPos - startPos); + sharedBlock->SetLastPos(startPos + currentBlockCapacity); LOG_INFO("requiredPos= %{public}d, startPos_= %{public}" PRIu32 ", lastPos_= %{public}" PRIu32 ", blockPos_= %{public}" PRIu32 ".", - requiredPos, GetBlock()->GetStartPos(), GetBlock()->GetLastPos(), GetBlock()->GetBlockPos()); + requiredPos, sharedBlock->GetStartPos(), sharedBlock->GetLastPos(), sharedBlock->GetBlockPos()); } connectionPool_->ReleaseConnection(connection); } diff --git a/interfaces/inner_api/appdatafwk/include/shared_block.h b/interfaces/inner_api/appdatafwk/include/shared_block.h index b1c7b97fc475921fd174c271c1dff03b22c8c100..e76b390b049c6976d302f5c991f97a5e6d4d85bd 100644 --- a/interfaces/inner_api/appdatafwk/include/shared_block.h +++ b/interfaces/inner_api/appdatafwk/include/shared_block.h @@ -317,7 +317,8 @@ private: uint8_t *mData; size_t mSize; bool mReadOnly; - static const size_t ROW_OFFSETS_NUM = 100; + static const size_t ROW_NUM_IN_A_GROUP = 128; + static const uint32_t GROUP_NUM = 128; /** * Default setting for SQLITE_MAX_COLUMN is 2000. * We can set it at compile time to as large as 32767 @@ -327,8 +328,6 @@ private: struct SharedBlockHeader { /* Offset of the lowest unused byte in the block. */ uint32_t unusedOffset; - /* Offset of the first row group. */ - uint32_t firstRowGroupOffset; /* Row numbers of the row group block. */ uint32_t rowNums; /* Column numbers of the row group block. */ @@ -339,11 +338,11 @@ private: uint32_t lastPos_; /* current position of the current block. */ uint32_t blockPos_; + uint32_t groupOffset[GROUP_NUM]; }; struct RowGroupHeader { - uint32_t rowOffsets[ROW_OFFSETS_NUM]; - uint32_t nextGroupOffset; + uint32_t rowOffsets[ROW_NUM_IN_A_GROUP]; }; SharedBlockHeader *mHeader; @@ -352,35 +351,23 @@ private: * Allocate a portion of the block. Returns the offset of the allocation. * Returns 0 if there isn't enough space. */ - uint32_t Alloc(size_t size, bool aligned = false); + uint32_t Alloc(size_t size); - inline uint32_t *GetRowOffset(uint32_t row); + inline uint32_t GetRowOffset(uint32_t row); uint32_t *AllocRowOffset(); - int PutBlobOrString(uint32_t row, uint32_t column, const void *value, size_t size, int32_t type); + inline int PutBlobOrString(uint32_t row, uint32_t column, const void *value, size_t size, int32_t type); static int CreateSharedBlock(const std::string &name, size_t size, sptr ashmem, SharedBlock *&outSharedBlock); - uint32_t OffsetFromPtr(void *ptr); - inline void *OffsetToPtr(uint32_t offset, uint32_t bufferSize = 0) { if (offset + bufferSize > mSize) { return nullptr; } return mData + offset; } - - /** - * Convert utf8 string to utf16. - */ - static std::u16string ToUtf16(std::string str); - - /** - * Convert utf16 string to utf8. - */ - static std::string ToUtf8(std::u16string str16); }; } // namespace AppDataFwk } // namespace OHOS diff --git a/interfaces/inner_api/rdb/include/abs_shared_result_set.h b/interfaces/inner_api/rdb/include/abs_shared_result_set.h index 73dc022f00060f3dc211bf2f4ba5033c054e0c2a..b9095a41b27056f51fa39d37f85c0b1e41ca3822 100644 --- a/interfaces/inner_api/rdb/include/abs_shared_result_set.h +++ b/interfaces/inner_api/rdb/include/abs_shared_result_set.h @@ -215,7 +215,6 @@ public: protected: int CheckState(int columnIndex); void ClearBlock(); - void InitBlock(); void ClosedBlock(); virtual void Finalize();