More fixes to ItemView

Author: Enmk

clickhouse/columns/itemview.cpp

@@ -1,72 +1,96 @@
 #include "../columns/itemview.h"
 
+#include <algorithm>
+#include <sstream>
+
+namespace {
+
+template <typename Container>
+std::string ContainerToString(Container container, const char * separator = ", ") {
+    std::stringstream sstr;
+    const auto end = std::end(container);
+    for (auto i = std::begin(container); i != end; /*intentionally no ++i*/) {
+        const auto & elem = *i;
+        sstr << elem;
+
+        if (++i != end) {
+            sstr << separator;
+        }
+    }
+
+    return sstr.str();
+}
+
+}
+
 namespace clickhouse {
 
 void ItemView::ValidateData(Type::Code type, DataType data) {
-    int expected_size = 0;
+
+    auto AssertSize = [type, &data](std::initializer_list<int> allowed_sizes) -> void {
+        const auto end = std::end(allowed_sizes);
+        if (std::find(std::begin(allowed_sizes), end, static_cast<int>(data.size())) == end) {
+            throw AssertionError(std::string("ItemView value size mismatch for ")
+                    + Type::TypeName(type)
+                    + " expected: " + ContainerToString(allowed_sizes, " or ")
+                    + ", got: " + std::to_string(data.size()));
+        }
+    };
+
     switch (type) {
         case Type::Code::Void:
-            expected_size = 0;
-            break;
+            return AssertSize({0});
 
         case Type::Code::Int8:
         case Type::Code::UInt8:
         case Type::Code::Enum8:
-            expected_size = 1;
-            break;
+            return AssertSize({1});
 
         case Type::Code::Int16:
         case Type::Code::UInt16:
         case Type::Code::Date:
         case Type::Code::Enum16:
-            expected_size = 2;
-            break;
+            return AssertSize({2});
 
         case Type::Code::Int32:
         case Type::Code::UInt32:
         case Type::Code::Float32:
         case Type::Code::DateTime:
         case Type::Code::IPv4:
         case Type::Code::Decimal32:
-            expected_size = 4;
-            break;
+            return AssertSize({4});
 
         case Type::Code::Int64:
         case Type::Code::UInt64:
         case Type::Code::Float64:
         case Type::Code::DateTime64:
         case Type::Code::Decimal64:
-            expected_size = 8;
-            break;
+            return AssertSize({8});
 
         case Type::Code::String:
         case Type::Code::FixedString:
-        case Type::Code::Decimal:
             // value can be of any size
             return;
 
         case Type::Code::Array:
         case Type::Code::Nullable:
         case Type::Code::Tuple:
         case Type::Code::LowCardinality:
-            throw UnimplementedError("Unsupported type in ItemView: " + std::to_string(static_cast<int>(type)));
+            throw AssertionError("Unsupported type in ItemView: " + std::string(Type::TypeName(type)));
 
         case Type::Code::IPv6:
         case Type::Code::UUID:
         case Type::Code::Int128:
         case Type::Code::Decimal128:
-            expected_size = 16;
-            break;
+            return AssertSize({16});
+
+        case Type::Code::Decimal:
+            // Could be either Decimal32, Decimal64 or Decimal128
+            return AssertSize({4, 8, 16});
 
         default:
             throw UnimplementedError("Unknon type code:" + std::to_string(static_cast<int>(type)));
     }
-
-    if (expected_size != static_cast<int>(data.size())) {
-        throw AssertionError("Value size mismatch for type "
-                + std::to_string(static_cast<int>(type)) + " expected: "
-                + std::to_string(expected_size) + ", got: " + std::to_string(data.size()));
-    }
 }
 
 }

clickhouse/types/types.cpp

@@ -13,50 +13,69 @@ Type::Type(const Code code)
     , type_unique_id_(0)
 {}
 
+const char* Type::TypeName(Type::Code code) {
+    switch (code) {
+        case Type::Code::Void:           return "Void";
+        case Type::Code::Int8:           return "Int8";
+        case Type::Code::Int16:          return "Int16";
+        case Type::Code::Int32:          return "Int32";
+        case Type::Code::Int64:          return "Int64";
+        case Type::Code::UInt8:          return "UInt8";
+        case Type::Code::UInt16:         return "UInt16";
+        case Type::Code::UInt32:         return "UInt32";
+        case Type::Code::UInt64:         return "UInt64";
+        case Type::Code::Float32:        return "Float32";
+        case Type::Code::Float64:        return "Float64";
+        case Type::Code::String:         return "String";
+        case Type::Code::FixedString:    return "FixedString";
+        case Type::Code::DateTime:       return "DateTime";
+        case Type::Code::Date:           return "Date";
+        case Type::Code::Array:          return "Array";
+        case Type::Code::Nullable:       return "Nullable";
+        case Type::Code::Tuple:          return "Tuple";
+        case Type::Code::Enum8:          return "Enum8";
+        case Type::Code::Enum16:         return "Enum16";
+        case Type::Code::UUID:           return "UUID";
+        case Type::Code::IPv4:           return "IPv4";
+        case Type::Code::IPv6:           return "IPv6";
+        case Type::Code::Int128:         return "Int128";
+        case Type::Code::Decimal:        return "Decimal";
+        case Type::Code::Decimal32:      return "Decimal32";
+        case Type::Code::Decimal64:      return "Decimal64";
+        case Type::Code::Decimal128:     return "Decimal128";
+        case Type::Code::LowCardinality: return "LowCardinality";
+        case Type::Code::DateTime64:     return "DateTime64";
+    }
+
+    return "Unknown type";
+}
+
 std::string Type::GetName() const {
     switch (code_) {
         case Void:
-            return "Void";
         case Int8:
-            return "Int8";
         case Int16:
-            return "Int16";
         case Int32:
-            return "Int32";
         case Int64:
-            return "Int64";
         case Int128:
-            return "Int128";
         case UInt8:
-            return "UInt8";
         case UInt16:
-            return "UInt16";
         case UInt32:
-            return "UInt32";
         case UInt64:
-            return "UInt64";
         case UUID:
-            return "UUID";
         case Float32:
-            return "Float32";
         case Float64:
-            return "Float64";
         case String:
-            return "String";
-        case FixedString:
-            return As<FixedStringType>()->GetName();
         case IPv4:
-            return "IPv4";
         case IPv6:
-            return "IPv6";
+        case Date:
+            return TypeName(code_);
+        case FixedString:
+            return As<FixedStringType>()->GetName();
         case DateTime:
-        {
             return As<DateTimeType>()->GetName();
-        }
         case DateTime64:
             return As<DateTime64Type>()->GetName();
-        case Date:
-            return "Date";
         case Array:
             return As<ArrayType>()->GetName();
         case Nullable:

clickhouse/types/types.h

@@ -83,6 +83,9 @@ class Type {
 
     bool IsEqual(const TypeRef& other) const { return IsEqual(*other); }
 
+    /// Simple name, doesn't depend on parameters and\or nested types, caller MUST NOT free returned value.
+    static const char* TypeName(Code);
+
 public:
     static TypeRef CreateArray(TypeRef item_type);