support bool type

src/DataTypes/DataTypeDomainBool.cpp

@@ -0,0 +1,21 @@
+#include <DataTypes/Serializations/SerializationBool.h>
+#include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeCustom.h>
+
+namespace DB
+{
+
+void registerDataTypeDomainBool(DataTypeFactory & factory)
+{
+    factory.registerSimpleDataTypeCustom("Bool", []
+    {
+        auto type = DataTypeFactory::instance().get("UInt8");
+        return std::make_pair(type, std::make_unique<DataTypeCustomDesc>(
+                std::make_unique<DataTypeCustomFixedName>("Bool"), std::make_unique<SerializationBool>(type->getDefaultSerialization())));
+    });
+
+    factory.registerAlias("bool", "Bool", DataTypeFactory::CaseInsensitive);
+    factory.registerAlias("boolean", "Bool", DataTypeFactory::CaseInsensitive);
+}
+
+}

src/DataTypes/DataTypeFactory.cpp

@@ -209,6 +209,7 @@ DataTypeFactory::DataTypeFactory()
     registerDataTypeInterval(*this);
     registerDataTypeLowCardinality(*this);
     registerDataTypeDomainIPv4AndIPv6(*this);
+    registerDataTypeDomainBool(*this);
     registerDataTypeDomainSimpleAggregateFunction(*this);
     registerDataTypeDomainGeo(*this);
     registerDataTypeMap(*this);

src/DataTypes/DataTypeFactory.h

@@ -85,6 +85,7 @@ void registerDataTypeNested(DataTypeFactory & factory);
 void registerDataTypeInterval(DataTypeFactory & factory);
 void registerDataTypeLowCardinality(DataTypeFactory & factory);
 void registerDataTypeDomainIPv4AndIPv6(DataTypeFactory & factory);
+void registerDataTypeDomainBool(DataTypeFactory & factory);
 void registerDataTypeDomainSimpleAggregateFunction(DataTypeFactory & factory);
 void registerDataTypeDomainGeo(DataTypeFactory & factory);
 

src/DataTypes/DataTypesNumber.cpp

@@ -57,8 +57,6 @@ void registerDataTypeNumbers(DataTypeFactory & factory)
     /// These synonyms are added for compatibility.
 
     factory.registerAlias("TINYINT", "Int8", DataTypeFactory::CaseInsensitive);
-    factory.registerAlias("BOOL", "Int8", DataTypeFactory::CaseInsensitive);
-    factory.registerAlias("BOOLEAN", "Int8", DataTypeFactory::CaseInsensitive);
     factory.registerAlias("INT1", "Int8", DataTypeFactory::CaseInsensitive);    /// MySQL
     factory.registerAlias("BYTE", "Int8", DataTypeFactory::CaseInsensitive);    /// MS Access
     factory.registerAlias("SMALLINT", "Int16", DataTypeFactory::CaseInsensitive);

src/DataTypes/Serializations/SerializationBool.cpp

@@ -0,0 +1,72 @@
+#include <DataTypes/Serializations/SerializationBool.h>
+
+#include <Columns/ColumnsNumber.h>
+#include <Common/Exception.h>
+#include <IO/WriteBuffer.h>
+#include <IO/ReadBuffer.h>
+#include <IO/ReadHelpers.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING;
+    extern const int ILLEGAL_COLUMN;
+}
+
+SerializationBool::SerializationBool(const SerializationPtr &nested_)
+        : SerializationCustomSimpleText(nested_)
+{
+}
+
+void SerializationBool::serializeText(const IColumn &column, size_t row_num, WriteBuffer &ostr, const FormatSettings &) const
+{
+    const auto *col = checkAndGetColumn<ColumnUInt8>(&column);
+    if (!col)
+        throw Exception("Bool type can only serialize columns of type UInt8." + column.getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
+
+    if (col->getData()[row_num])
+        ostr.write(str_true, sizeof(str_true) - 1);
+    else
+        ostr.write(str_false, sizeof(str_false) - 1);
+}
+
+void SerializationBool::deserializeText(IColumn &column, ReadBuffer &istr, const FormatSettings &) const
+{
+    ColumnUInt8 *col = typeid_cast<ColumnUInt8 *>(&column);
+    if (!col)
+    {
+        throw Exception("Bool type can only deserialize columns of type UInt32." + column.getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
+    }
+
+    if (!istr.eof())
+    {
+        bool value = false;
+
+        if (*istr.position() == 't' || *istr.position() == 'f')
+            readBoolTextWord(value, istr);
+        else if (*istr.position() == '1' || *istr.position() == '0')
+            readBoolText(value, istr);
+        else
+            throw Exception("Invalid boolean value, should be true, false, 1, or 0.",
+                            ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING);
+        col->insert(value);
+    }
+    else
+        throw Exception("Expected boolean value but get EOF.", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING);
+}
+
+void SerializationBool::serializeTextJSON(const IColumn &column, size_t row_num, WriteBuffer &ostr, const FormatSettings &settings) const
+{
+    serializeText(column, row_num, ostr, settings);
+}
+
+void SerializationBool::deserializeTextJSON(IColumn &column, ReadBuffer &istr, const FormatSettings &settings) const
+{
+    deserializeText(column, istr, settings);
+}
+
+}

src/DataTypes/Serializations/SerializationBool.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <DataTypes/Serializations/SerializationCustomSimpleText.h>
+
+namespace DB
+{
+
+class SerializationBool final : public SerializationCustomSimpleText
+{
+private:
+    static constexpr char str_true[5] = "true";
+    static constexpr char str_false[6] = "false";
+public:
+    SerializationBool(const SerializationPtr & nested_);
+
+    void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override;
+    void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const override;
+
+    void serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override;
+    void deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override;
+};
+
+}