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

Fix Item_cache constructors to accept Type_handler instead of enum_field_types

Details

    Description

      Item_cache and its descendants have this style constructors:

        Item_cache(THD *thd, enum_field_types field_type_arg):
      		 
          Item_basic_constant(thd),
      		 
          Type_handler_hybrid_field_type(field_type_arg),
      		 
          example(0), cached_field(0),
      		 
          value_cached(0)
      		 
        {
      		 
          fixed= 1;
      		 
          maybe_null= 1;
      		 
          null_value= 1;
      		 
        }

      Making a cache involves calls for field_type(), e.g.:

      new (thd->mem_root) Item_cache_int(thd, item->field_type());
      		 
      new (thd->mem_root) Item_cache_temporal(thd, item->field_type());

      This is not friendly to pluggable data types, which will return existing type codes in field_type().

      We'll change all Item_cache* constructors to accept a Type_handler pointer instead:

        Item_cache(THD *thd, const Type_handler *):
      		 
          Item_basic_constant(thd),
      		 
          Type_handler_hybrid_field_type(handler),
      		 
          example(0), cached_field(0),
      		 
          value_cached(0)
      		 
        {
      		 
          ...
      		 
        }

      And replace constructor calls to:

      new (thd->mem_root) Item_cache_int(thd, item->type_handler());
      		 
      new (thd->mem_root) Item_cache_temporal(thd, item->type_handler());

      Attachments

        Issue Links

          blocks

          Epic - Created by Jira Software - do not edit or delete. Issue type for a big user story that needs to be broken down. MDEV-4912 Data type plugin API version 1

          • Minor - Minor loss of function, or other problem where easy workaround is present.
          • Closed

          Activity

            Ascending order - Click to sort in descending order
            bar Alexander Barkov created issue -
            bar Alexander Barkov made changes -
            Field Original Value New Value
            bar Alexander Barkov made changes -
            Status Open [ 1 ] In Progress [ 3 ]
            bar Alexander Barkov made changes -
            Description {{Item_cache}} and its descendant has this constructor:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type())}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            		{{Item_cache}} and its descendants has this constructor:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type())}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            bar Alexander Barkov made changes -
            Description {{Item_cache}} and its descendants has this constructor:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type())}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            		{{Item_cache}} and its descendants have this style constructors:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type())}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            bar Alexander Barkov made changes -
            Description {{Item_cache}} and its descendants have this style constructors:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type())}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            		{{Item_cache}} and its descendants have this style constructors:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type()}}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            bar Alexander Barkov made changes -
            Description {{Item_cache}} and its descendants have this style constructors:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type()}}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}
            		{{Item_cache}} and its descendants have this style constructors:
            {code:cpp}
              Item_cache(THD *thd, enum_field_types field_type_arg):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(field_type_arg),
                example(0), cached_field(0),
                value_cached(0)
              {
                fixed= 1;
                maybe_null= 1;
                null_value= 1;
              }
            {code}

            Making a cache involves calls for {{field_type()}}, e.g.:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->field_type());
            new (thd->mem_root) Item_cache_temporal(thd, item->field_type());
            {code}

            This is not friendly to pluggable data types, which will return existing type codes in {{field_type()}}.

            We'll change all {{Item_cache*}} constructors to accept a {{Type_handler}} pointer instead:
            {code:cpp}
              Item_cache(THD *thd, const Type_handler *):
                Item_basic_constant(thd),
                Type_handler_hybrid_field_type(handler),
                example(0), cached_field(0),
                value_cached(0)
              {
                ...
              }
            {code}

            And replace constructor calls to:
            {code:cpp}
            new (thd->mem_root) Item_cache_int(thd, item->type_handler());
            new (thd->mem_root) Item_cache_temporal(thd, item->type_handler());
            {code}
            bar Alexander Barkov made changes -
            issue.field.resolutiondate 2017-05-06 09:34:54.0 2017-05-06 09:34:54.926
            bar Alexander Barkov made changes -
            Fix Version/s 10.3.1 [ 22532 ]
            Fix Version/s 10.3 [ 22126 ]
            Resolution Fixed [ 1 ]
            Status In Progress [ 3 ] Closed [ 6 ]
            serg Sergei Golubchik made changes -
            Workflow MariaDB v3 [ 80631 ] MariaDB v4 [ 133237 ]

            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.