dbms: development.

dbms/include/DB/Common/VarInt.h

@@ -35,6 +35,15 @@ inline void readVarInt(Int64 & x, std::istream & istr)
 }
 
 
+template <typename T> inline void writeVarT(T x, std::ostream & ostr);
+template <> inline void writeVarT<UInt64>(UInt64 x, std::ostream & ostr) { writeVarUInt(x, ostr); }
+template <> inline void writeVarT<Int64>(Int64 x, std::ostream & ostr) { writeVarInt(x, ostr); }
+
+template <typename T> inline void readVarT(T & x, std::istream & istr);
+template <> inline void readVarT<UInt64>(UInt64 & x, std::istream & istr) { readVarUInt(x, istr); }
+template <> inline void readVarT<Int64>(Int64 & x, std::istream & istr) { readVarInt(x, istr); }
+
+
 }
 
 #endif

dbms/include/DB/DataTypes/DataTypesNumberVariable.h

@@ -0,0 +1,27 @@
+#ifndef DBMS_DATA_TYPES_NUMBER_VARIABLE_H
+#define DBMS_DATA_TYPES_NUMBER_VARIABLE_H
+
+#include <DB/Columns/ColumnsNumber.h>
+#include <DB/DataTypes/IDataTypeNumberVariable.h>
+
+
+namespace DB
+{
+
+/** Типы столбцов для чисел переменной ширины. */
+
+class DataTypeVarUInt : public IDataTypeNumberVariable<UInt64, ColumnUInt64>
+{
+public:
+	std::string getName() const { return "VarUInt"; }
+};
+
+class DataTypeVarInt : public IDataTypeNumberVariable<Int64, ColumnInt64>
+{
+public:
+	std::string getName() const { return "VarInt"; }
+};
+
+}
+
+#endif

dbms/include/DB/DataTypes/IDataTypeNumberVariable.h

@@ -0,0 +1,70 @@
+#ifndef DBMS_DATA_TYPES_IDATATYPE_NUMBER_VARIABLE_H
+#define DBMS_DATA_TYPES_IDATATYPE_NUMBER_VARIABLE_H
+
+#include <DB/Common/VarInt.h>
+#include <DB/Core/Exception.h>
+#include <DB/Core/ErrorCodes.h>
+
+#include <DB/DataTypes/IDataTypeNumber.h>
+
+
+namespace DB
+{
+
+
+/** Реализует часть интерфейса IDataType, общую для знаковых и беззнаковых чисел переменной длины
+  * - ввод и вывод в текстовом и бинарном виде.
+  * Остаётся лишь чисто виртуальный метод getName().
+  *
+  * Параметры: FieldType - тип единичного значения, ColumnType - тип столбца со значениями.
+  * (см. Core/Field.h, Columns/IColumn.h)
+  */
+template <typename FieldType, typename ColumnType>
+class IDataTypeNumberVariable : public IDataTypeNumber<FieldType>
+{
+public:
+	void serializeBinary(const Field & field, std::ostream & ostr) const
+	{
+		writeVarT<typename ColumnType::value_type>(boost::get<FieldType>(field), ostr);
+	}
+	
+	void deserializeBinary(Field & field, std::istream & istr) const
+	{
+		readVarT<typename ColumnType::value_type>(boost::get<FieldType>(field), istr);
+	}
+	
+	void serializeBinary(const IColumn & column, std::ostream & ostr) const
+	{
+		const typename ColumnType::Container_t & x = dynamic_cast<const ColumnType &>(column).getData();
+		size_t size = x.size();
+		for (size_t i = 0; i < size; ++i)
+			writeVarT<typename ColumnType::value_type>(x[i], ostr);
+	}
+	
+	void deserializeBinary(IColumn & column, std::istream & istr, size_t limit) const
+	{
+		typename ColumnType::Container_t & x =  dynamic_cast<ColumnType &>(column).getData();
+		x.resize(limit);
+		for (size_t i = 0; i < limit; ++i)
+		{
+			readVarT<typename ColumnType::value_type>(x[i], istr);
+
+			if (istr.eof())
+			{
+				x.resize(i);
+				break;
+			}
+			else if (!istr.good())
+				throw Exception("Cannot read data from istream", ErrorCodes::CANNOT_READ_DATA_FROM_ISTREAM);
+		}
+	}
+
+	SharedPtr<IColumn> createColumn() const
+	{
+		return new ColumnType;
+	}
+};
+
+}
+
+#endif

dbms/src/DataTypes/tests/data_types_number_fixed.cpp

@@ -21,7 +21,7 @@ int main(int argc, char ** argv)
 	for (size_t i = 0; i < n; ++i)
 		vec[i] = i;
 
-	std::ofstream ostr("/dev/null");
+	std::ofstream ostr("test");
 
 	stopwatch.restart();
 	data_type.serializeBinary(*column, ostr);

dbms/src/DataTypes/tests/data_types_number_variable.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <fstream>
+
+#include <Poco/Stopwatch.h>
+#include <Poco/SharedPtr.h>
+
+#include <DB/Columns/ColumnsNumber.h>
+#include <DB/DataTypes/DataTypesNumberVariable.h>
+
+
+int main(int argc, char ** argv)
+{
+	Poco::SharedPtr<DB::ColumnUInt64> column = new DB::ColumnUInt64();
+	DB::ColumnUInt64::Container_t & vec = column->getData();
+	DB::DataTypeVarUInt data_type;
+
+	Poco::Stopwatch stopwatch;
+	size_t n = 10000000;
+
+	vec.resize(n);
+	for (size_t i = 0; i < n; ++i)
+		vec[i] = i;
+
+	std::ofstream ostr("test");
+
+	stopwatch.restart();
+	data_type.serializeBinary(*column, ostr);
+	stopwatch.stop();
+
+	std::cout << "Elapsed: " << static_cast<double>(stopwatch.elapsed()) / 1000000 << std::endl;
+
+	return 0;
+}