feat: introduce representation of BLOB types.

include/takatori/type/blob.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <takatori/type/lob.h>

include/takatori/type/clob.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <takatori/type/lob.h>

include/takatori/type/dispatch.h

@@ -16,6 +16,7 @@
 #include "time_of_day.h"
 #include "time_point.h"
 #include "datetime_interval.h"
+#include "lob.h"
 // #include "array.h"
 // #include "record.h"
 // #include "row_reference.h"
@@ -58,6 +59,8 @@ inline auto dispatch(Callback&& callback, data const& object, Args&&... args) {
         case time_of_day::tag: return util::polymorphic_callback<time_of_day>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
         case time_point::tag: return util::polymorphic_callback<time_point>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
         case datetime_interval::tag: return util::polymorphic_callback<datetime_interval>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
+        case blob::tag: return util::polymorphic_callback<blob>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
+        case clob::tag: return util::polymorphic_callback<clob>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
 //        case array::tag: return util::polymorphic_callback<array>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
 //        case record::tag: return util::polymorphic_callback<record>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);
         case unknown::tag: return util::polymorphic_callback<unknown>(std::forward<Callback>(callback), object, std::forward<Args>(args)...);

include/takatori/type/lob.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "type_kind.h"
+#include "simple_type.h"
+
+#include <takatori/util/meta_type.h>
+
+namespace takatori::type {
+
+/**
+ * @brief binary large object type.
+ */
+using blob = simple_type<type_kind::blob>;
+
+/**
+ * @brief character large object type.
+ */
+using clob = simple_type<type_kind::clob>;
+
+/**
+ * @brief type_of for blob.
+ */
+template<> struct type_of<blob::tag> : util::meta_type<blob> {};
+
+/**
+ * @brief type_of for clob.
+ */
+template<> struct type_of<clob::tag> : util::meta_type<clob> {};
+
+} // namespace takatori::type

include/takatori/type/type_kind.h

@@ -48,6 +48,12 @@ enum class type_kind {
     /// @brief date-time interval type.
     datetime_interval,
 
+    // large objects
+    /// @brief binary large object type.
+    blob,
+    /// @brief character large object type.
+    clob,
+
     // complex types
 
     /// @brief array type.
@@ -116,6 +122,8 @@ constexpr inline std::string_view to_string_view(type_kind value) noexcept {
         case kind::time_of_day: return "time_of_day"sv;
         case kind::time_point: return "time_point"sv;
         case kind::datetime_interval: return "datetime_interval"sv;
+        case kind::blob: return "blob"sv;
+        case kind::clob: return "clob"sv;
         case kind::array: return "array"sv;
         case kind::record: return "record"sv;
         case kind::unknown: return "unknown"sv;

src/takatori/serializer/details/type_property_scanner.cpp

@@ -6,9 +6,11 @@ namespace takatori::serializer::details {
 
 using namespace std::string_view_literals;
 
-type_property_scanner::type_property_scanner(object_scanner const& scanner, object_acceptor& acceptor) noexcept
-    : scanner_(scanner)
-    , acceptor_(acceptor)
+type_property_scanner::type_property_scanner(
+        object_scanner const& scanner,
+        object_acceptor& acceptor) noexcept :
+    scanner_ { scanner },
+    acceptor_ { acceptor }
 {}
 
 void type_property_scanner::operator()(type::boolean const&) {}
@@ -91,6 +93,10 @@ void type_property_scanner::operator()(type::time_point const& element) {
 
 void type_property_scanner::operator()(type::datetime_interval const&) {}
 
+void type_property_scanner::operator()(type::blob const&) {}
+
+void type_property_scanner::operator()(type::clob const&) {}
+
 void type_property_scanner::operator()(type::unknown const&) {}
 
 void type_property_scanner::operator()(type::row_id const& element) {

src/takatori/serializer/details/type_property_scanner.h

@@ -9,6 +9,7 @@
 #include <takatori/type/time_of_day.h>
 #include <takatori/type/time_point.h>
 #include <takatori/type/datetime_interval.h>
+#include <takatori/type/lob.h>
 #include <takatori/type/row_id.h>
 #include <takatori/type/declared.h>
 #include <takatori/type/extension.h>
@@ -37,6 +38,8 @@ class type_property_scanner {
     void operator()(type::time_of_day const& element);
     void operator()(type::time_point const& element);
     void operator()(type::datetime_interval const& element);
+    void operator()(type::blob const& element);
+    void operator()(type::clob const& element);
     void operator()(type::unknown const& element);
     void operator()(type::row_id const& element);
     void operator()(type::declared const& element);

test/takatori/serializer/object_scanner_test.cpp

@@ -25,6 +25,7 @@
 #include <takatori/type/time_of_day.h>
 #include <takatori/type/time_point.h>
 #include <takatori/type/datetime_interval.h>
+#include <takatori/type/lob.h>
 #include <takatori/type/row_id.h>
 #include <takatori/type/declared.h>
 #include <takatori/type/extension.h>
@@ -288,6 +289,14 @@ TEST_F(object_scanner_test, type_datetime_interval) {
     print(type::datetime_interval {});
 }
 
+TEST_F(object_scanner_test, type_blob) {
+    print(type::blob {});
+}
+
+TEST_F(object_scanner_test, type_clob) {
+    print(type::clob {});
+}
+
 TEST_F(object_scanner_test, type_unknown) {
     print(type::unknown {});
 }