Uploaded image for project: 'MariaDB Server'
  1. MariaDB Server
  2. MDEV-19710

Split the server side code in rpl_utility.cc into virtual methods in Type_handler

Details

    Description

      The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

      The client side code used by mysqlbinlog is out of scope of this task.

      The affected functions:

      • max_display_length_for_field()
      • show_sql_type()
      • can_convert_field_to()

      Instead of testing for field->real_type() inside these functions, we'll introduce the following new code:

      • New data types:

        enum enum_conv_type
        {
          CONV_TYPE_PRECISE,
          CONV_TYPE_VARIANT,
          CONV_TYPE_SUBSET_TO_SUPERSET,
          CONV_TYPE_SUPERSET_TO_SUBSET,
          CONV_TYPE_IMPOSSIBLE
        };
         
         
        class Conv_param
        {
          uint16 m_table_def_flags;
        public:
          Conv_param(uint16 table_def_flags)
           :m_table_def_flags(table_def_flags)
          { }
          uint16 table_def_flags() const { return m_table_def_flags; }
        };
         
         
        class Conv_source: public Type_handler_hybrid_field_type
        {
          enum_field_types m_type;
          uint16 m_metadata;
          CHARSET_INFO *m_cs;
        public:
          Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
           :Type_handler_hybrid_field_type(h),
            m_metadata(metadata),
            m_cs(cs)
          {
            DBUG_ASSERT(cs);
          }
          uint16 metadata() const { return m_metadata; }
          uint mbmaxlen() const { return m_cs->mbmaxlen; }
        };
        

      • A new virtual method in Field

        virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                  const Relay_log_info *rli,
                                                  const Conv_param &param)
                                                  const;
        

      • A new virtual method in Field

        enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                         const Relay_log_info *rli,
                                                         const Conv_param &param)
                                                         const;
        

      • A new method in Type_handler

        virtual void show_binlog_type(const Conv_source &src, String *str) const;
        

      • A new virtual method in Type_handler

        virtual uint32 max_display_length_for_field(const Conv_source &src) const;
        

      Let's also put the new code into a new file rpl_utility_server.cc, to split the server side code and the client side code.

      Attachments

        Issue Links

          Activity

            bar Alexander Barkov created issue -
            bar Alexander Barkov made changes -
            Field Original Value New Value
            bar Alexander Barkov made changes -
            Description The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:

            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field

            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}
            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:

            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field

            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            bar Alexander Barkov made changes -
            Description The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:

            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field

            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:

            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            bar Alexander Barkov made changes -
            Description The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:

            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:
            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            bar Alexander Barkov made changes -
            Description The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:
            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}
            The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:
            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}


            Let's also put the new code into rpl_utility_server.cc, to split the server side code and the client side code.
            bar Alexander Barkov made changes -
            Description The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:
            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}


            Let's also put the new code into rpl_utility_server.cc, to split the server side code and the client side code.
            The server side code in rpl_utility.cc is not friendly to pluggable data types, which will want to have their own rules on data type conversion during replication.

            bq. The client side code used by {{mysqlbinlog}} is out of scope of this task.

            The affected functions:

            - max_display_length_for_field()
            - show_sql_type()
            - can_convert_field_to()

            Instead of testing for {{field->real_type()}} inside these functions, we'll introduce the following new code:

            - New data types:
            {code:cpp}
            enum enum_conv_type
            {
              CONV_TYPE_PRECISE,
              CONV_TYPE_VARIANT,
              CONV_TYPE_SUBSET_TO_SUPERSET,
              CONV_TYPE_SUPERSET_TO_SUBSET,
              CONV_TYPE_IMPOSSIBLE
            };


            class Conv_param
            {
              uint16 m_table_def_flags;
            public:
              Conv_param(uint16 table_def_flags)
               :m_table_def_flags(table_def_flags)
              { }
              uint16 table_def_flags() const { return m_table_def_flags; }
            };


            class Conv_source: public Type_handler_hybrid_field_type
            {
              enum_field_types m_type;
              uint16 m_metadata;
              CHARSET_INFO *m_cs;
            public:
              Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
               :Type_handler_hybrid_field_type(h),
                m_metadata(metadata),
                m_cs(cs)
              {
                DBUG_ASSERT(cs);
              }
              uint16 metadata() const { return m_metadata; }
              uint mbmaxlen() const { return m_cs->mbmaxlen; }
            };
            {code}

            - A new virtual method in Field
            {code:sql}
            virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
                                                      const Relay_log_info *rli,
                                                      const Conv_param &param)
                                                      const;
            {code}

            - A new virtual method in Field
            {code:sql}
            enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
                                                             const Relay_log_info *rli,
                                                             const Conv_param &param)
                                                             const;
            {code}

            - A new method in Type_handler
            {code:sql}
            virtual void show_binlog_type(const Conv_source &src, String *str) const;
            {code}

            - A new virtual method in Type_handler
            {code:sql}
            virtual uint32 max_display_length_for_field(const Conv_source &src) const;
            {code}


            Let's also put the new code into a new file {{rpl_utility_server.cc}}, to split the server side code and the client side code.
            bar Alexander Barkov made changes -
            issue.field.resolutiondate 2019-06-07 09:05:43.0 2019-06-07 09:05:43.094
            bar Alexander Barkov made changes -
            Fix Version/s 10.5.0 [ 23709 ]
            Fix Version/s 10.5 [ 23123 ]
            Resolution Fixed [ 1 ]
            Status Open [ 1 ] Closed [ 6 ]
            alice Alice Sherepa made changes -
            serg Sergei Golubchik made changes -
            Workflow MariaDB v3 [ 97401 ] MariaDB v4 [ 133987 ]

            People

              bar Alexander Barkov
              bar Alexander Barkov
              Votes:
              0 Vote for this issue
              Watchers:
              1 Start watching this issue

              Dates

                Created:
                Updated:
                Resolved:

                Git Integration

                  Error rendering 'com.xiplink.jira.git.jira_git_plugin:git-issue-webpanel'. Please contact your Jira administrators.