BaseContainer::RowArray::RowArray(TransactionContext &txn, BaseContainer *container) : rowArrayImplList_(txn.getDefaultAllocator()), rowArrayStorage_(txn.getPartitionId(), *container->getObjectManager()), rowCache_(txn, container), defaultImpl_(NULL) { if (container->getContainerType() == COLLECTION_CONTAINER) { latestParam_.rowDataOffset_ = getColFixedOffset(); latestParam_.rowIdOffset_ = getColRowIdOffset(); latestParam_.rowHeaderOffset_ = COL_ROW_HEADER_OFFSET; } else if (container->getContainerType() == TIME_SERIES_CONTAINER) { latestParam_.rowDataOffset_ = sizeof(RowHeader); latestParam_.rowIdOffset_ = latestParam_.rowDataOffset_ + container->getColumnInfo(ColumnInfo::ROW_KEY_COLUMN_ID) .getColumnOffset(); latestParam_.rowHeaderOffset_ = TIM_ROW_HEADER_OFFSET; } else { assert(false); GS_THROW_USER_ERROR(GS_ERROR_DS_DS_CONTAINER_TYPE_INVALID, ""); } latestParam_.varColumnNum_ = container->getVariableColumnNum(); latestParam_.varHeaderSize_ = ValueProcessor::getEncodedVarSize(latestParam_.varColumnNum_); latestParam_.columnNum_ = container->getColumnNum(); latestParam_.nullOffsetDiff_ = 0; latestParam_.columnOffsetDiff_ = 0; latestParam_.rowSize_ = container->getRowSize(); latestParam_.rowFixedColumnSize_ = container->getRowFixedColumnSize(); latestParam_.nullbitsSize_ = container->getNullbitsSize(); latestParam_.nullsOffset_ = latestParam_.rowSize_ - (latestParam_.nullbitsSize_ + latestParam_.rowFixedColumnSize_); typedef BaseContainer::RowArrayImpl<BaseContainer, BaseContainer::ROW_ARRAY_GENERAL> GeneralRowArrayImpl; typedef BaseContainer::RowArrayImpl<BaseContainer, BaseContainer::ROW_ARRAY_PLAIN> PlainRowArrayImpl; util::StackAllocator &alloc = txn.getDefaultAllocator(); GeneralRowArrayImpl *generalImpl = ALLOC_NEW(alloc) GeneralRowArrayImpl( txn, container, rowArrayStorage_, rowCache_, latestParam_); PlainRowArrayImpl *plainImpl = reinterpret_cast<PlainRowArrayImpl *>(generalImpl); rowArrayImplList_.push_back(generalImpl); rowArrayImplList_.push_back(plainImpl); defaultImpl_ = getImpl<BaseContainer, BaseContainer::ROW_ARRAY_GENERAL>(); }
StringCursor::StringCursor(TransactionContext &txn, const char *str) : BaseObject(NULL), zeroLengthStr_(ZERO_LENGTH_STR_BINARY_) { setBaseOId(UNDEF_OID); if (str == NULL) { setBaseAddr(&zeroLengthStr_); length_ = 0; } else { length_ = static_cast<uint32_t>(strlen(str)); size_t offset = ValueProcessor::getEncodedVarSize(length_); setBaseAddr( ALLOC_NEW(txn.getDefaultAllocator()) uint8_t[offset + length_]); uint64_t encodedLength = ValueProcessor::encodeVarSize(length_); memcpy(getBaseAddr(), &encodedLength, offset); memcpy(getBaseAddr() + offset, str, length_); moveCursor(offset); } }
BaseContainer::RowCache::RowCache(TransactionContext &txn, BaseContainer *container) : fieldCacheList_(txn.getDefaultAllocator()) { ObjectManager &objectManager = *(container->getObjectManager()); new (frontFieldCache_.addr()) FieldCache(txn.getPartitionId(), objectManager); const uint32_t varCount = container->getVariableColumnNum(); lastCachedField_ = 0; if (varCount > 0) { assert(fieldCacheList_.empty()); fieldCacheList_.resize(varCount); for (uint32_t i = varCount; i > 0; i--) { void *addr = &fieldCacheList_[i - 1]; new (addr) FieldCache(txn.getPartitionId(), objectManager); } } }
void HashMap::split(TransactionContext& txn) { if (hashMapImage_->split_ == hashMapImage_->front_) { hashMapImage_->split_ = 0; hashMapImage_->front_ = hashMapImage_->front_ << 1; hashMapImage_->toSplit_ = false; } uint64_t bucketAddr0 = hashMapImage_->split_; uint64_t bucketAddr1 = hashMapImage_->rear_; hashMapImage_->split_++; hashMapImage_->rear_++; if (hashMapImage_->rear_ > hashArray_.size()) { hashArray_.twiceHashArray(txn); if (hashMapImage_->rear_ > hashArray_.size()) { GS_THROW_SYSTEM_ERROR(GS_ERROR_DS_HM_MAX_ARRY_SIZE_OVER, ""); } } Bucket splitBucket( txn, *getObjectManager(), maxArraySize_, maxCollisionArraySize_); hashArray_.get(txn, bucketAddr0, splitBucket); Bucket::Cursor cursor(txn, *getObjectManager()); splitBucket.set(txn, cursor); if (cursor.size_ == 0) { ; } else { util::XArray<OId> remainOIdList(txn.getDefaultAllocator()); Bucket newBucket1( txn, *getObjectManager(), maxArraySize_, maxCollisionArraySize_); hashArray_.get(txn, bucketAddr1, newBucket1); size_t bucket0Size = 0; size_t bucket1Size = 0; bool isCurrent = splitBucket.next(txn, cursor); while (isCurrent) { OId oId = splitBucket.getCurrentOId(cursor); uint32_t addr = hashBucketAddrFromObject<T>(txn, oId); if (addr == bucketAddr0) { bucket0Size++; remainOIdList.push_back(oId); } else { bucket1Size++; newBucket1.append(txn, oId); } isCurrent = splitBucket.next(txn, cursor); } cursor.array_.reset(); if (bucket1Size > 0) { splitBucket.clear(txn); for (size_t i = 0; i < remainOIdList.size(); i++) { splitBucket.append(txn, remainOIdList[i]); } } else if (bucket0Size > 1) { remainOIdList.clear(); } } return; }