MCOL-4412 Introduce TypeHandler::getEmptyValueForType to return const ptr for an empty value

WE changes for SQL DML and DDL operations

Changes for bulk operations

Changes for scanning operations

Cleanup

datatypes/mcs_datatype.cpp

@@ -1750,7 +1750,6 @@ TypeHandlerStr::getNullValueForTypeVarcharText(const SystemCatalog::TypeAttribut
   return value;
 }
 
-
 boost::any
 TypeHandlerBlob::getNullValueForType(const SystemCatalog::TypeAttributesStd &attr) const
 {
@@ -2083,6 +2082,215 @@ TypeHandlerUDecimal128::convertFromString(const SystemCatalog::TypeAttributesStd
 }
 
 
+/****************************************************************************/
+const uint8_t*
+getEmptyTypeHandlerSInt8()
+{
+  const static uint8_t TINYINTEMPTYROW = joblist::TINYINTEMPTYROW;
+  return &TINYINTEMPTYROW;
+}
+ 
+const uint8_t*
+TypeHandlerSInt8::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerSInt8();
+}
+
+const uint8_t*
+getEmptyTypeHandlerSInt16()
+{
+  const static uint16_t SMALLINTEMPTYROW = joblist::SMALLINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&SMALLINTEMPTYROW);
+}
+ 
+const uint8_t*
+TypeHandlerSInt16::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerSInt16();
+}
+
+const uint8_t*
+getEmptyTypeHandlerSInt32()
+{
+  const static uint32_t INTEMPTYROW = joblist::INTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&INTEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerSInt24::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerSInt32();
+}
+
+const uint8_t*
+TypeHandlerSInt32::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerSInt32();
+}
+
+const uint8_t*
+getEmptyTypeHandlerSInt64()
+{
+  const static uint64_t BIGINTEMPTYROW = joblist::BIGINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&BIGINTEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerSInt64::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerSInt64();
+}
+
+const uint8_t*
+TypeHandlerUInt8::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  const static uint8_t UTINYINTEMPTYROW = joblist::UTINYINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&UTINYINTEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerUInt16::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  const static uint16_t USMALLINTEMPTYROW = joblist::USMALLINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&USMALLINTEMPTYROW);
+}
+
+const uint8_t*
+getEmptyTypeHandlerUInt32()
+{
+  const static uint32_t UINTEMPTYROW = joblist::UINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&UINTEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerUInt24::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerUInt32();
+}
+
+const uint8_t*
+TypeHandlerUInt32::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerUInt32();
+}
+
+const uint8_t*
+TypeHandlerUInt64::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  const static uint64_t UBIGINTEMPTYROW = joblist::UBIGINTEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&UBIGINTEMPTYROW);
+}
+
+const uint8_t*
+getEmptyTypeHandlerFloat(const SystemCatalog::TypeAttributesStd &attr)
+{
+  const static uint32_t FLOATEMPTYROW = joblist::FLOATEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&FLOATEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerUFloat::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerFloat(attr);
+}
+
+const uint8_t*
+TypeHandlerSFloat::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerFloat(attr);
+}
+
+const uint8_t*
+getEmptyTypeHandlerDouble(const SystemCatalog::TypeAttributesStd &attr)
+{
+  const static uint64_t DOUBLEEMPTYROW = joblist::DOUBLEEMPTYROW;
+  return reinterpret_cast<const uint8_t*>(&DOUBLEEMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerUDouble::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerDouble(attr);
+}
+
+const uint8_t*
+TypeHandlerSDouble::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerDouble(attr);
+}
+
+// returns a ptr to an empty magic value for TypeHandlerStr types
+// args
+//  attr - width, precision and scale
+//  offset - offset value to reduce width for VARCHAR by 1
+const uint8_t*
+getEmptyTypeHandlerStr(const SystemCatalog::TypeAttributesStd &attr, int8_t offset)
+{
+  const static uint8_t  CHAR1EMPTYROW = joblist::CHAR1EMPTYROW;
+  const static uint16_t CHAR2EMPTYROW = joblist::CHAR2EMPTYROW;
+  const static uint32_t CHAR4EMPTYROW = joblist::CHAR4EMPTYROW;
+  const static uint64_t CHAR8EMPTYROW = joblist::CHAR8EMPTYROW;
+
+  if (attr.colWidth == (2 + offset))
+    return reinterpret_cast<const uint8_t*>(&CHAR2EMPTYROW);
+  else if (attr.colWidth >= (3 + offset) && attr.colWidth <= (4 + offset))
+    return reinterpret_cast<const uint8_t*>(&CHAR4EMPTYROW);
+  else if (attr.colWidth >= (5 + offset))
+    return reinterpret_cast<const uint8_t*>(&CHAR8EMPTYROW);
+
+  return reinterpret_cast<const uint8_t*>(&CHAR1EMPTYROW);
+}
+
+const uint8_t*
+TypeHandlerStr::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerStr(attr, 0);
+}
+
+const uint8_t*
+TypeHandlerVarchar::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyTypeHandlerStr(attr, -1);
+}
+
+inline const uint8_t*
+getEmptyValueForDecimal64(const SystemCatalog::TypeAttributesStd &attr)
+{
+  if (attr.colWidth <= 1)
+    return getEmptyTypeHandlerSInt8();
+  else if (attr.colWidth <= 2)
+    return getEmptyTypeHandlerSInt16();
+  else if (attr.colWidth <= 4)
+    return getEmptyTypeHandlerSInt32();
+  else
+    return getEmptyTypeHandlerSInt64();
+}
+
+const uint8_t*
+TypeHandlerSDecimal64::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyValueForDecimal64(attr);
+}
+
+const uint8_t*
+TypeHandlerUDecimal64::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return getEmptyValueForDecimal64(attr);
+}
+
+const uint8_t*
+TypeHandlerSDecimal128::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return reinterpret_cast<const uint8_t*>(&datatypes::Decimal128Empty);
+}
+
+const uint8_t*
+TypeHandlerUDecimal128::getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const
+{
+  return reinterpret_cast<const uint8_t*>(&datatypes::Decimal128Empty);
+}
+
+
 /****************************************************************************/
 
 } // end of namespace datatypes

datatypes/mcs_datatype.h

@@ -941,6 +941,9 @@ public:
                                        const ConvertFromStringParam& prm,
                                        const std::string& str,
                                        bool& pushWarning) const = 0;
+  virtual const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                   const = 0;
+
 };
 
 
@@ -1003,6 +1006,12 @@ class TypeHandlerBit: public TypeHandler
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    idbassert(0);
+    return nullptr;
+  }
+
 };
 
 
@@ -1074,6 +1083,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1130,6 +1140,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1188,6 +1199,7 @@ class TypeHandlerSInt24: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1246,6 +1258,7 @@ class TypeHandlerSInt32: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1301,6 +1314,7 @@ class TypeHandlerSInt64: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1383,6 +1397,7 @@ class TypeHandlerUInt8: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1464,6 +1479,7 @@ class TypeHandlerUInt16: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1548,6 +1564,7 @@ class TypeHandlerUInt24: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1632,6 +1649,7 @@ class TypeHandlerUInt32: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1713,6 +1731,7 @@ class TypeHandlerUInt64: public TypeHandlerInt
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1853,6 +1872,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -1933,6 +1953,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2015,6 +2036,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2093,6 +2115,7 @@ public:
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2152,6 +2175,7 @@ class TypeHandlerSFloat: public TypeHandlerReal
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2186,6 +2210,7 @@ class TypeHandlerSDouble: public TypeHandlerReal
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2220,6 +2245,7 @@ class TypeHandlerUFloat: public TypeHandlerReal
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2254,6 +2280,7 @@ class TypeHandlerUDouble: public TypeHandlerReal
                                const ConvertFromStringParam& prm,
                                const std::string& str,
                                bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
 };
 
 
@@ -2294,6 +2321,276 @@ class TypeHandlerSLongDouble: public TypeHandlerReal
     throw logging::QueryDataExcept("convertColumnData: unknown column data type.", logging::dataTypeErr);
     return boost::any();
   }
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    idbassert(0);
+    return nullptr;
+  }
+};
+
+const uint8_t* getEmptyTypeHandlerStr(const SystemCatalog::TypeAttributesStd &attr, int8_t offset);
+
+class TypeHandlerStr: public TypeHandler
+{
+protected:
+  std::string formatPartitionInfoSmallCharVarchar(
+                                  const SystemCatalog::TypeAttributesStd &attr,
+                                  const MinMaxInfo &i)
+                                  const;
+  boost::any getNullValueForTypeVarcharText(const SystemCatalog::TypeAttributesStd &attr)
+                                                                  const;
+public:
+  int storeValueToFieldCharVarchar(rowgroup::Row &row, int pos,
+                                   StoreField *f) const;
+  int storeValueToFieldBlobText(rowgroup::Row &row, int pos,
+                                StoreField *f) const;
+  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
+                                          const MinMaxInfo &i)
+                                          const override
+  {
+    // QQ: Check with Roman if this correct:
+    return formatPartitionInfoSInt64(attr, i);
+  }
+  execplan::SimpleColumn *newSimpleColumn(const DatabaseQualifiedColumnName &name,
+                                          SystemCatalog::TypeHolderStd &ct,
+                                          const SimpleColumnParam &prm)
+                                          const override;
+  SimpleValue toSimpleValue(const SessionParam &sp,
+                            const SystemCatalog::TypeAttributesStd &attr,
+                            const char *str, round_style_t & rf) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
+};
+
+
+class TypeHandlerChar: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::CHAR;
+  }
+  const string print(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    ostringstream oss;
+    oss << name () << "(" << attr.colWidth << ")";
+    return oss.str();
+  }
+  bool CP_type(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return attr.colWidth <= 8;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    return field->ColWriteBatchChar(buf, nullVal, writer);
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override
+  {
+    return storeValueToFieldCharVarchar(row, pos, f);
+  }
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override;
+  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
+                                  const MinMaxInfo &i)
+                                  const override;
+  MinMaxPartitionInfo getExtentPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
+                                             BRM::DBRM &em,
+                                             const BRM::EMEntry &entry,
+                                             int *state) const override;
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override;
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
+};
+
+
+class TypeHandlerVarchar: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::VARCHAR;
+  }
+  const string print(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    ostringstream oss;
+    oss << name () << "(" << attr.colWidth << ")";
+    return oss.str();
+  }
+  bool CP_type(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return attr.colWidth <= 7;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    return field->ColWriteBatchVarchar(buf, nullVal, writer);
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override
+  {
+    return storeValueToFieldCharVarchar(row, pos, f);
+  }
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override;
+  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
+                                  const MinMaxInfo &i)
+                                  const override;
+  MinMaxPartitionInfo getExtentPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
+                                             BRM::DBRM &em,
+                                             const BRM::EMEntry &entry,
+                                             int *state) const override;
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override
+  {
+    return getNullValueForTypeVarcharText(attr);
+  }
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override;
+};
+
+
+class TypeHandlerVarbinary: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::VARBINARY;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    return field->ColWriteBatchVarbinary(buf, nullVal, writer);
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override;
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override;
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override;
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
+};
+
+
+class TypeHandlerBlob: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::BLOB;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    return field->ColWriteBatchBlob(buf, nullVal, writer);
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override
+  {
+    return storeValueToFieldBlobText(row, pos, f);
+  }
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return "0"; // QQ
+  }
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override;
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
+};
+
+
+class TypeHandlerText: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::TEXT;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    return field->ColWriteBatchBlob(buf, nullVal, writer);
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override
+  {
+    return storeValueToFieldBlobText(row, pos, f);
+  }
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return "0"; // QQ
+  }
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override
+  {
+    return getNullValueForTypeVarcharText(attr);
+  }
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
+};
+
+
+class TypeHandlerClob: public TypeHandlerStr
+{
+  const string &name() const override;
+  code_t code() const override
+  {
+    return SystemCatalog::CLOB;
+  }
+  size_t ColWriteBatch(WriteBatchField *field,
+                       const unsigned char *buf,
+                       bool nullVal,
+                       ColBatchWriter & writer) const override
+  {
+    idbassert(0); // QQ
+    return 0;
+  }
+  int storeValueToField(rowgroup::Row &row, int pos,
+                        StoreField *f) const override
+  {
+    idbassert(0); // QQ
+    return 1;
+  }
+  std::string format(const SimpleValue &v,
+                     const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return "0"; // QQ
+  }
+  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
+                                                                const override
+  {
+    return boost::any(); // QQ
+  }
+  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
+                               const ConvertFromStringParam& prm,
+                               const std::string& str,
+                               bool& pushWarning) const override;
 };
 
 
@@ -2310,6 +2607,10 @@ public:
                                           SystemCatalog::TypeHolderStd &ct,
                                           const SimpleColumnParam &prm)
                                           const override;
+  const uint8_t* getEmptyValueForType(const SystemCatalog::TypeAttributesStd &attr) const override
+  {
+    return getEmptyTypeHandlerStr(attr, 0);
+  }
 };
 
 
@@ -2448,269 +2749,6 @@ class TypeHandlerTimestamp: public TypeHandlerTemporal
                                bool& pushWarning) const override;
 };
 
-
-class TypeHandlerStr: public TypeHandler
-{
-protected:
-  std::string formatPartitionInfoSmallCharVarchar(
-                                  const SystemCatalog::TypeAttributesStd &attr,
-                                  const MinMaxInfo &i)
-                                  const;
-  boost::any getNullValueForTypeVarcharText(const SystemCatalog::TypeAttributesStd &attr)
-                                                                  const;
-public:
-  int storeValueToFieldCharVarchar(rowgroup::Row &row, int pos,
-                                   StoreField *f) const;
-  int storeValueToFieldBlobText(rowgroup::Row &row, int pos,
-                                StoreField *f) const;
-  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
-                                          const MinMaxInfo &i)
-                                          const override
-  {
-    // QQ: Check with Roman if this correct:
-    return formatPartitionInfoSInt64(attr, i);
-  }
-  execplan::SimpleColumn *newSimpleColumn(const DatabaseQualifiedColumnName &name,
-                                          SystemCatalog::TypeHolderStd &ct,
-                                          const SimpleColumnParam &prm)
-                                          const override;
-  SimpleValue toSimpleValue(const SessionParam &sp,
-                            const SystemCatalog::TypeAttributesStd &attr,
-                            const char *str, round_style_t & rf) const override;
-};
-
-
-class TypeHandlerChar: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::CHAR;
-  }
-  const string print(const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    ostringstream oss;
-    oss << name () << "(" << attr.colWidth << ")";
-    return oss.str();
-  }
-  bool CP_type(const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    return attr.colWidth <= 8;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    return field->ColWriteBatchChar(buf, nullVal, writer);
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override
-  {
-    return storeValueToFieldCharVarchar(row, pos, f);
-  }
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override;
-  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
-                                  const MinMaxInfo &i)
-                                  const override;
-  MinMaxPartitionInfo getExtentPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
-                                             BRM::DBRM &em,
-                                             const BRM::EMEntry &entry,
-                                             int *state) const override;
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override;
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
-class TypeHandlerVarchar: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::VARCHAR;
-  }
-  const string print(const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    ostringstream oss;
-    oss << name () << "(" << attr.colWidth << ")";
-    return oss.str();
-  }
-  bool CP_type(const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    return attr.colWidth <= 7;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    return field->ColWriteBatchVarchar(buf, nullVal, writer);
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override
-  {
-    return storeValueToFieldCharVarchar(row, pos, f);
-  }
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override;
-  std::string formatPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
-                                  const MinMaxInfo &i)
-                                  const override;
-  MinMaxPartitionInfo getExtentPartitionInfo(const SystemCatalog::TypeAttributesStd &attr,
-                                             BRM::DBRM &em,
-                                             const BRM::EMEntry &entry,
-                                             int *state) const override;
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override
-  {
-    return getNullValueForTypeVarcharText(attr);
-  }
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
-class TypeHandlerVarbinary: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::VARBINARY;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    return field->ColWriteBatchVarbinary(buf, nullVal, writer);
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override;
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override;
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override;
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
-class TypeHandlerBlob: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::BLOB;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    return field->ColWriteBatchBlob(buf, nullVal, writer);
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override
-  {
-    return storeValueToFieldBlobText(row, pos, f);
-  }
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    return "0"; // QQ
-  }
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override;
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
-class TypeHandlerText: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::TEXT;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    return field->ColWriteBatchBlob(buf, nullVal, writer);
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override
-  {
-    return storeValueToFieldBlobText(row, pos, f);
-  }
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    return "0"; // QQ
-  }
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override
-  {
-    return getNullValueForTypeVarcharText(attr);
-  }
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
-class TypeHandlerClob: public TypeHandlerStr
-{
-  const string &name() const override;
-  code_t code() const override
-  {
-    return SystemCatalog::CLOB;
-  }
-  size_t ColWriteBatch(WriteBatchField *field,
-                       const unsigned char *buf,
-                       bool nullVal,
-                       ColBatchWriter & writer) const override
-  {
-    idbassert(0); // QQ
-    return 0;
-  }
-  int storeValueToField(rowgroup::Row &row, int pos,
-                        StoreField *f) const override
-  {
-    idbassert(0); // QQ
-    return 1;
-  }
-  std::string format(const SimpleValue &v,
-                     const SystemCatalog::TypeAttributesStd &attr) const override
-  {
-    return "0"; // QQ
-  }
-  boost::any getNullValueForType(const SystemCatalog::TypeAttributesStd &attr)
-                                                                const override
-  {
-    return boost::any(); // QQ
-  }
-  boost::any convertFromString(const SystemCatalog::TypeAttributesStd& colType,
-                               const ConvertFromStringParam& prm,
-                               const std::string& str,
-                               bool& pushWarning) const override;
-};
-
-
 }// end of namespace datatypes
 
 #endif //MCS_DATATYPE_H_INCLUDED