Update for V5.8

Author: knonomura

server/base_container.cpp

@@ -557,6 +557,74 @@ void BaseContainer::searchColumnIdIndex(TransactionContext &txn,
 	}
 }
 
+int64_t BaseContainer::estimateIndexSearchSize(
+		TransactionContext &txn, BtreeMap::SearchContext &sc) {
+	const util::Vector<ColumnId> &columnIds = sc.getColumnIds();
+
+	uint64_t estimationSize;
+	if (getContainerType() == TIME_SERIES_CONTAINER &&
+			columnIds.size() == 1 && columnIds.front() == 0) {
+		estimateRowIdIndexSearchSize(txn, sc, estimationSize);
+	}
+	else {
+		if (!estimateColumnIdIndexSearchSize(txn, sc, estimationSize)) {
+			return -1;
+		}
+	}
+
+	return static_cast<int64_t>(std::min(
+			estimationSize,
+			static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
+}
+
+void BaseContainer::estimateRowIdIndexSearchSize(
+		TransactionContext &txn, BtreeMap::SearchContext &sc,
+		uint64_t &estimationSize) {
+	estimationSize = 0;
+
+	const util::Vector<ColumnId> &columnIds = sc.getColumnIds();
+	assert(columnIds.size() == 1 && columnIds.front() == 0);
+	static_cast<void>(columnIds);
+
+	StackAllocAutoPtr<BtreeMap> rowIdMap(
+			txn.getDefaultAllocator(), getRowIdMap(txn));
+	estimationSize = toEstimationSize(rowIdMap.get()->estimate(txn, sc));
+}
+
+bool BaseContainer::estimateColumnIdIndexSearchSize(
+		TransactionContext &txn, BtreeMap::SearchContext &sc,
+		uint64_t &estimationSize) {
+	estimationSize = 0;
+
+	const MapType mapType = MAP_TYPE_BTREE;
+	const bool withUncommitted = false;
+
+	const util::Vector<ColumnId> &columnIds = sc.getColumnIds();
+	IndexData &indexData = sc.prepareIndexData(txn.getDefaultAllocator());
+	if (!getIndexData(txn, columnIds, mapType, withUncommitted, indexData)) {
+		return false;
+	}
+
+	ValueMap valueMap(txn, this, indexData);
+	estimationSize = toEstimationSize(valueMap.estimate<BtreeMap>(txn, sc));
+	return true;
+}
+
+uint64_t BaseContainer::toEstimationSize(uint64_t base) {
+	if (base <= 0) {
+		return 0;
+	}
+
+	const uint64_t max = std::numeric_limits<uint64_t>::max();
+	const uint64_t total = getRowNum();
+
+	const double rate = static_cast<double>(base) / static_cast<double>(max);
+	const double rawSize = rate * static_cast<double>(total);
+
+	const uint64_t size = static_cast<uint64_t>(rawSize);
+	return std::min(std::max<uint64_t>(size, 1), total);
+}
+
 /*!
 	@brief Get list of Row in Message format
 */
@@ -1984,6 +2052,8 @@ void BaseContainer::resolveExclusiveStatus(TransactionContext& txn) {
 		return;
 	}
 
+	util::StackAllocator::Scope scope(txn.getDefaultAllocator());
+
 	BtreeMap::SearchContext sc (txn.getDefaultAllocator(), UNDEF_COLUMNID);
 	const bool checkOnly = true;
 	util::XArray<OId> dummyList(txn.getDefaultAllocator());
@@ -2614,6 +2684,13 @@ int32_t BaseContainer::ValueMap::search<BtreeMap>(TransactionContext &txn,
 	return 0;
 }
 
+template <typename T>
+uint64_t BaseContainer::ValueMap::estimate(
+		TransactionContext &txn, typename T::SearchContext &sc) {
+	const bool forNull = false;
+	T *map = static_cast<T*>(getValueMap(txn, forNull));
+	return map->estimate(txn, sc);
+}
 
 /*!
 	@brief Check if Container has data of uncommited transaction

server/base_container.h

@@ -123,12 +123,20 @@ class BaseContainer : public BaseObject {
 		MapType getMapType() {
 			return indexData_.mapType_;
 		}
+
+		template <typename T>
+		int32_t search(
+				TransactionContext &txn, typename T::SearchContext &sc,
+				util::XArray<OId> &oIdList, OutputOrder outputOrder);
+
 		template <typename T>
-		int32_t search(TransactionContext &txn, typename T::SearchContext &sc,
-			util::XArray<OId> &oIdList, OutputOrder outputOrder);
+		uint64_t estimate(
+				TransactionContext &txn, typename T::SearchContext &sc);
+
 		TreeFuncInfo *getFuncInfo(TransactionContext &txn) {
 			return getValueMap(txn, false)->getFuncInfo();
 		}
+
 	private:
 		BaseContainer *container_;
 		IndexAutoPtr valueMap_;
@@ -395,6 +403,16 @@ class BaseContainer : public BaseObject {
 		BtreeMap::SearchContext &sc, util::XArray<OId> &normalRowList,
 		util::XArray<OId> &mvccRowList);
 
+	int64_t estimateIndexSearchSize(
+			TransactionContext &txn, BtreeMap::SearchContext &sc);
+	void estimateRowIdIndexSearchSize(
+			TransactionContext &txn, BtreeMap::SearchContext &sc,
+			uint64_t &estimationSize);
+	bool estimateColumnIdIndexSearchSize(
+			TransactionContext &txn, BtreeMap::SearchContext &sc,
+			uint64_t &estimationSize);
+	uint64_t toEstimationSize(uint64_t base);
+
 	void getRowList(TransactionContext &txn, util::XArray<OId> &oIdList,
 		ResultSize limit, ResultSize &resultNum,
 		MessageRowStore *messageRowStore, bool isWithRowId,

server/btree_map.cpp

@@ -95,6 +95,9 @@ struct BtreeMap::MapKeyTraits<CompositeInfoObject136> {
 #if !GS_BTREE_MAP_DEFINE_SWITCHER_ONLY
 int32_t BtreeMap::compositeInfoCmp(TransactionContext &txn, ObjectManagerV4 &objectManager, AllocateStrategy &strategy,
 						 const CompositeInfoObject *e1, const CompositeInfoObject *e2, BaseIndex::Setting &setting) {
+
+	util::StackAllocator::Scope scope(txn.getDefaultAllocator());
+
 	int32_t ret = 0;
 	TreeFuncInfo *funcInfo = setting.getFuncInfo();
 	assert(funcInfo != NULL);
@@ -133,6 +136,9 @@ int32_t BtreeMap::compositeInfoCmp(TransactionContext &txn, ObjectManagerV4 &obj
 template <>
 bool BtreeMap::compositeInfoMatch(TransactionContext &txn, ObjectManagerV4 &objectManager,
 						 const CompositeInfoObject *e, BaseIndex::Setting &setting) {
+
+	util::StackAllocator::Scope scope(txn.getDefaultAllocator());
+
 	bool isMatch = true;
 	TreeFuncInfo *funcInfo = setting.getFuncInfo();
 	VariableArrayCursor *cursor = NULL;

server/btree_map.h

@@ -535,6 +535,8 @@ class BtreeMap : public BaseIndex {
 		return rootNode.getTailNodeOId();
 	}
 
+	uint64_t estimate(TransactionContext &txn, SearchContext &sc);
+
 	inline bool isEmpty() const {
 		BNode<char, char> rootNode(this, *const_cast<AllocateStrategy*>(&allocateStrategy_));
 		return rootNode.numkeyValues() == 0;
@@ -619,6 +621,39 @@ class BtreeMap : public BaseIndex {
 		}
 	};
 
+	template <typename P, typename K, typename V, CompareComponent C>
+	class BoundaryCmpFunctor {
+	public:
+		BoundaryCmpFunctor(bool lower, bool inclusive) :
+				eqRet_(resolveEqResult(lower, inclusive)) {
+		}
+
+		int32_t operator()(
+				TransactionContext &txn, ObjectManagerV4 &objectManager,
+				AllocateStrategy &strategy, const KeyValue<P, V> &e1,
+				const KeyValue<K, V> &e2, Setting &setting) const {
+			CmpFunctor<P, K, V, C> base;
+			const int32_t baseRet =
+					base(txn, objectManager, strategy, e1, e2, setting);
+			if (baseRet == 0) {
+				return eqRet_;
+			}
+			return baseRet;
+		}
+
+	private:
+		static int32_t resolveEqResult(bool lower, bool inclusive) {
+			if (inclusive) {
+				return 0;
+			}
+			else {
+				return (lower ? 1 : -1);
+			}
+		}
+
+		int32_t eqRet_;
+	};
+
 	/*!
 		@brief Btree Node Header format
 	*/
@@ -1232,6 +1267,10 @@ class BtreeMap : public BaseIndex {
 	};
 
 	struct SearchBulkFunc;
+	struct EstimateFunc;
+
+	typedef std::pair<int32_t, int32_t> LocationEntry;
+	typedef util::Vector<LocationEntry> LocationPath;
 
 	template<typename Action>
 	void switchToBasicType(ColumnType type, Action &action);
@@ -1912,6 +1951,11 @@ class BtreeMap : public BaseIndex {
 			TransactionContext &txn, SearchContext &sc, util::XArray<R> &idList,
 			Setting &setting, BNode<K, V> &node, int32_t &loc);
 
+	template <typename P, typename K, typename V, typename C>
+	bool findNodeCustom(
+			TransactionContext &txn, KeyValue<P, V> &val, BNode<K, V> &node,
+			int32_t &loc, C &cmp, Setting &setting);
+
 	template <typename P, typename K, typename V, typename R, CompareComponent C>
 	bool findGreaterNext(
 			TransactionContext &txn, KeyValue<P, V> &keyValue,
@@ -1935,6 +1979,41 @@ class BtreeMap : public BaseIndex {
 			TransactionContext &txn, KeyValue<P, V> &val, BNode<K, V> &node,
 			int32_t &loc, CmpFunctor<P, K, V, C> &cmp, Setting &setting);
 
+	template<typename P, typename K, typename V, CompareComponent C>
+	uint64_t estimateAt(TransactionContext &txn, SearchContext &sc);
+
+	template<typename K, typename V>
+	uint64_t estimatePathRange(
+			TransactionContext &txn, const LocationPath &beginPath,
+			const LocationPath &endPath);
+
+	uint64_t estimatePathRangeSub(
+			const LocationPath &beginPath, const LocationPath &endPath);
+
+	static uint64_t mergePathRangeSize(uint64_t size1, uint64_t size2);
+
+	template<typename P, typename K, typename V, CompareComponent C>
+	void findLocationPath(
+			TransactionContext &txn, KeyValue<P, V> &keyValue,
+			bool inclusive, bool less, Setting &setting, LocationPath &path);
+
+	template<typename K, typename V>
+	void getHeadLocationPath(
+			TransactionContext &txn, LocationPath &path);
+	template<typename K, typename V>
+	void getTailLocationPath(
+			TransactionContext &txn, LocationPath &path);
+
+	template<typename K, typename V>
+	bool findMiddleLocationPath(
+			TransactionContext &txn,  const LocationPath &beginPath,
+			const LocationPath &endPath, LocationPath &path);
+
+	template<typename K, typename V>
+	void nodeToLocationPath(
+			TransactionContext &txn, BNode<K, V> &node, int32_t &loc,
+			LocationPath &path);
+
 	static void errorInvalidSearchCondition();
 };