�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql%2F'>sql</a>/</p><hr><h3>✏️ Editing: opt_rewrite_date_cmp.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   Copyright (c) 2023, MariaDB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1335  USA */


/**
  @file

  @brief
    Rewrites that make non-sargable date[time] comparisons sargable.
*/

#include &quot;mariadb.h&quot;
#include &quot;sql_priv.h&quot;
#include &quot;my_json_writer.h&quot;
#include &quot;opt_rewrite_date_cmp.h&quot;

Date_cmp_func_rewriter::Date_cmp_func_rewriter(THD* thd,
                                               Item_func_eq *item_func) :
  thd(thd),
  result(item_func)
{
  if (!check_cond_match_and_prepare(item_func))
    return;

  /*
    This is an equality. Do a rewrite like this:
    &quot;YEAR(col) = val&quot;  -&gt;  col BETWEEN year_start(val) AND year_end(val)
    &quot;DATE(col) = val&quot;  -&gt;  col BETWEEN day_start(val) AND day_end(val)
  */
  Item *start_bound, *end_bound;
  if (!(start_bound= create_start_bound()) || !(end_bound= create_end_bound()))
    return;
  Item *new_cond;
  if (!(new_cond= new (thd-&gt;mem_root) Item_func_between(thd, field_ref,
                                                        start_bound, end_bound)))
    return;
  if (!new_cond-&gt;fix_fields(thd, &amp;new_cond))
    result= new_cond;
}


Date_cmp_func_rewriter::Date_cmp_func_rewriter(THD* thd,
                                               Item_func_ge *item_func) :
  thd(thd),
  result(item_func)
{
  if (!check_cond_match_and_prepare(item_func))
    return;
  rewrite_le_gt_lt_ge();
}


Date_cmp_func_rewriter::Date_cmp_func_rewriter(THD* thd,
                                               Item_func_lt *item_func) :
  thd(thd),
  result(item_func)
{
  if (!check_cond_match_and_prepare(item_func))
    return;
  rewrite_le_gt_lt_ge();
}


Date_cmp_func_rewriter::Date_cmp_func_rewriter(THD* thd,
                                               Item_func_gt *item_func) :
  thd(thd),
  result(item_func)
{
  if (!check_cond_match_and_prepare(item_func))
    return;
  rewrite_le_gt_lt_ge();
}


Date_cmp_func_rewriter::Date_cmp_func_rewriter(THD* thd,
                                               Item_func_le*item_func) :
  thd(thd),
  result(item_func)
{
  if (!check_cond_match_and_prepare(item_func))
    return;
  rewrite_le_gt_lt_ge();
}


bool Date_cmp_func_rewriter::check_cond_match_and_prepare(
    Item_bool_rowready_func2 *item_func)
{
  if (thd-&gt;lex-&gt;is_ps_or_view_context_analysis())
  {
    DBUG_ASSERT(0);
    return false;
  }

  Item **args= item_func-&gt;arguments();
  rewrite_func_type= item_func-&gt;functype();
  bool condition_matches= false;
  const Type_handler *comparison_type= item_func-&gt;get_comparator()-&gt;
                                       compare_type_handler();

  /*
    Check if this is &quot;YEAR(indexed_col) CMP const_item&quot; or
    &quot;DATE(indexed_col) CMP const_item&quot;
  */
  if ((field_ref= is_date_rounded_field(args[0], comparison_type,
                                        &amp;argument_func_type)) &amp;&amp;
      args[1]-&gt;basic_const_item())
  {
    const_arg_value= args[1];
    condition_matches= true;
  }
  else
  /*
    Check if this is &quot;const_item CMP YEAR(indexed_col)&quot; or
    &quot;const_item CMP DATE(indexed_col)&quot;
  */
  if ((field_ref= is_date_rounded_field(args[1], comparison_type,
                                        &amp;argument_func_type)) &amp;&amp;
      args[0]-&gt;basic_const_item())
  {
    /*
      Ok, the condition has form like &quot;const&lt;YEAR(col)&quot;/&quot;const&lt;DATE(col)&quot;.
      Turn it around to be &quot;YEAR(col)&gt;const&quot;/&quot;DATE(col)&gt;const&quot;
    */
    const_arg_value= args[0];

    rewrite_func_type= item_func-&gt;rev_functype();
    condition_matches= true;
  }
  return condition_matches;
}

/*
  Check if the passed item is YEAR(key_col) or DATE(key_col).

  Also
  - key_col must be covered by an index usable by the current query
  - key_col must have a DATE[TIME] or TIMESTAMP type
  - The value of the YEAR(..) or DATE(..) function must be compared using an a
    appropriate comparison_type.

  @param item             IN   Item to check
  @param comparison_type  IN   Which datatype is used to compare the item value
  @param out_func_type    OUT  Function (is it YEAR or DATE)

  @return
     key_col  if the check suceeded
     NULL     otherwise
*/
Item_field *Date_cmp_func_rewriter::is_date_rounded_field(Item* item,
                                  const Type_handler *comparison_type,
                                  Item_func::Functype *out_func_type) const
{
  if (item-&gt;type() != Item::FUNC_ITEM)
    return nullptr;

  Item_func::Functype func_type= ((Item_func*)item)-&gt;functype();
  bool function_ok= false;
  switch (func_type) {
  case Item_func::YEAR_FUNC:
    // The value of YEAR(x) must be compared as integer
    if (comparison_type == &amp;type_handler_slonglong)
      function_ok= true;
    break;
  case Item_func::DATE_FUNC:
    // The value of DATE(x) must be compared as dates.
    if (comparison_type == &amp;type_handler_newdate)
      function_ok= true;
    break;
  default:
    ;// do nothing
  }

  if (function_ok)
  {
    Item* arg= ((Item_func*)item)-&gt;arguments()[0];
    // Check if the argument is a column that&#039;s covered by some index
    if (arg-&gt;real_item()-&gt;type() == Item::FIELD_ITEM)
    {
      Item_field *item_field= (Item_field*)(arg-&gt;real_item());
      enum_field_types field_type= item_field-&gt;field_type();
      if ((field_type == MYSQL_TYPE_DATE ||
           field_type == MYSQL_TYPE_DATETIME ||
           field_type == MYSQL_TYPE_NEWDATE ||
           field_type == MYSQL_TYPE_TIMESTAMP) &amp;&amp;
          item_field-&gt;field-&gt;flags &amp; PART_KEY_FLAG)
      {
        *out_func_type= func_type;
        return item_field;
      }
    }
  }
  return nullptr;
}


void Date_cmp_func_rewriter::rewrite_le_gt_lt_ge()
{
  if (rewrite_func_type == Item_func::LE_FUNC ||
      rewrite_func_type == Item_func::GT_FUNC)
  {
    const_arg_value= create_end_bound();
  }
  else if (rewrite_func_type == Item_func::LT_FUNC ||
           rewrite_func_type == Item_func::GE_FUNC)
  {
    const_arg_value= create_start_bound();
  }
  if (!const_arg_value)
    return;
  Item *repl= create_cmp_func(rewrite_func_type, field_ref, const_arg_value);
  if (!repl)
    return;
  if (!repl-&gt;fix_fields(thd, &amp;repl))
    result= repl;
}


Item *Date_cmp_func_rewriter::create_bound(uint month, uint day,
                                           const TimeOfDay6 &amp;td) const
{
  /*
    We could always create Item_datetime with Item_datetime::decimals==6 here.
    But this would not be efficient in some cases.

    Let&#039;s create an Item_datetime with Item_datetime::decimals
    equal to field_ref-&gt;decimals, so if:

    (1) the original statement:

        SELECT ts3 FROM t1 WHERE DATE(ts3) &lt;= &#039;2024-01-23&#039;;

    gets rewritten to:

    (2) a statement with DATETIME comparison
        with an Item_datetime on the right side:

          SELECT ts3 FROM t1
          WHERE ts3 &lt;= &#039;2024-01-23 23:59.59.999&#039;; -- Item_datetime

    and then gets further rewritten with help of convert_item_for_comparison()
    to:

    (3) a statement with TIMESTAMP comparison
        with an Item_timestamp_literal on the right side

          SELECT ts3 FROM t1
          WHERE ts3 &lt;= &#039;2024-01-23 23:59:59.999&#039;; -- Item_timestamp_literal

    then we have an efficent statement calling
    Type_handler_timestamp_common::cmp_native() for comparison,
    which has a faster execution path when both sides have equal
    fractional precision.
  */
  switch (argument_func_type) {
  case Item_func::YEAR_FUNC:
  {
    longlong year= const_arg_value-&gt;val_int();
    const Datetime bound(static_cast&lt;unsigned int&gt;(year), month, day, td);
    if (!bound.is_valid_datetime())
      return nullptr; // &quot;year&quot; was out of the supported range
    return new (thd-&gt;mem_root) Item_datetime(thd, bound, field_ref-&gt;decimals);
  }
  case Item_func::DATE_FUNC:
    if (field_ref-&gt;field-&gt;type() == MYSQL_TYPE_DATE)
      return const_arg_value;
    else
    {
      const Datetime const_arg_dt(current_thd, const_arg_value);
      if (!const_arg_dt.is_valid_datetime())
        return nullptr; // SQL NULL datetime
      const Datetime bound(const_arg_dt.time_of_day(td));
      return new (thd-&gt;mem_root) Item_datetime(thd, bound, field_ref-&gt;decimals);
    }
  default:
    DBUG_ASSERT(0);
    break;
  }
  return nullptr;
}


/*
  Create an Item for &quot;arg1 $CMP arg2&quot;, where $CMP is specified by func_type.
*/
Item *Date_cmp_func_rewriter::create_cmp_func(Item_func::Functype func_type,
                                              Item *arg1, Item *arg2)
{
  Item *res;
  switch (func_type) {
    case Item_func::GE_FUNC:
      res= new (thd-&gt;mem_root) Item_func_ge(thd, arg1, arg2);
      break;
    case Item_func::GT_FUNC:
      res= new (thd-&gt;mem_root) Item_func_gt(thd, arg1, arg2);
      break;
    case Item_func::LE_FUNC:
      res= new (thd-&gt;mem_root) Item_func_le(thd, arg1, arg2);
      break;
    case Item_func::LT_FUNC:
      res= new (thd-&gt;mem_root) Item_func_lt(thd, arg1, arg2);
      break;
    default:
      DBUG_ASSERT(0);
      res= NULL;
  }
  return res;
}

void trace_date_item_rewrite(THD *thd, Item *new_item, Item *old_item)
{
  if (new_item != old_item)
  {
    Json_writer_object trace_wrapper(thd);
    trace_wrapper.add(&quot;transformation&quot;, &quot;date_conds_into_sargable&quot;)
                 .add(&quot;before&quot;, old_item)
                 .add(&quot;after&quot;, new_item);
  }
}

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql'>🔙 Back</a></p>