Bug#31355484: ABI compatibility complaint after WL#9384 change

Worklog # 9384 changed the value of MAX_CHAR_WIDTH from 255 to 255U.
While probably harmless, we'll change it back.

Patch also moves the new max blob size constant values from
mysql_com.h to class Field (sql/field.h).

The max size constants are also consolidated with those found
in sql/create_field.h.

Reviewed by: Guilhem Bichot <guilhem.bichot@oracle.com>

Change-Id: I5f0031174d4143995bec2493cd57ec84f7e81b4f

Author: roylyseng

include/mysql_com.h

@@ -846,18 +846,8 @@ struct Vio;
 #define MAX_INT_WIDTH 10      /**< Max width for a LONG w.o. sign */
 #define MAX_BIGINT_WIDTH 20   /**< Max width for a LONGLONG */
 /// Max width for a CHAR column, in number of characters
-#define MAX_CHAR_WIDTH 255U
-/// Max width for a VARCHAR column, in number of bytes
-#define MAX_VARCHAR_WIDTH 65535U
-/// Max width for a tiny blob, in bytes
-#define MAX_TINY_BLOB_WIDTH 255U
-/// Max width for a short blob (aka BLOB), in bytes
-#define MAX_SHORT_BLOB_WIDTH 65535U
-/// Max width for a medium blob, in bytes
-#define MAX_MEDIUM_BLOB_WIDTH 16777215U
-/// Max width for a long blob, in bytes
-#define MAX_LONG_BLOB_WIDTH 4294967295U
-/// Default width for blob  @todo - replace this with the specific types above?
+#define MAX_CHAR_WIDTH 255
+/// Default width for blob in bytes @todo - align this with sizes from field.h
 #define MAX_BLOB_WIDTH 16777216
 
 typedef struct NET {

sql/create_field.cc

@@ -32,12 +32,6 @@
 
 #include <cmath>
 
-// Definition of static constexpr data members in Create_field.
-constexpr size_t Create_field::TINYBLOB_MAX_SIZE_IN_BYTES;
-constexpr size_t Create_field::BLOB_MAX_SIZE_IN_BYTES;
-constexpr size_t Create_field::MEDIUMBLOB_MAX_SIZE_IN_BYTES;
-constexpr size_t Create_field::LONGBLOB_MAX_SIZE_IN_BYTES;
-
 /**
     Constructs a column definition from an object representing an actual
     column. This is a reverse-engineering procedure that creates a column
@@ -659,19 +653,19 @@ size_t Create_field::max_display_width_in_codepoints() const {
     return std::min(max_display_width_in_codepoints,
                     static_cast<size_t>(MAX_FIELD_WIDTH - 1));
   } else if (sql_type == MYSQL_TYPE_TINY_BLOB) {
-    return TINYBLOB_MAX_SIZE_IN_BYTES / charset->mbmaxlen;
+    return Field::MAX_TINY_BLOB_WIDTH / charset->mbmaxlen;
   } else if (sql_type == MYSQL_TYPE_BLOB && !explicit_display_width()) {
     // For BLOB and TEXT, the user can give a display width explicitly in CREATE
     // TABLE (BLOB(25), TEXT(25)) where the expected behavior is that the server
     // will find the smallest possible BLOB/TEXT type that will fit the given
     // display width. If the user has given an explicit display width, return
     // that instead of the max BLOB size.
-    return BLOB_MAX_SIZE_IN_BYTES / charset->mbmaxlen;
+    return Field::MAX_SHORT_BLOB_WIDTH / charset->mbmaxlen;
   } else if (sql_type == MYSQL_TYPE_MEDIUM_BLOB) {
-    return MEDIUMBLOB_MAX_SIZE_IN_BYTES / charset->mbmaxlen;
+    return Field::MAX_MEDIUM_BLOB_WIDTH / charset->mbmaxlen;
   } else if (sql_type == MYSQL_TYPE_LONG_BLOB || sql_type == MYSQL_TYPE_JSON ||
              sql_type == MYSQL_TYPE_GEOMETRY) {
-    return LONGBLOB_MAX_SIZE_IN_BYTES / charset->mbmaxlen;
+    return Field::MAX_LONG_BLOB_WIDTH / charset->mbmaxlen;
   } else {
     return m_max_display_width_in_codepoints;
   }
@@ -691,29 +685,29 @@ size_t Create_field::max_display_width_in_bytes() const {
     // Numeric types, temporal types, YEAR or BIT are never multi-byte.
     return max_display_width_in_codepoints();
   } else if (sql_type == MYSQL_TYPE_TINY_BLOB) {
-    return TINYBLOB_MAX_SIZE_IN_BYTES;
+    return Field::MAX_TINY_BLOB_WIDTH;
   } else if (sql_type == MYSQL_TYPE_BLOB && !explicit_display_width()) {
     // For BLOB and TEXT, the user can give a display width (BLOB(25), TEXT(25))
     // where the expected behavior is that the server will find the smallest
     // possible BLOB/TEXT type that will fit the given display width. If the
     // user has given an explicit display width, return that instead of the
     // max BLOB size.
-    return BLOB_MAX_SIZE_IN_BYTES;
+    return Field::MAX_SHORT_BLOB_WIDTH;
   } else if (sql_type == MYSQL_TYPE_MEDIUM_BLOB) {
-    return MEDIUMBLOB_MAX_SIZE_IN_BYTES;
+    return Field::MAX_MEDIUM_BLOB_WIDTH;
   } else if (sql_type == MYSQL_TYPE_LONG_BLOB || sql_type == MYSQL_TYPE_JSON ||
              sql_type == MYSQL_TYPE_GEOMETRY) {
-    return LONGBLOB_MAX_SIZE_IN_BYTES;
+    return Field::MAX_LONG_BLOB_WIDTH;
   } else {
     // If the user has given a display width to the TEXT type where the display
     // width is 2^32-1, the below computation will exceed
-    // LONGBLOB_MAX_SIZE_IN_BYTES if the character set is multi-byte. So we must
+    // MAX_LONG_BLOB_WIDTH if the character set is multi-byte. So we must
     // ensure that we never return a value greater than
-    // LONGBLOB_MAX_SIZE_IN_BYTES.
+    // MAX_LONG_BLOB_WIDTH.
     std::int64_t display_width = max_display_width_in_codepoints() *
                                  static_cast<std::int64_t>(charset->mbmaxlen);
     return static_cast<size_t>(std::min(
-        display_width, static_cast<std::int64_t>(LONGBLOB_MAX_SIZE_IN_BYTES)));
+        display_width, static_cast<std::int64_t>(Field::MAX_LONG_BLOB_WIDTH)));
   }
 }
 

sql/create_field.h

@@ -257,18 +257,6 @@ class Create_field {
 
   /// Whether or not the display width was given explicitly by the user.
   bool m_explicit_display_width{false};
-
-  /// The maximum number of bytes a TINYBLOB can hold.
-  static constexpr size_t TINYBLOB_MAX_SIZE_IN_BYTES{255};
-
-  /// The maximum number of bytes a BLOB can hold.
-  static constexpr size_t BLOB_MAX_SIZE_IN_BYTES{65535};
-
-  /// The maximum number of bytes a MEDIUMBLOB can hold.
-  static constexpr size_t MEDIUMBLOB_MAX_SIZE_IN_BYTES{16777215};
-
-  /// The maximum number of bytes a LONGBLOB can hold.
-  static constexpr size_t LONGBLOB_MAX_SIZE_IN_BYTES{4294967295};
 };
 
 /// @returns whether or not this field is a hidden column that represents a

sql/field.h

@@ -864,6 +864,15 @@ class Field {
   };
   enum imagetype { itRAW, itMBR };
 
+  // Max width for a VARCHAR column, in number of bytes
+  static constexpr size_t MAX_VARCHAR_WIDTH{65535};
+
+  // Maximum sizes of the four BLOB types, in number of bytes
+  static constexpr size_t MAX_TINY_BLOB_WIDTH{255};
+  static constexpr size_t MAX_SHORT_BLOB_WIDTH{65535};
+  static constexpr size_t MAX_MEDIUM_BLOB_WIDTH{16777215};
+  static constexpr size_t MAX_LONG_BLOB_WIDTH{4294967295};
+
   // Length of field. Never write to this member directly; instead, use
   // set_field_length().
   uint32 field_length;

sql/item.cc

@@ -3492,7 +3492,7 @@ bool Item_param::propagate_type(THD *, const Type_properties &type) {
     case MYSQL_TYPE_LONG_BLOB:
     case MYSQL_TYPE_BLOB:
       // Parameter type is BLOB of largest possible size
-      set_data_type_string(MAX_LONG_BLOB_WIDTH, type.m_collation);
+      set_data_type_string(Field::MAX_LONG_BLOB_WIDTH, type.m_collation);
       break;
     case MYSQL_TYPE_DATETIME:
     case MYSQL_TYPE_DATETIME2:

sql/item.h

@@ -1333,9 +1333,9 @@ class Item : public Parse_tree_node {
   inline void set_data_type_string(uint32 max_l) {
     max_length = max_l * collation.collation->mbmaxlen;
     decimals = DECIMAL_NOT_SPECIFIED;
-    if (max_length <= MAX_VARCHAR_WIDTH)
+    if (max_length <= Field::MAX_VARCHAR_WIDTH)
       set_data_type(MYSQL_TYPE_VARCHAR);
-    else if (max_length <= MAX_MEDIUM_BLOB_WIDTH)
+    else if (max_length <= Field::MAX_MEDIUM_BLOB_WIDTH)
       set_data_type(MYSQL_TYPE_MEDIUM_BLOB);
     else
       set_data_type(MYSQL_TYPE_LONG_BLOB);
@@ -1478,7 +1478,7 @@ class Item : public Parse_tree_node {
     set_data_type(MYSQL_TYPE_JSON);
     collation.set(&my_charset_utf8mb4_bin, DERIVATION_IMPLICIT);
     decimals = DECIMAL_NOT_SPECIFIED;
-    max_length = MAX_LONG_BLOB_WIDTH;
+    max_length = Field::MAX_LONG_BLOB_WIDTH;
   }
 
   /**
@@ -1549,9 +1549,9 @@ class Item : public Parse_tree_node {
     @param max_bytes Maximum string size, in number of bytes
   */
   static enum_field_types string_field_type(uint32 max_bytes) {
-    if (max_bytes > MAX_MEDIUM_BLOB_WIDTH)
+    if (max_bytes > Field::MAX_MEDIUM_BLOB_WIDTH)
       return MYSQL_TYPE_LONG_BLOB;
-    else if (max_bytes > MAX_VARCHAR_WIDTH)
+    else if (max_bytes > Field::MAX_VARCHAR_WIDTH)
       return MYSQL_TYPE_MEDIUM_BLOB;
     else
       return MYSQL_TYPE_VARCHAR;

sql/item_geofunc.h

@@ -349,7 +349,7 @@ class Item_func_as_wkb : public Item_geometry_func {
     if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_GEOMETRY)) return true;
     if (param_type_is_default(thd, 1, 2)) return true;
     if (Item_geometry_func::resolve_type(thd)) return true;
-    set_data_type_blob(MAX_LONG_BLOB_WIDTH);
+    set_data_type_blob(Field::MAX_LONG_BLOB_WIDTH);
     return false;
   }
 };