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

Detect cmp_type() and result_type() from field_type()

Details

    Description

      Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

      We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

      The change will consists of the following parts:
      1. Changes in simple cases:

      • Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type(): 

         Item_result cmp_type() const { return type_handler()->cmp_type(); }

      • Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
      • Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
        The top level Item::field_type() will be pure virtual. 

         Item_result result_type() const { return type_handler()->result_type(); }

      • Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

      2. Changes in Item_sum_sum:

      • Remove Item_sum_sum::hybrid_type
      • Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
      • Remove Item::field_type_by_result_type(), as it's not needed any more.

      3. Changes in Item_splocal

      • Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
      • Derive Item_splocal from Type_handler_hybrid_field_type instead.

      4. Changes in Item_temporal_func

      • Remove Item_temporal_hybrid_func::cached_field_type
      • Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

      5. Changes in Item_param

      • Remove Item_param::param_type and Item_param::item_result_type
      • Derive Item_param from Type_handler_hybrid_field_type

      6. Changes in Item_type_holder

      • Remove Item_type_holder::fld_type
      • Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
      • Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
      • Derive Item_type_holder from Type_handler_hybrid_real_field_type

      7. Canges in Item_cache

      • Remove Item_cache::cached_field_type
      • Derive Item_cache from Type_handler_hybrid_field_type

      8. Changes in Item_copy

      • Remove Item_copy::cached_field_type and Item_copy::cached_result_type
      • Derive Item_copy from Type_handler_hybrid_field_type

      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
          relates to

          Task - A task that needs to be done. MDEV-12718 Determine Item::cmp_type() from Item::type_handler()

          • Major - Major loss of function.
          • 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 -
            Fix Version/s 10.2 [ 14601 ]
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().
            bar Alexander Barkov made changes -
            Issue Type Bug [ 1 ] Task [ 3 ]
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_num, and will be removed in a later step.
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_num, and will be removed in a later step.
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type and derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type and derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible real_type() values, as we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible real_type() values, as we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type

            7. Canges in Item_cache
            - Remove Item_cache::cached_field_type
            - Derive Item_cache from Type_handler_hybrid_field_type
            bar Alexander Barkov made changes -
            Description Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type

            7. Canges in Item_cache
            - Remove Item_cache::cached_field_type
            - Derive Item_cache from Type_handler_hybrid_field_type
            		 Currently many items define its result_type() and then calculate field_type() and cmp_type() from result_type().

            We'll change this to have items define its field_type(), while result_type() and cmp_type() will be calculated from field_type().

            The change will consists of the following parts:
            1. Changes in simple cases:
            - Remove the default implementation of Item::cmp_type() and change the simple items (with non-hybrid types) to calculate cmp_type() from field_type():
            {code}
             Item_result cmp_type() const { return type_handler()->cmp_type(); }
            {code}
            - Change the default implementation of Item::result_type() to detect the value by field_type(), instead of returning REAL_RESULT.
            - Remove the default implementation of Item::field_type() and Implement field_type() for all Items that currently do not have it.
              The top level Item::field_type() will be pure virtual.
            {code}
             Item_result result_type() const { return type_handler()->result_type(); }
            {code}
            - Rename the top-level Item::field_type() into a non-virtual Item::field_type_by_result_type(). It's still needed for Item_sum_sum, and will be removed in a later step.

            2. Changes in Item_sum_sum:
            - Remove Item_sum_sum::hybrid_type
            - Derive Item_sum_sum from Type_handler_hybrid_field_type instead.
            - Remove Item::field_type_by_result_type(), as it's not needed any more.

            3. Changes in Item_splocal
            - Remove Item_splocal::m_field_type and Item_splocale::m_result_type.
            - Derive Item_splocal from Type_handler_hybrid_field_type instead.

            4. Changes in Item_temporal_func
            - Remove Item_temporal_hybrid_func::cached_field_type
            - Derive Item_temporal_hybrid_func from Type_handler_hybrid_field_type

            5. Changes in Item_param
            - Remove Item_param::param_type and Item_param::item_result_type
            - Derive Item_param from Type_handler_hybrid_field_type

            6. Changes in Item_type_holder
            - Remove Item_type_holder::fld_type
            - Add type handlers for all missing possible Field::real_type() values. Note: we have had handlers for all field_type() values only so far.
            - Add Type_handler_hybrid_real_field_type, derived from Type_handler_hybrid_field_type
            - Derive Item_type_holder from Type_handler_hybrid_real_field_type

            7. Canges in Item_cache
            - Remove Item_cache::cached_field_type
            - Derive Item_cache from Type_handler_hybrid_field_type

            8. Changes in Item_copy
            - Remove Item_copy::cached_field_type and Item_copy::cached_result_type
            - Derive Item_copy from Type_handler_hybrid_field_type
            bar Alexander Barkov made changes -
            Labels refactoring
            serg Sergei Golubchik made changes -
            Fix Version/s 10.2 [ 14601 ]
            bar Alexander Barkov made changes -
            bar Alexander Barkov made changes -
            Component/s OTHER [ 10125 ]
            bar Alexander Barkov added a comment -

            All tasks mentioned here were solved by a number of other MDEV-4912 dependency tasks, e.g. MDEV-12718

            bar Alexander Barkov added a comment - All tasks mentioned here were solved by a number of other MDEV-4912 dependency tasks, e.g. MDEV-12718
            bar Alexander Barkov made changes -
            Fix Version/s 10.3.1 [ 22532 ]
            Resolution Fixed [ 1 ]
            Status Open [ 1 ] Closed [ 6 ]
            serg Sergei Golubchik made changes -
            Workflow MariaDB v3 [ 72814 ] MariaDB v4 [ 132741 ]

            People

              bar Alexander Barkov
              bar Alexander Barkov
              Votes:
              0 Vote for this issue
              Watchers:
              2 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.