Reverted experimental modification [#CONV-2944].

dbms/include/DB/Columns/ColumnAggregateFunction.h

@@ -10,7 +10,7 @@ namespace DB
 
 /** Столбец, хранящий состояния агрегатных функций.
   */
-class ColumnAggregateFunction : public ColumnVector<AggregateFunctionPtr, std::vector<AggregateFunctionPtr> >
+class ColumnAggregateFunction : public ColumnVector<AggregateFunctionPtr>
 {
 public:
  	std::string getName() const { return "ColumnAggregateFunction"; }
@@ -62,12 +62,13 @@ public:
 		return 0;
 	}
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
 		size_t s = data.size();
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
+		return res;
 	}
 };
 

dbms/include/DB/Columns/ColumnArray.h

@@ -241,16 +241,16 @@ public:
 		}
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
-		Permutation nested_perm;
-		data->getPermutation(nested_perm);
+		Permutation nested_perm = data->getPermutation();
 		size_t s = size();
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
 
 		std::sort(res.begin(), res.end(), less(*this, nested_perm));
+		return res;
 	}
 
 	size_t byteSize() const

dbms/include/DB/Columns/ColumnConst.h

@@ -88,11 +88,12 @@ public:
 				: 1);
 	}
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
+		return res;
 	}
 
 	StringRef getDataAt(size_t n) const;

dbms/include/DB/Columns/ColumnFixedArray.h

@@ -173,16 +173,16 @@ public:
 		}
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
-		Permutation nested_perm;
-		data->getPermutation(nested_perm);
+		Permutation nested_perm = data->getPermutation();
 		size_t s = data->size() / n;
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
 
 		std::sort(res.begin(), res.end(), less(*this, nested_perm));
+		return res;
 	}
 
 	size_t byteSize() const

dbms/include/DB/Columns/ColumnFixedString.h

@@ -93,14 +93,15 @@ public:
 		}
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
 		size_t s = size();
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
 
 		std::sort(res.begin(), res.end(), less(*this));
+		return res;
 	}
 
 	void replicate(const Offsets_t & offsets)

dbms/include/DB/Columns/ColumnSet.h

@@ -44,11 +44,12 @@ public:
 			throw Exception("Size of permutation doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
 	}
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
+		return res;
 	}
 
 	void replicate(const Offsets_t & offsets)

dbms/include/DB/Columns/ColumnString.h

@@ -166,14 +166,15 @@ public:
 		}
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
 		size_t s = getOffsets().size();
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
 
 		std::sort(res.begin(), res.end(), less(*this));
+		return res;
 	}
 
 	void replicate(const Offsets_t & replicate_offsets)

dbms/include/DB/Columns/ColumnTuple.h

@@ -137,15 +137,16 @@ public:
 		}
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
 		size_t rows = size();
-		res.resize(rows);
+		Permutation perm(rows);
 		for (size_t i = 0; i < rows; ++i)
-			res[i] = i;
+			perm[i] = i;
 
 		Less less(columns);
-		std::sort(res.begin(), res.end(), less);
+		std::sort(perm.begin(), perm.end(), less);
+		return perm;
 	}
 
 	void clear()

dbms/include/DB/Columns/ColumnVector.h

@@ -57,15 +57,14 @@ public:
 };
 
 	
-/** Шаблон столбцов, которые используют для хранения непрерывный кусок памяти.
+/** Шаблон столбцов, которые используют для хранения std::vector.
   */
-template <typename T, typename Container = PODArray<T> >
+template <typename T>
 class ColumnVector : public IColumn
 {
 public:
 	typedef T value_type;
-	typedef Container Container_t;
-	typedef ColumnVector<T, Container> Self;
+	typedef std::vector<value_type> Container_t;
 
 	ColumnVector() {}
 	ColumnVector(size_t n) : data(n) {}
@@ -78,7 +77,7 @@ public:
 
 	ColumnPtr cloneEmpty() const
 	{
-		return new Self;
+		return new ColumnVector<T>;
 	}
 
 	size_t size() const
@@ -106,7 +105,7 @@ public:
 		if (start + length > data.size())
 			throw Exception("Parameters start = "
 				+ Poco::NumberFormatter::format(start) + ", length = "
-				+ Poco::NumberFormatter::format(length) + " are out of bound in ColumnVector<>::cut() method"
+				+ Poco::NumberFormatter::format(length) + " are out of bound in IColumnVector<T>::cut() method"
 				" (data.size() = " + Poco::NumberFormatter::format(data.size()) + ").",
 				ErrorCodes::PARAMETER_OUT_OF_BOUND);
 
@@ -127,7 +126,7 @@ public:
 
 	void insertFrom(const IColumn & src, size_t n)
 	{
-		data.push_back(static_cast<const Self &>(src).getData()[n]);
+		data.push_back(static_cast<const ColumnVector<T> &>(src).getData()[n]);
 	}
 
 	void insertDefault()
@@ -175,7 +174,7 @@ public:
 
 	int compareAt(size_t n, size_t m, const IColumn & rhs_) const
 	{
-		const Self & rhs = static_cast<const Self &>(rhs_);
+		const ColumnVector<T> & rhs = static_cast<const ColumnVector<T> &>(rhs_);
 		return data[n] < rhs.data[m]
 			? -1
 			: (data[n] == rhs.data[m]
@@ -185,19 +184,21 @@ public:
 
 	struct less
 	{
-		const Self & parent;
-		less(const Self & parent_) : parent(parent_) {}
+		const ColumnVector<T> & parent;
+		less(const ColumnVector<T> & parent_) : parent(parent_) {}
 		bool operator()(size_t lhs, size_t rhs) const { return parent.data[lhs] < parent.data[rhs]; }
 	};
 
-	void getPermutation(Permutation & res) const
+	Permutation getPermutation() const
 	{
 		size_t s = data.size();
-		res.resize(s);
+		Permutation res(s);
 		for (size_t i = 0; i < s; ++i)
 			res[i] = i;
 
 		std::sort(res.begin(), res.end(), less(*this));
+		
+		return res;
 	}
 
 	void replicate(const Offsets_t & offsets)

dbms/include/DB/Columns/IColumn.h

@@ -7,8 +7,6 @@
 #include <DB/Core/ErrorCodes.h>
 #include <DB/Core/StringRef.h>
 
-#include <DB/Common/PODArray.h>
-
 
 namespace DB
 {
@@ -96,13 +94,13 @@ public:
 	/** Оставить только значения, соответствующие фильтру.
 	  * Используется для операции WHERE / HAVING.
 	  */
-	typedef PODArray<UInt8> Filter;
+	typedef std::vector<UInt8> Filter;
 	virtual void filter(const Filter & filt) = 0;
 
 	/** Переставить значения местами, используя указанную перестановку.
 	  * Используется при сортировке.
 	  */
-	typedef PODArray<size_t> Permutation;
+	typedef std::vector<size_t> Permutation;
 	virtual void permute(const Permutation & perm) = 0;
 
 	/** Сравнить (*this)[n] и rhs[m].
@@ -114,13 +112,13 @@ public:
 	/** Получить перестановку чисел, такую, что их порядок соответствует порядку значений в столбце.
 	  * Используется при сортировке.
 	  */
-	virtual void getPermutation(Permutation & res) const = 0;
+	virtual Permutation getPermutation() const = 0;
 
 	/** Размножить все значения столько раз, сколько прописано в offsets.
 	  * (i-е значение размножается в offsets[i] - offsets[i - 1] значений.)
 	  */
 	typedef UInt64 Offset_t;
-	typedef PODArray<Offset_t> Offsets_t;
+	typedef std::vector<Offset_t> Offsets_t;
 	virtual void replicate(const Offsets_t & offsets) = 0;
 
 	/** Очистить */

dbms/include/DB/Common/PODArray.h

-#pragma once
-
-#include <string.h>
-#include <cstddef>
-#include <sys/mman.h>
-#include <algorithm>
-
-#include <boost/noncopyable.hpp>
-
-#include <Yandex/optimization.h>
-
-#include <DB/Core/Exception.h>
-
-
-namespace DB
-{
-
-/** Динамический массив для POD-типов.
-  * Предназначен для небольшого количества больших массивов (а не большого количества маленьких).
-  * А точнее - для использования в ColumnVector.
-  * Отличается от std::vector тем, что использует mremap для ресайза, а также не инициализирует элементы.
-  *  (впрочем, mmap даёт память, инициализированную нулями, так что можно считать, что элементы инициализируются)
-  * Сделано noncopyable, чтобы не было случайных копий. Скопировать данные можно с помощью метода assign.
-  * Поддерживается только часть интерфейса std::vector.
-  *
-  * Если вставлять элементы push_back-ом, не делая reserve, то PODArray примерно в 2.5 раза быстрее std::vector.
-  */
-template <typename T>
-class PODArray : private boost::noncopyable
-{
-private:
-	static const size_t initial_size = 4096;
-
-	char * c_start;
-	char * c_end;
-	char * c_end_of_storage;
-
-	T * t_start() 						{ return reinterpret_cast<T *>(c_start); }
-	T * t_end() 						{ return reinterpret_cast<T *>(c_end); }
-	T * t_end_of_storage() 				{ return reinterpret_cast<T *>(c_end_of_storage); }
-	
-	const T * t_start() const 			{ return reinterpret_cast<const T *>(c_start); }
-	const T * t_end() const 			{ return reinterpret_cast<const T *>(c_end); }
-	const T * t_end_of_storage() const 	{ return reinterpret_cast<const T *>(c_end_of_storage); }
-
-	size_t storage_size() const { return c_end_of_storage - c_start; }
-	static size_t byte_size(size_t n) { return n * sizeof(T); }
-
-	static size_t round_up_to_power_of_two(size_t n) { return n == 0 ? 0 : (0x8000000000000000ULL >> (__builtin_clzl(n - 1) - 1)); }
-	static size_t to_size(size_t n) { return byte_size(std::max(initial_size, round_up_to_power_of_two(n))); }
-	
-	void alloc(size_t n)
-	{
-		size_t bytes_to_alloc = to_size(n);
-		c_start = c_end = reinterpret_cast<char *>(mmap(NULL, bytes_to_alloc, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
-		c_end_of_storage = c_start + bytes_to_alloc;
-
-		if (MAP_FAILED == c_start)
-			throwFromErrno("PODArray: Cannot mmap.");
-	}
-
-	void dealloc()
-	{
-		if (0 != munmap(c_start, storage_size()))
-			throwFromErrno("PODArray: Cannot munmap.");
-	}
-
-	void realloc(size_t n)
-	{
-		ptrdiff_t end_diff = c_end - c_start;
-		size_t bytes_to_alloc = to_size(n);
-		c_start = reinterpret_cast<char *>(mremap(c_start, storage_size(), bytes_to_alloc, MREMAP_MAYMOVE));
-		c_end = c_start + end_diff;
-		c_end_of_storage = c_start + bytes_to_alloc;
-
-		if (MAP_FAILED == c_start)
-			throwFromErrno("PODArray: Cannot mremap.");
-	}
-
-public:
-	typedef T value_type;
-	typedef T * iterator;
-	typedef const T * const_iterator;
-	
-	PODArray() { alloc(initial_size); }
-    PODArray(size_t n) { alloc(n); c_end += byte_size(n); }
-    PODArray(size_t n, const T & x) { alloc(n); assign(n, x); }
-    PODArray(const_iterator from_begin, const_iterator from_end) { alloc(from_end - from_begin); insert(from_end - from_begin); }
-    ~PODArray() { dealloc(); }
-
-    size_t size() const { return t_end() - t_start(); }
-    bool empty() const { return t_end() == t_start(); }
-    size_t capacity() const { return t_end_of_storage() - t_start(); }
-
-	T & operator[] (size_t n) 				{ return t_start()[n]; }
-	const T & operator[] (size_t n) const 	{ return t_start()[n]; }
-
-	T & front() 			{ return t_start()[0]; }
-	T & back() 				{ return t_end()[-1]; }
-	const T & front() const { return t_start()[0]; }
-	const T & back() const  { return t_end()[-1]; }
-
-	iterator begin() 				{ return t_start(); }
-	iterator end() 					{ return t_end(); }
-	const_iterator begin() const	{ return t_start(); }
-	const_iterator end() const		{ return t_end(); }
-
-	void reserve(size_t n)
-	{
-		if (n > capacity())
-			realloc(n);
-	}
-
-	void reserve()
-	{
-		realloc(size() * 2);
-	}
-
-	void resize(size_t n)
-	{
-		reserve(n);
-		c_end = c_start + byte_size(n);
-	}
-
-	void clear()
-	{
-		c_end = c_start;
-	}
-
-	void push_back(const T & x)
-	{
-		if (unlikely(c_end == c_end_of_storage))
-			reserve();
-
-		*t_end() = x;
-		c_end += byte_size(1);
-	}
-
-	/// Не вставляйте в массив кусок самого себя. Потому что при ресайзе, итераторы на самого себя могут инвалидироваться.
-	void insert(const_iterator from_begin, const_iterator from_end)
-	{
-		size_t required_capacity = size() + from_end - from_begin;
-		if (required_capacity > capacity())
-			reserve(round_up_to_power_of_two(required_capacity));
-
-		size_t bytes_to_copy = byte_size(from_end - from_begin);
-		memcpy(c_end, reinterpret_cast<const void *>(from_begin), bytes_to_copy);
-		c_end += bytes_to_copy;
-	}
-
-	void swap(PODArray<T> & rhs)
-	{
-		std::swap(c_start, rhs.c_start);
-		std::swap(c_end, rhs.c_end);
-		std::swap(c_end_of_storage, rhs.c_end_of_storage);
-	}
-
-	void assign(size_t n, const T & x)
-	{
-		resize(n);
-		std::fill(begin(), end(), x);
-	}
-
-	void assign(const_iterator from_begin, const_iterator from_end)
-	{
-		size_t required_capacity = from_end - from_begin;
-		if (required_capacity > capacity())
-			reserve(round_up_to_power_of_two(required_capacity));
-
-		size_t bytes_to_copy = byte_size(required_capacity);
-		memcpy(c_start, reinterpret_cast<const void *>(from_begin), bytes_to_copy);
-		c_end = c_start + bytes_to_copy;
-	}
-
-	void assign(const PODArray<T> & from)
-	{
-		assign(from.begin(), from.end());
-	}
-};
-
-
-}

dbms/include/DB/Functions/FunctionsArithmetic.h

@@ -20,21 +20,21 @@ struct BinaryOperationImpl
 {
 	typedef typename Op::ResultType ResultType;
 
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<ResultType> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<ResultType> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = Op::apply(a[i], b[i]);
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<ResultType> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<ResultType> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = Op::apply(a[i], b);
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<ResultType> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<ResultType> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -52,7 +52,7 @@ struct UnaryOperationImpl
 {
 	typedef typename Op::ResultType ResultType;
 
-	static void vector(const PODArray<A> & a, PODArray<ResultType> & c)
+	static void vector(const std::vector<A> & a, std::vector<ResultType> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)

dbms/include/DB/Functions/FunctionsArray.h

@@ -63,9 +63,9 @@ template <typename T>
 struct ArrayElementNumImpl
 {
 	static void vector(
-		const PODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+		const std::vector<T> & data, const ColumnArray::Offsets_t & offsets,
 		const ColumnArray::Offset_t index,	/// Передаётся индекс начиная с нуля, а не с единицы.
-		PODArray<T> & result)
+		std::vector<T> & result)
 	{
 		size_t size = offsets.size();
 		result.resize(size);
@@ -87,9 +87,9 @@ struct ArrayElementNumImpl
 struct ArrayElementStringImpl
 {
 	static void vector(
-		const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+		const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
 		const ColumnArray::Offset_t index,	/// Передаётся индекс начиная с нуля, а не с единицы.
-		PODArray<UInt8> & result_data, ColumnArray::Offsets_t & result_offsets)
+		std::vector<UInt8> & result_data, ColumnArray::Offsets_t & result_offsets)
 	{
 		size_t size = offsets.size();
 		result_offsets.resize(size);
@@ -277,9 +277,9 @@ template <typename T, typename IndexConv>
 struct ArrayIndexNumImpl
 {
 	static void vector(
-		const PODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+		const std::vector<T> & data, const ColumnArray::Offsets_t & offsets,
 		const T value,
-		PODArray<typename IndexConv::ResultType> & result)
+		std::vector<typename IndexConv::ResultType> & result)
 	{
 		size_t size = offsets.size();
 		result.resize(size);
@@ -309,9 +309,9 @@ template <typename IndexConv>
 struct ArrayIndexStringImpl
 {
 	static void vector(
-		const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+		const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
 		const String & value,
-		PODArray<typename IndexConv::ResultType> & result)
+		std::vector<typename IndexConv::ResultType> & result)
 	{
 		size_t size = offsets.size();
 		size_t value_size = value.size();

dbms/include/DB/Functions/FunctionsComparison.h

@@ -39,21 +39,21 @@ namespace DB
 template<typename A, typename B>
 struct EqualsNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] == b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] == b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -69,9 +69,9 @@ struct EqualsNumImpl
 struct EqualsStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -82,9 +82,9 @@ struct EqualsStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -95,9 +95,9 @@ struct EqualsStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -110,9 +110,9 @@ struct EqualsStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -123,9 +123,9 @@ struct EqualsStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -133,9 +133,9 @@ struct EqualsStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -146,8 +146,8 @@ struct EqualsStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -161,8 +161,8 @@ struct EqualsStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());
@@ -183,21 +183,21 @@ struct EqualsStringImpl
 template<typename A, typename B>
 struct NotEqualsNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] != b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] != b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -213,9 +213,9 @@ struct NotEqualsNumImpl
 struct NotEqualsStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -226,9 +226,9 @@ struct NotEqualsStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -239,9 +239,9 @@ struct NotEqualsStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -254,9 +254,9 @@ struct NotEqualsStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -267,9 +267,9 @@ struct NotEqualsStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -277,9 +277,9 @@ struct NotEqualsStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -290,8 +290,8 @@ struct NotEqualsStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -305,8 +305,8 @@ struct NotEqualsStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());
@@ -327,21 +327,21 @@ struct NotEqualsStringImpl
 template<typename A, typename B>
 struct LessNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] < b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] < b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -357,9 +357,9 @@ struct LessNumImpl
 struct LessStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -379,9 +379,9 @@ struct LessStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -401,9 +401,9 @@ struct LessStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -425,9 +425,9 @@ struct LessStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -447,9 +447,9 @@ struct LessStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -460,9 +460,9 @@ struct LessStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -476,8 +476,8 @@ struct LessStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -500,8 +500,8 @@ struct LessStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());
@@ -525,21 +525,21 @@ struct LessStringImpl
 template<typename A, typename B>
 struct GreaterNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] > b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] > b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -555,9 +555,9 @@ struct GreaterNumImpl
 struct GreaterStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -577,9 +577,9 @@ struct GreaterStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -599,9 +599,9 @@ struct GreaterStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -623,9 +623,9 @@ struct GreaterStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -645,9 +645,9 @@ struct GreaterStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -658,9 +658,9 @@ struct GreaterStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -674,8 +674,8 @@ struct GreaterStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -698,8 +698,8 @@ struct GreaterStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());
@@ -723,21 +723,21 @@ struct GreaterStringImpl
 template<typename A, typename B>
 struct LessOrEqualsNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] <= b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] <= b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -753,9 +753,9 @@ struct LessOrEqualsNumImpl
 struct LessOrEqualsStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -775,9 +775,9 @@ struct LessOrEqualsStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -797,9 +797,9 @@ struct LessOrEqualsStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -821,9 +821,9 @@ struct LessOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -843,9 +843,9 @@ struct LessOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -856,9 +856,9 @@ struct LessOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -872,8 +872,8 @@ struct LessOrEqualsStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -896,8 +896,8 @@ struct LessOrEqualsStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());
@@ -921,21 +921,21 @@ struct LessOrEqualsStringImpl
 template<typename A, typename B>
 struct GreaterOrEqualsNumImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] >= b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] >= b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -951,9 +951,9 @@ struct GreaterOrEqualsNumImpl
 struct GreaterOrEqualsStringImpl
 {
 	static void string_vector_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -973,9 +973,9 @@ struct GreaterOrEqualsStringImpl
 	}
 
 	static void string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -995,9 +995,9 @@ struct GreaterOrEqualsStringImpl
 	}
 
 	static void string_vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_offsets.size();
 		ColumnArray::Offset_t b_n = b.size();
@@ -1019,9 +1019,9 @@ struct GreaterOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -1041,9 +1041,9 @@ struct GreaterOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_fixed_string_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		for (size_t i = 0, j = 0; i < size; i += a_n, ++j)
@@ -1054,9 +1054,9 @@ struct GreaterOrEqualsStringImpl
 	}
 
 	static void fixed_string_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c)
+		std::vector<UInt8> & c)
 	{
 		size_t size = a_data.size();
 		const UInt8 * b_data = reinterpret_cast<const UInt8 *>(b.data());
@@ -1070,8 +1070,8 @@ struct GreaterOrEqualsStringImpl
 
 	static void constant_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_offsets.size();
 		ColumnArray::Offset_t a_n = a.size();
@@ -1094,8 +1094,8 @@ struct GreaterOrEqualsStringImpl
 
 	static void constant_fixed_string_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c)
 	{
 		size_t size = b_data.size();
 		const UInt8 * a_data = reinterpret_cast<const UInt8 *>(a.data());

dbms/include/DB/Functions/FunctionsConditional.h

@@ -21,9 +21,9 @@ template <typename T>
 struct NumIfImpl
 {
 	static void vector_vector(
-		const PODArray<UInt8> & cond,
-		const PODArray<T> & a, const PODArray<T> & b,
-		PODArray<T> & res)
+		const std::vector<UInt8> & cond,
+		const std::vector<T> & a, const std::vector<T> & b,
+		std::vector<T> & res)
 	{
 		size_t size = cond.size();
 		for (size_t i = 0; i < size; ++i)
@@ -31,9 +31,9 @@ struct NumIfImpl
 	}
 
 	static void vector_constant(
-		const PODArray<UInt8> & cond,
-		const PODArray<T> & a, T b,
-		PODArray<T> & res)
+		const std::vector<UInt8> & cond,
+		const std::vector<T> & a, T b,
+		std::vector<T> & res)
 	{
 		size_t size = cond.size();
 		for (size_t i = 0; i < size; ++i)
@@ -41,9 +41,9 @@ struct NumIfImpl
 	}
 
 	static void constant_vector(
-		const PODArray<UInt8> & cond,
-		T a, const PODArray<T> & b,
-		PODArray<T> & res)
+		const std::vector<UInt8> & cond,
+		T a, const std::vector<T> & b,
+		std::vector<T> & res)
 	{
 		size_t size = cond.size();
 		for (size_t i = 0; i < size; ++i)
@@ -51,9 +51,9 @@ struct NumIfImpl
 	}
 
 	static void constant_constant(
-		const PODArray<UInt8> & cond,
+		const std::vector<UInt8> & cond,
 		T a, T b,
-		PODArray<T> & res)
+		std::vector<T> & res)
 	{
 		size_t size = cond.size();
 		for (size_t i = 0; i < size; ++i)
@@ -65,10 +65,10 @@ struct NumIfImpl
 struct StringIfImpl
 {
 	static void vector_vector(
-		const PODArray<UInt8> & cond,
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & cond,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = cond.size();
 		c_offsets.resize(size);
@@ -103,10 +103,10 @@ struct StringIfImpl
 	}
 
 	static void vector_constant(
-		const PODArray<UInt8> & cond,
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & cond,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const String & b,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = cond.size();
 		c_offsets.resize(size);
@@ -139,10 +139,10 @@ struct StringIfImpl
 	}
 
 	static void constant_vector(
-		const PODArray<UInt8> & cond,
+		const std::vector<UInt8> & cond,
 		const String & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = cond.size();
 		c_offsets.resize(size);
@@ -175,9 +175,9 @@ struct StringIfImpl
 	}
 
 	static void constant_constant(
-		const PODArray<UInt8> & cond,
+		const std::vector<UInt8> & cond,
 		const String & a, const String & b,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = cond.size();
 		c_offsets.resize(size);
@@ -249,7 +249,7 @@ private:
 		ColumnString * col_res = new ColumnString;
 		block.getByPosition(result).column = col_res;
 
-		PODArray<UInt8> & res_vec = dynamic_cast<ColumnUInt8 &>(col_res->getData()).getData();
+		std::vector<UInt8> & res_vec = dynamic_cast<ColumnUInt8 &>(col_res->getData()).getData();
 		ColumnArray::Offsets_t & res_offsets = col_res->getOffsets();
 
 		if (col_then && col_else)

dbms/include/DB/Functions/FunctionsConversion.h

@@ -162,7 +162,7 @@ struct ConvertImpl<FromDataType, DataTypeString, Name>
 			data_to.resize(size * 2);
 			offsets_to.resize(size);
 
-			WriteBufferFromVector<UInt8, PODArray<UInt8> > write_buffer(data_to);
+			WriteBufferFromVector<UInt8> write_buffer(data_to);
 
 			for (size_t i = 0; i < size; ++i)
 			{

dbms/include/DB/Functions/FunctionsDateTime.h

@@ -302,8 +302,8 @@ template <typename DurationType>
 struct TimeSlotsImpl
 {
 	static void vector_vector(
-		const PODArray<UInt32> & starts, const PODArray<DurationType> & durations,
-		PODArray<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
+		const std::vector<UInt32> & starts, const std::vector<DurationType> & durations,
+		std::vector<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
 	{
 		size_t size = starts.size();
 
@@ -324,8 +324,8 @@ struct TimeSlotsImpl
 	}
 
 	static void vector_constant(
-		const PODArray<UInt32> & starts, DurationType duration,
-		PODArray<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
+		const std::vector<UInt32> & starts, DurationType duration,
+		std::vector<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
 	{
 		size_t size = starts.size();
 
@@ -346,8 +346,8 @@ struct TimeSlotsImpl
 	}
 
 	static void constant_vector(
-		UInt32 start, const PODArray<DurationType> & durations,
-		PODArray<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
+		UInt32 start, const std::vector<DurationType> & durations,
+		std::vector<UInt32> & result_values, ColumnArray::Offsets_t & result_offsets)
 	{
 		size_t size = durations.size();
 

dbms/include/DB/Functions/FunctionsFormatting.h

@@ -74,7 +74,7 @@ public:
 			data_to.resize(size * 2);
 			offsets_to.resize(size);
 
-			WriteBufferFromVector<UInt8, PODArray<UInt8> > buf_to(data_to);
+			WriteBufferFromVector<UInt8> buf_to(data_to);
 
 			for (size_t i = 0; i < size; ++i)
 			{

dbms/include/DB/Functions/FunctionsLogical.h

@@ -16,21 +16,21 @@ namespace DB
 template<typename A, typename B>
 struct AndImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] && b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] && b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -46,21 +46,21 @@ struct AndImpl
 template<typename A, typename B>
 struct OrImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] || b[i];
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = a[i] || b;
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -76,21 +76,21 @@ struct OrImpl
 template<typename A, typename B>
 struct XorImpl
 {
-	static void vector_vector(const PODArray<A> & a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void vector_vector(const std::vector<A> & a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = (a[i] && !b[i]) || (!a[i] && b[i]);
 	}
 
-	static void vector_constant(const PODArray<A> & a, B b, PODArray<UInt8> & c)
+	static void vector_constant(const std::vector<A> & a, B b, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)
 			c[i] = (a[i] && !b) || (!a[i] && b);
 	}
 
-	static void constant_vector(A a, const PODArray<B> & b, PODArray<UInt8> & c)
+	static void constant_vector(A a, const std::vector<B> & b, std::vector<UInt8> & c)
 	{
 		size_t size = b.size();
 		for (size_t i = 0; i < size; ++i)
@@ -106,7 +106,7 @@ struct XorImpl
 template<typename A>
 struct NotImpl
 {
-	static void vector(const PODArray<A> & a, PODArray<UInt8> & c)
+	static void vector(const std::vector<A> & a, std::vector<UInt8> & c)
 	{
 		size_t size = a.size();
 		for (size_t i = 0; i < size; ++i)

dbms/include/DB/Functions/FunctionsMiscellaneous.h

@@ -44,7 +44,7 @@ namespace DB
 
 
 template <typename T>
-static void numWidthVector(const PODArray<T> & a, PODArray<UInt64> & c)
+static void numWidthVector(const std::vector<T> & a, std::vector<UInt64> & c)
 {
 	size_t size = a.size();
 	for (size_t i = 0; i < size; ++i)
@@ -81,7 +81,7 @@ inline UInt64 floatWidth(double x)
 }
 
 template <typename T>
-static void floatWidthVector(const PODArray<T> & a, PODArray<UInt64> & c)
+static void floatWidthVector(const std::vector<T> & a, std::vector<UInt64> & c)
 {
 	size_t size = a.size();
 	for (size_t i = 0; i < size; ++i)
@@ -94,8 +94,8 @@ static void floatWidthConstant(T a, UInt64 & c)
 	c = floatWidth(a);
 }
 
-template <> inline void numWidthVector<Float64>(const PODArray<Float64> & a, PODArray<UInt64> & c) { floatWidthVector(a, c); }
-template <> inline void numWidthVector<Float32>(const PODArray<Float32> & a, PODArray<UInt64> & c) { floatWidthVector(a, c); }
+template <> inline void numWidthVector<Float64>(const std::vector<Float64> & a, std::vector<UInt64> & c) { floatWidthVector(a, c); }
+template <> inline void numWidthVector<Float32>(const std::vector<Float32> & a, std::vector<UInt64> & c) { floatWidthVector(a, c); }
 template <> inline void numWidthConstant<Float64>(Float64 a, UInt64 & c) { floatWidthConstant(a, c); }
 template <> inline void numWidthConstant<Float32>(Float32 a, UInt64 & c) { floatWidthConstant(a, c); }
 
@@ -112,7 +112,7 @@ static inline UInt64 stringWidth(const UInt8 * pos, const UInt8 * end)
 	return res;
 }
 
-static inline void stringWidthVector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets, PODArray<UInt64> & res)
+static inline void stringWidthVector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets, std::vector<UInt64> & res)
 {
 	size_t size = offsets.size();
 
@@ -124,7 +124,7 @@ static inline void stringWidthVector(const PODArray<UInt8> & data, const ColumnA
 	}
 }
 
-static inline void stringWidthFixedVector(const PODArray<UInt8> & data, size_t n, PODArray<UInt64> & res)
+static inline void stringWidthFixedVector(const std::vector<UInt8> & data, size_t n, std::vector<UInt64> & res)
 {
 	size_t size = data.size() / n;
 	for (size_t i = 0; i < size; ++i)

dbms/include/DB/Functions/FunctionsRandom.h

@@ -43,7 +43,7 @@ struct RandImpl
 {
 	typedef UInt32 ReturnType;
 	
-	static void execute(PODArray<ReturnType> & res)
+	static void execute(std::vector<ReturnType> & res)
 	{
 		drand48_data rand_state;
 		detail::seed(rand_state);
@@ -62,7 +62,7 @@ struct Rand64Impl
 {
 	typedef UInt64 ReturnType;
 
-	static void execute(PODArray<ReturnType> & res)
+	static void execute(std::vector<ReturnType> & res)
 	{
 		drand48_data rand_state;
 		detail::seed(rand_state);

dbms/include/DB/Functions/FunctionsString.h

@@ -45,8 +45,8 @@ namespace DB
 template <bool negative = false>
 struct EmptyImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res)
 	{
 		size_t size = offsets.size();
 		ColumnArray::Offset_t prev_offset = 1;
@@ -57,14 +57,14 @@ struct EmptyImpl
 		}
 	}
 
-	static void vector_fixed_to_constant(const PODArray<UInt8> & data, size_t n,
+	static void vector_fixed_to_constant(const std::vector<UInt8> & data, size_t n,
 		UInt8 & res)
 	{
 		res = negative ^ (n == 0);
 	}
 
-	static void vector_fixed_to_vector(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res)
+	static void vector_fixed_to_vector(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res)
 	{
 	}
 
@@ -73,7 +73,7 @@ struct EmptyImpl
 		res = negative ^ (data.empty());
 	}
 
-	static void array(const ColumnArray::Offsets_t & offsets, PODArray<UInt8> & res)
+	static void array(const ColumnArray::Offsets_t & offsets, std::vector<UInt8> & res)
 	{
 		size_t size = offsets.size();
 		ColumnArray::Offset_t prev_offset = 0;
@@ -95,8 +95,8 @@ struct EmptyImpl
   */
 struct LengthImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt64> & res)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt64> & res)
 	{
 		size_t size = offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -105,14 +105,14 @@ struct LengthImpl
 				: (offsets[i] - 1 - offsets[i - 1]);
 	}
 
-	static void vector_fixed_to_constant(const PODArray<UInt8> & data, size_t n,
+	static void vector_fixed_to_constant(const std::vector<UInt8> & data, size_t n,
 		UInt64 & res)
 	{
 		res = n;
 	}
 
-	static void vector_fixed_to_vector(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt64> & res)
+	static void vector_fixed_to_vector(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt64> & res)
 	{
 	}
 
@@ -121,7 +121,7 @@ struct LengthImpl
 		res = data.size();
 	}
 
-	static void array(const ColumnArray::Offsets_t & offsets, PODArray<UInt64> & res)
+	static void array(const ColumnArray::Offsets_t & offsets, std::vector<UInt64> & res)
 	{
 		size_t size = offsets.size();
 		for (size_t i = 0; i < size; ++i)
@@ -143,8 +143,8 @@ struct LengthImpl
   */
 struct LengthUTF8Impl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt64> & res)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt64> & res)
 	{
 		size_t size = offsets.size();
 
@@ -159,13 +159,13 @@ struct LengthUTF8Impl
 		}
 	}
 
-	static void vector_fixed_to_constant(const PODArray<UInt8> & data, size_t n,
+	static void vector_fixed_to_constant(const std::vector<UInt8> & data, size_t n,
 		UInt64 & res)
 	{
 	}
 
-	static void vector_fixed_to_vector(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt64> & res)
+	static void vector_fixed_to_vector(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt64> & res)
 	{
 		size_t size = data.size() / n;
 
@@ -186,7 +186,7 @@ struct LengthUTF8Impl
 				++res;
 	}
 
-	static void array(const ColumnArray::Offsets_t & offsets, PODArray<UInt64> & res)
+	static void array(const ColumnArray::Offsets_t & offsets, std::vector<UInt64> & res)
 	{
 		throw Exception("Cannot apply function lengthUTF8 to Array argument", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 	}
@@ -203,16 +203,16 @@ struct LengthUTF8Impl
 template <int F(int)>
 struct LowerUpperImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.resize(data.size());
-		res_offsets.assign(offsets);
+		res_offsets = offsets;
 		array(&*data.begin(), &*data.end(), &*res_data.begin());
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		res_data.resize(data.size());
 		array(&*data.begin(), &*data.end(), &*res_data.begin());
@@ -242,16 +242,16 @@ private:
 template <int F(int)>
 struct LowerUpperUTF8Impl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.resize(data.size());
-		res_offsets.assign(offsets);
+		res_offsets = offsets;
 		array(&*data.begin(), &*data.end(), &*res_data.begin());
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		res_data.resize(data.size());
 		array(&*data.begin(), &*data.end(), &*res_data.begin());
@@ -291,11 +291,11 @@ private:
   */
 struct ReverseImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.resize(data.size());
-		res_offsets.assign(offsets);
+		res_offsets = offsets;
 		size_t size = offsets.size();
 
 		ColumnArray::Offset_t prev_offset = 0;
@@ -308,8 +308,8 @@ struct ReverseImpl
 		}
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		res_data.resize(data.size());
 		size_t size = data.size() / n;
@@ -334,11 +334,11 @@ struct ReverseImpl
   */
 struct ReverseUTF8Impl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.resize(data.size());
-		res_offsets.assign(offsets);
+		res_offsets = offsets;
 		size_t size = offsets.size();
 
 		ColumnArray::Offset_t prev_offset = 0;
@@ -374,8 +374,8 @@ struct ReverseUTF8Impl
 		}
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		throw Exception("Cannot apply function reverseUTF8 to fixed string.", ErrorCodes::ILLEGAL_COLUMN);
 	}
@@ -417,9 +417,9 @@ struct ReverseUTF8Impl
 struct ConcatImpl
 {
 	static void vector_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = a_offsets.size();
 		c_data.resize(a_data.size() + b_data.size() - size);
@@ -443,9 +443,9 @@ struct ConcatImpl
 	}
 
 	static void vector_fixed_vector(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = a_offsets.size();
 		c_data.resize(a_data.size() + b_data.size());
@@ -471,13 +471,13 @@ struct ConcatImpl
 	}
 
 	static void vector_constant(
-		const PODArray<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
+		const std::vector<UInt8> & a_data, const ColumnArray::Offsets_t & a_offsets,
 		const std::string & b,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = a_offsets.size();
 		c_data.resize(a_data.size() + b.size() * size);
-		c_offsets.assign(a_offsets);
+		c_offsets = a_offsets;
 
 		for (size_t i = 0; i < size; ++i)
 			c_offsets[i] += b.size() * (i + 1);
@@ -496,9 +496,9 @@ struct ConcatImpl
 	}
 
 	static void fixed_vector_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = b_offsets.size();
 		c_data.resize(a_data.size() + b_data.size());
@@ -522,9 +522,9 @@ struct ConcatImpl
 	}
 
 	static void fixed_vector_fixed_vector(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c_data)
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c_data)
 	{
 		size_t size = a_data.size() / a_n;
 		c_data.resize(a_data.size() + b_data.size());
@@ -538,9 +538,9 @@ struct ConcatImpl
 	}
 
 	static void fixed_vector_constant(
-		const PODArray<UInt8> & a_data, ColumnArray::Offset_t a_n,
+		const std::vector<UInt8> & a_data, ColumnArray::Offset_t a_n,
 		const std::string & b,
-		PODArray<UInt8> & c_data)
+		std::vector<UInt8> & c_data)
 	{
 		size_t size = a_data.size() / a_n;
 		ColumnArray::Offset_t b_n = b.size();
@@ -556,12 +556,12 @@ struct ConcatImpl
 
 	static void constant_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
-		PODArray<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
+		const std::vector<UInt8> & b_data, const ColumnArray::Offsets_t & b_offsets,
+		std::vector<UInt8> & c_data, ColumnArray::Offsets_t & c_offsets)
 	{
 		size_t size = b_offsets.size();
 		c_data.resize(b_data.size() + a.size() * size);
-		c_offsets.assign(b_offsets);
+		c_offsets = b_offsets;
 
 		for (size_t i = 0; i < size; ++i)
 			c_offsets[i] += a.size() * (i + 1);
@@ -581,8 +581,8 @@ struct ConcatImpl
 
 	static void constant_fixed_vector(
 		const std::string & a,
-		const PODArray<UInt8> & b_data, ColumnArray::Offset_t b_n,
-		PODArray<UInt8> & c_data)
+		const std::vector<UInt8> & b_data, ColumnArray::Offset_t b_n,
+		std::vector<UInt8> & c_data)
 	{
 		size_t size = b_data.size() / b_n;
 		ColumnArray::Offset_t a_n = a.size();
@@ -610,9 +610,9 @@ struct ConcatImpl
   */
 struct SubstringImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
 		size_t start, size_t length,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.reserve(data.size());
 		size_t size = offsets.size();
@@ -641,9 +641,9 @@ struct SubstringImpl
 		}
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
 		size_t start, size_t length,
-		PODArray<UInt8> & res_data)
+		std::vector<UInt8> & res_data)
 	{
 		if (length == 0 || start + length > n + 1)
 			throw Exception("Index out of bound for function substring of fixed size value", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
@@ -672,9 +672,9 @@ struct SubstringImpl
   */
 struct SubstringUTF8Impl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
 		size_t start, size_t length,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.reserve(data.size());
 		size_t size = offsets.size();
@@ -729,9 +729,9 @@ struct SubstringUTF8Impl
 		}
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, ColumnArray::Offset_t n,
+	static void vector_fixed(const std::vector<UInt8> & data, ColumnArray::Offset_t n,
 		size_t start, size_t length,
-		PODArray<UInt8> & res_data)
+		std::vector<UInt8> & res_data)
 	{
 		throw Exception("Cannot apply function substringUTF8 to fixed string.", ErrorCodes::ILLEGAL_COLUMN);
 	}

dbms/include/DB/Functions/FunctionsStringSearch.h

@@ -41,9 +41,9 @@ struct PositionImpl
 	typedef UInt64 ResultType;
 
 	/// Предполагается, что res нужного размера и инициализирован нулями.
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
 		const std::string & needle,
-		PODArray<UInt64> & res)
+		std::vector<UInt64> & res)
 	{
 		const UInt8 * begin = &data[0];
 		const UInt8 * pos = begin;
@@ -83,9 +83,9 @@ struct PositionUTF8Impl
 {
 	typedef UInt64 ResultType;
 	
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
 		const std::string & needle,
-		PODArray<UInt64> & res)
+		std::vector<UInt64> & res)
 	{
 		const UInt8 * begin = &data[0];
 		const UInt8 * pos = begin;
@@ -260,9 +260,9 @@ struct MatchImpl
 {
 	typedef UInt8 ResultType;
 
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
 		const std::string & pattern,
-		PODArray<UInt8> & res)
+		std::vector<UInt8> & res)
 	{
 		String strstr_pattern;
 		/// Простой случай, когда выражение LIKE сводится к поиску подстроки в строке

dbms/include/DB/Functions/FunctionsURL.h

@@ -261,8 +261,8 @@ struct ExtractWWW
 template <typename Extractor>
 struct ExtractSubstringImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.reserve(data.size() * Extractor::getReserveLengthForElement());
 		size_t size = offsets.size();
@@ -298,8 +298,8 @@ struct ExtractSubstringImpl
 		res_data.assign(start, length);
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		throw Exception("Column of type FixedString is not supported by URL functions", ErrorCodes::ILLEGAL_COLUMN);
 	}
@@ -311,8 +311,8 @@ struct ExtractSubstringImpl
 template <typename Extractor>
 struct CutSubstringImpl
 {
-	static void vector(const PODArray<UInt8> & data, const ColumnArray::Offsets_t & offsets,
-		PODArray<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
+	static void vector(const std::vector<UInt8> & data, const ColumnArray::Offsets_t & offsets,
+		std::vector<UInt8> & res_data, ColumnArray::Offsets_t & res_offsets)
 	{
 		res_data.reserve(data.size());
 		size_t size = offsets.size();
@@ -350,8 +350,8 @@ struct CutSubstringImpl
 		res_data.erase(start - data.data(), length);
 	}
 
-	static void vector_fixed(const PODArray<UInt8> & data, size_t n,
-		PODArray<UInt8> & res_data)
+	static void vector_fixed(const std::vector<UInt8> & data, size_t n,
+		std::vector<UInt8> & res_data)
 	{
 		throw Exception("Column of type FixedString is not supported by URL functions", ErrorCodes::ILLEGAL_COLUMN);
 	}

dbms/include/DB/IO/WriteBufferFromVector.h

@@ -14,10 +14,11 @@ namespace DB
 /** Инициализируется вектором. Пишет данные в него. Когда вектор закончится - увеличивает его размер в два раза.
   * CharType - char или unsigned char.
   */
-template <typename CharType, typename VectorType = std::vector<CharType> >
+template <typename CharType>
 class WriteBufferFromVector : public WriteBuffer
 {
 private:
+	typedef std::vector<CharType> VectorType;
 	VectorType & vector;
 
 	void nextImpl()

dbms/src/Common/tests/pod_array.cpp

-#include <iostream>
-#include <iomanip>
-#include <vector>
-#include <cassert>
-
-#include <Poco/NumberFormatter.h>
-
-#include <DB/Core/Types.h>
-#include <DB/Common/PODArray.h>
-
-#include <statdaemons/Stopwatch.h>
-
-
-int main(int argc, char ** argv)
-{
-	try
-	{
-		typedef UInt16 Value;
-		typedef DB::PODArray<Value> Arr;
-
-		std::cerr << std::fixed << std::setprecision(3) << std::endl;
-
-		{
-			Arr arr;
-			assert(arr.size() == 0);
-
-			arr.push_back(1);
-			assert(arr.size() == 1);
-
-			arr.clear();
-			assert(arr.size() == 0);
-
-			arr.reserve(1000000);
-			assert(arr.capacity() >= 1000000);
-
-			arr.resize(10);
-			assert(arr.size() == 10);
-			assert(arr.capacity() >= 1000000);
-
-			arr.front() = 12;
-			arr.back() = 34;
-			arr[5] = 56;
-
-			Arr arr2(10);
-			arr2.front() = 12;
-			arr2.back() = 34;
-			arr2[5] = 56;
-
-			arr.insert(arr2.begin(), arr2.end());
-
-			assert(arr.size() == 20);
-			assert(arr.capacity() >= 1000000);
-			assert(arr[0] == 12);
-			assert(arr[9] == 34);
-			assert(arr[5] == 56);
-			assert(arr[10] == 12);
-			assert(arr[19] == 34);
-			assert(arr[15] == 56);
-
-			Arr().swap(arr);
-			assert(arr.size() == 0);
-			assert(arr.capacity() < 1000000);
-
-			arr.resize(4090);
-			arr.insert(arr2.begin(), arr2.end());
-			assert(arr.size() == 4100);
-			assert(arr.capacity() == 8192);
-			assert(arr[4090] == 12);
-			assert(arr[4099] == 34);
-			assert(arr[4095] == 56);
-		}
-
-		{
-			Arr arr(4096);
-			arr.push_back(123);
-			std::cerr << "size: " << arr.size() << ", capacity: " << arr.capacity() << std::endl;
-
-			for (Arr::const_iterator it = arr.begin(); it != arr.end(); ++it)
-				std::cerr << (it != arr.begin() ? ", " : "") << *it;
-			std::cerr << std::endl;
-		}
-
-		{
-			Arr arr;
-
-			for (size_t i = 0; i < 10000; ++i)
-				arr.push_back(i);
-			std::cerr << "size: " << arr.size() << ", capacity: " << arr.capacity() << std::endl;
-
-			for (Arr::const_iterator it = arr.begin(); it != arr.end(); ++it)
-				std::cerr << (it != arr.begin() ? ", " : "") << *it;
-			std::cerr << std::endl;
-		}
-
-		{
-			Arr arr;
-			arr.resize(10000);
-
-			for (size_t i = 0; i < 10000; ++i)
-				arr[i] = i;
-			std::cerr << "size: " << arr.size() << ", capacity: " << arr.capacity() << std::endl;
-
-			for (Arr::const_iterator it = arr.begin(); it != arr.end(); ++it)
-				std::cerr << (it != arr.begin() ? ", " : "") << *it;
-			std::cerr << std::endl;
-		}
-
-		{
-			Arr arr;
-			size_t n = 100000000;
-
-			Stopwatch watch;
-
-			for (size_t i = 0; i < n; ++i)
-				arr.push_back(i);
-
-			watch.stop();
-
-			std::cerr << "size: " << arr.size() << ", capacity: " << arr.capacity() << std::endl;
-
-			std::cerr << "PODArray: " << watch.elapsedSeconds() << " sec., "
-				<< n / watch.elapsedSeconds() << " elems/sec., "
-				<< n * sizeof(Value) / watch.elapsedSeconds() / 1000000 << " MB/sec."
-				<< std::endl;
-		}
-
-		{
-			std::vector<Value> arr;
-			size_t n = 100000000;
-
-			Stopwatch watch;
-
-			for (size_t i = 0; i < n; ++i)
-				arr.push_back(i);
-
-			watch.stop();
-
-			std::cerr << "size: " << arr.size() << ", capacity: " << arr.capacity() << std::endl;
-
-			std::cerr << "std::vector: " << watch.elapsedSeconds() << " sec., "
-				<< n / watch.elapsedSeconds() << " elems/sec., "
-				<< n * sizeof(Value) / watch.elapsedSeconds() / 1000000 << " MB/sec."
-				<< std::endl;
-		}
-	}
-	catch (const DB::Exception & e)
-	{
-		std::cerr << e.displayText() << std::endl;
-		return 1;
-	}
-
-	return 0;
-}

dbms/src/DataStreams/tests/aggregating_stream.cpp

@@ -60,7 +60,7 @@ int main(int argc, char ** argv)
 		column_x.type = new DB::DataTypeInt16;
 		DB::ColumnInt16 * x = new DB::ColumnInt16;
 		column_x.column = x;
-		DB::PODArray<Int16> & vec_x = x->getData();
+		std::vector<Int16> & vec_x = x->getData();
 
 		vec_x.resize(n);
 		for (size_t i = 0; i < n; ++i)

dbms/src/Interpreters/sortBlock.cpp

@@ -42,10 +42,9 @@ void sortBlock(Block & block, const SortDescription & description)
 	/// Если столбец сортировки один
 	if (description.size() == 1)
 	{
-		IColumn::Permutation perm;
-		(!description[0].column_name.empty()
+		IColumn::Permutation perm = (!description[0].column_name.empty()
 			? block.getByName(description[0].column_name).column
-			: block.getByPosition(description[0].column_number).column)->getPermutation(perm);
+			: block.getByPosition(description[0].column_number).column)->getPermutation();
 
 		if (description[0].direction == -1)
 			for (size_t i = 0, size = perm.size(); i < size / 2; ++i)

dbms/src/Interpreters/tests/aggregate.cpp

@@ -54,7 +54,7 @@ int main(int argc, char ** argv)
 		column_x.type = new DB::DataTypeInt16;
 		DB::ColumnInt16 * x = new DB::ColumnInt16;
 		column_x.column = x;
-		DB::PODArray<Int16> & vec_x = x->getData();
+		std::vector<Int16> & vec_x = x->getData();
 
 		vec_x.resize(n);
 		for (size_t i = 0; i < n; ++i)

dbms/src/Interpreters/tests/expression.cpp

@@ -124,7 +124,7 @@ int main(int argc, char ** argv)
 		column_x.type = new DB::DataTypeInt16;
 		DB::ColumnInt16 * x = new DB::ColumnInt16;
 		column_x.column = x;
-		DB::PODArray<Int16> & vec_x = x->getData();
+		std::vector<Int16> & vec_x = x->getData();
 
 		vec_x.resize(n);
 		for (size_t i = 0; i < n; ++i)