Skip navigation links

 Systems for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Downloads
• Documentation
• Articles
• Forums
• Bugs
• Forge
• Blogs

 

---

Learn about new MySQL releases, technical articles, events and more.

Subscribe Now »

mysql/src/5.1-dbg/sql/opt_sum.cc File Reference

#include "mysql_priv.h"
#include "sql_select.h"

Include dependency graph for opt_sum.cc:

Go to the source code of this file.

Functions
static bool	find_key_for_maxmin (bool max_fl, TABLE_REF *ref, Field *field, COND *cond, uint *range_fl, uint *key_prefix_length)
static int	reckey_in_range (bool max_fl, TABLE_REF *ref, Field *field, COND *cond, uint range_fl, uint prefix_len)
static int	maxmin_in_range (bool max_fl, Field *field, COND *cond)
static ulonglong	get_exact_record_count (TABLE_LIST *tables)
int	opt_sum_query (TABLE_LIST *tables, List< Item > &all_fields, COND *conds)
bool	simple_pred (Item_func *func_item, Item **args, bool *inv_order)
static bool	matching_cond (bool max_fl, TABLE_REF *ref, KEY *keyinfo, KEY_PART_INFO *field_part, COND *cond, key_part_map *key_part_used, uint *range_fl, uint *prefix_len)

---

Function Documentation

static bool find_key_for_maxmin	(	bool	max_fl,
		TABLE_REF *	ref,
		Field *	field,
		COND *	cond,
		uint *	range_fl,
		uint *	key_prefix_length
	)			[static]

Definition at line 730 of file opt_sum.cc.

References BLOB_FLAG, cond, Field::eq(), handler::extra(), st_key_part_info::field, st_table::field, st_key_part_info::fieldnr, st_table::file, Field::flags, HA_EXTRA_KEYREAD, HA_READ_ORDER, handler::index_flags(), Bitmap< 64 >::is_set(), st_table_ref::key, st_table_ref::key_buff, st_table::key_info, st_table_ref::key_length, Field::key_length(), st_table::key_read, keyinfo, st_table_share::keys, st_table::keys_in_use_for_query, st_key_part_info::length, matching_cond(), NEAR_MIN, NO_MAX_RANGE, NO_MIN_RANGE, st_key_part_info::null_bit, PART_KEY_FLAG, Field::part_of_key, st_table::s, st_key_part_info::store_length, and Field::table.

Referenced by opt_sum_query().

{
  if (!(field->flags & PART_KEY_FLAG))
    return 0;                                        // Not key field

  TABLE *table= field->table;
  uint idx= 0;

  KEY *keyinfo,*keyinfo_end;
  for (keyinfo= table->key_info, keyinfo_end= keyinfo+table->s->keys ;
       keyinfo != keyinfo_end;
       keyinfo++,idx++)
  {
    KEY_PART_INFO *part,*part_end;
    key_part_map key_part_to_use= 0;
    /*
      Perform a check if index is not disabled by ALTER TABLE
      or IGNORE INDEX.
    */
    if (!table->keys_in_use_for_query.is_set(idx))
      continue;
    uint jdx= 0;
    *prefix_len= 0;
    for (part= keyinfo->key_part, part_end= part+keyinfo->key_parts ;
         part != part_end ;
         part++, jdx++, key_part_to_use= (key_part_to_use << 1) | 1)
    {
      if (!(table->file->index_flags(idx, jdx, 0) & HA_READ_ORDER))
        return 0;

      /* Check whether the index component is partial */
      Field *part_field= table->field[part->fieldnr-1];
      if ((part_field->flags & BLOB_FLAG) ||
          part->length < part_field->key_length())
        break;

      if (field->eq(part->field))
      {
        ref->key= idx;
        ref->key_length= 0;
        key_part_map key_part_used= 0;
        *range_fl= NO_MIN_RANGE | NO_MAX_RANGE;
        if (matching_cond(max_fl, ref, keyinfo, part, cond,
                          &key_part_used, range_fl, prefix_len) &&
            !(key_part_to_use & ~key_part_used))
        {
          if (!max_fl && key_part_used == key_part_to_use && part->null_bit)
          {
            /*
              SELECT MIN(key_part2) FROM t1 WHERE key_part1=const
              If key_part2 may be NULL, then we want to find the first row
              that is not null
            */
            ref->key_buff[ref->key_length]= 1;
            ref->key_length+= part->store_length;
            *range_fl&= ~NO_MIN_RANGE;
            *range_fl|= NEAR_MIN;                // > NULL
          }
          /*
            The following test is false when the key in the key tree is
            converted (for example to upper case)
          */
          if (field->part_of_key.is_set(idx))
          {
            table->key_read= 1;
            table->file->extra(HA_EXTRA_KEYREAD);
          }
          return 1;
        }
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulonglong get_exact_record_count

(

TABLE_LIST *

tables

)

[static]

Definition at line 73 of file opt_sum.cc.

References count, HA_POS_ERROR, st_table_list::next_leaf, and ULONGLONG_MAX.

Referenced by opt_sum_query().

{
  ulonglong count= 1;
  for (TABLE_LIST *tl= tables; tl; tl= tl->next_leaf)
  {
    ha_rows tmp= tl->table->file->records();
    if ((tmp == HA_POS_ERROR))
      return ULONGLONG_MAX;
    count*= tmp;
  }
  return count;
}

Here is the caller graph for this function:

static bool matching_cond	(	bool	max_fl,
		TABLE_REF *	ref,
		KEY *	keyinfo,
		KEY_PART_INFO *	field_part,
		COND *	cond,
		key_part_map *	key_part_used,
		uint *	range_fl,
		uint *	prefix_len
	)			[static]

Definition at line 526 of file opt_sum.cc.

References args, Item_func::BETWEEN, CHECK_FIELD_IGNORE, cond, Item::COND_ITEM, Item_func::COND_OR_FUNC, Field::eq(), Item_func::EQ_FUNC, Item_func::EQUAL_FUNC, st_key_part_info::field, Item::FUNC_ITEM, Item_func::GE_FUNC, Field::get_key_image(), Item_func::GT_FUNC, Field::is_null(), Item_func::ISNULL_FUNC, Field::itRAW, st_table_ref::key_buff, st_table_ref::key_length, keyinfo, Item_func::LE_FUNC, st_key_part_info::length, Item_func::LT_FUNC, st_table::map, Item_func::MULT_EQUAL_FUNC, NEAR_MAX, NEAR_MIN, NO_MAX_RANGE, NO_MIN_RANGE, st_key_part_info::null_bit, Field::set_null(), simple_pred(), st_key_part_info::store_length, store_val_in_field(), Field::table, and test.

Referenced by find_key_for_maxmin().

{
  if (!cond)
    return 1;
  Field *field= field_part->field;
  if (!(cond->used_tables() & field->table->map))
  {
    /* Condition doesn't restrict the used table */
    return 1;
  }
  if (cond->type() == Item::COND_ITEM)
  {
    if (((Item_cond*) cond)->functype() == Item_func::COND_OR_FUNC)
      return 0;

    /* AND */
    List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
    Item *item;
    while ((item= li++))
    {
      if (!matching_cond(max_fl, ref, keyinfo, field_part, item,
                         key_part_used, range_fl, prefix_len))
        return 0;
    }
    return 1;
  }

  if (cond->type() != Item::FUNC_ITEM)
    return 0;                                 // Not operator, can't optimize

  bool eq_type= 0;                            // =, <=> or IS NULL
  bool noeq_type= 0;                          // < or >  
  bool less_fl= 0;                            // < or <= 
  bool is_null= 0;
  bool between= 0;

  switch (((Item_func*) cond)->functype()) {
  case Item_func::ISNULL_FUNC:
    is_null= 1;     /* fall through */
  case Item_func::EQ_FUNC:
  case Item_func::EQUAL_FUNC:
    eq_type= 1;
    break;
  case Item_func::LT_FUNC:
    noeq_type= 1;   /* fall through */
  case Item_func::LE_FUNC:
    less_fl= 1;      
    break;
  case Item_func::GT_FUNC:
    noeq_type= 1;   /* fall through */
  case Item_func::GE_FUNC:
    break;
  case Item_func::BETWEEN:
    between= 1;
    break;
  case Item_func::MULT_EQUAL_FUNC:
    eq_type= 1;
    break;
  default:
    return 0;                                        // Can't optimize function
  }
  
  Item *args[3];
  bool inv;

  /* Test if this is a comparison of a field and constant */
  if (!simple_pred((Item_func*) cond, args, &inv))
    return 0;

  if (inv && !eq_type)
    less_fl= 1-less_fl;                         // Convert '<' -> '>' (etc)

  /* Check if field is part of the tested partial key */
  byte *key_ptr= ref->key_buff;
  KEY_PART_INFO *part;
  for (part= keyinfo->key_part;
       ;
       key_ptr+= part++->store_length)

  {
    if (part > field_part)
      return 0;                     // Field is beyond the tested parts
    if (part->field->eq(((Item_field*) args[0])->field))
      break;                        // Found a part od the key for the field
  }

  bool is_field_part= part == field_part;
  if (!(is_field_part || eq_type))
    return 0;

  key_part_map org_key_part_used= *key_part_used;
  if (eq_type || between || max_fl == less_fl)
  {
    uint length= (key_ptr-ref->key_buff)+part->store_length;
    if (ref->key_length < length)
    /* Ultimately ref->key_length will contain the length of the search key */
      ref->key_length= length;      
    if (!*prefix_len && part+1 == field_part)       
      *prefix_len= length;
    if (is_field_part && eq_type)
      *prefix_len= ref->key_length;
  
    *key_part_used|= (key_part_map) 1 << (part - keyinfo->key_part);
  }

  if (org_key_part_used != *key_part_used ||
      (is_field_part && 
       (between || eq_type || max_fl == less_fl) && !cond->val_int()))
  {
    /*
      It's the first predicate for this part or a predicate of the
      following form  that moves upper/lower bounds for max/min values:
      - field BETWEEN const AND const
      - field = const 
      - field {<|<=} const, when searching for MAX
      - field {>|>=} const, when searching for MIN
    */

    if (is_null)
    {
      part->field->set_null();
      *key_ptr= (byte) 1;
    }
    else
    {
      store_val_in_field(part->field, args[between && max_fl ? 2 : 1],
                         CHECK_FIELD_IGNORE);
      if (part->null_bit) 
        *key_ptr++= (byte) test(part->field->is_null());
      part->field->get_key_image((char*) key_ptr, part->length, Field::itRAW);
    }
    if (is_field_part)
    {
      if (between || eq_type)
        *range_fl&= ~(NO_MAX_RANGE | NO_MIN_RANGE);
      else
      {
        *range_fl&= ~(max_fl ? NO_MAX_RANGE : NO_MIN_RANGE);
        if (noeq_type)
          *range_fl|=  (max_fl ? NEAR_MAX : NEAR_MIN);
        else
          *range_fl&= ~(max_fl ? NEAR_MAX : NEAR_MIN);
      }
    }
  }
  else if (eq_type)
  {
    if (!is_null && !cond->val_int() ||
        is_null && !test(part->field->is_null()))  
     return 0;                       // Impossible test
  }
  else if (is_field_part)
    *range_fl&= ~(max_fl ? NO_MIN_RANGE : NO_MAX_RANGE);
  return 1;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int maxmin_in_range	(	bool	max_fl,
		Field *	field,
		COND *	cond
	)			[static]

Definition at line 849 of file opt_sum.cc.

References Item_func::BETWEEN, cond, Item::COND_ITEM, Item::const_item(), DBUG_ASSERT, Item_func::EQ_FUNC, Item_func::EQUAL_FUNC, Item_func::GE_FUNC, Item_func::GT_FUNC, Item_func::LE_FUNC, Item_func::LT_FUNC, st_table::map, and Field::table.

Referenced by reckey_in_range().

{
  /* If AND/OR condition */
  if (cond->type() == Item::COND_ITEM)
  {
    List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
    Item *item;
    while ((item= li++))
    {
      if (maxmin_in_range(max_fl, field, item))
        return 1;
    }
    return 0;
  }

  if (cond->used_tables() != field->table->map)
    return 0;
  bool less_fl= 0;
  switch (((Item_func*) cond)->functype()) {
  case Item_func::BETWEEN:
    return cond->val_int() == 0;                // Return 1 if WHERE is false
  case Item_func::LT_FUNC:
  case Item_func::LE_FUNC:
    less_fl= 1;
  case Item_func::GT_FUNC:
  case Item_func::GE_FUNC:
  {
    Item *item= ((Item_func*) cond)->arguments()[1];
    /* In case of 'const op item' we have to swap the operator */
    if (!item->const_item())
      less_fl= 1-less_fl;
    /*
      We only have to check the expression if we are using an expression like
      SELECT MAX(b) FROM t1 WHERE a=const AND b>const
      not for
      SELECT MAX(b) FROM t1 WHERE a=const AND b<const
    */
    if (max_fl != less_fl)
      return cond->val_int() == 0;                // Return 1 if WHERE is false
    return 0;
  }
  case Item_func::EQ_FUNC:
  case Item_func::EQUAL_FUNC:
    break;
  default:                                        // Keep compiler happy
    DBUG_ASSERT(1);                               // Impossible
    break;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int opt_sum_query	(	TABLE_LIST *	tables,
		List< Item > &	all_fields,
		COND *	conds
	)

Definition at line 108 of file opt_sum.cc.

References args, Item::const_item(), count, Item_sum::COUNT_FUNC, error, handler::extra(), FALSE, Item_field::field, Item::FIELD_ITEM, st_table::file, find_key_for_maxmin(), get_exact_record_count(), HA_ERR_END_OF_FILE, HA_ERR_KEY_NOT_FOUND, HA_EXTRA_NO_KEYREAD, HA_HAS_RECORDS, handler::ha_index_end(), handler::ha_index_init(), HA_READ_AFTER_KEY, HA_READ_BEFORE_KEY, HA_READ_KEY_OR_NEXT, HA_READ_PREFIX_LAST_OR_PREV, HA_STATS_RECORDS_IS_EXACT, HA_STATUS_NO_LOCK, HA_STATUS_VARIABLE, handler::index_first(), handler::index_last(), handler::index_read(), st_table_ref::key, st_table_ref::key_buff, st_table_ref::key_length, st_table::key_read, st_table::map, Item_sum::MAX_FUNC, MAX_KEY_LENGTH, Item_sum::MIN_FUNC, MYF, NEAR_MAX, NEAR_MIN, st_table_list::next_leaf, handler::print_error(), Item::real_item(), reckey_in_range(), st_table::record, Item::SUM_FUNC_ITEM, Field::table, test, TRUE, Item::type(), ULONGLONG_MAX, Item::update_used_tables(), and Item::used_tables().

Referenced by JOIN::optimize().

{
  List_iterator_fast<Item> it(all_fields);
  int const_result= 1;
  bool recalc_const_item= 0;
  ulonglong count= 1;
  bool is_exact_count= TRUE, maybe_exact_count= TRUE;
  table_map removed_tables= 0, outer_tables= 0, used_tables= 0;
  table_map where_tables= 0;
  Item *item;
  int error;

  if (conds)
    where_tables= conds->used_tables();

  /*
    Analyze outer join dependencies, and, if possible, compute the number
    of returned rows.
  */
  for (TABLE_LIST *tl= tables; tl; tl= tl->next_leaf)
  {
    TABLE_LIST *embedded;
    for (embedded= tl ; embedded; embedded= embedded->embedding)
    {
      if (embedded->on_expr)
        break;
    }
    if (embedded)
    /* Don't replace expression on a table that is part of an outer join */
    {
      outer_tables|= tl->table->map;

      /*
        We can't optimise LEFT JOIN in cases where the WHERE condition
        restricts the table that is used, like in:
          SELECT MAX(t1.a) FROM t1 LEFT JOIN t2 join-condition
          WHERE t2.field IS NULL;
      */
      if (tl->table->map & where_tables)
        return 0;
    }
    else
      used_tables|= tl->table->map;

    /*
      If the storage manager of 'tl' gives exact row count as part of
      statistics (cheap), compute the total number of rows. If there are
      no outer table dependencies, this count may be used as the real count.
      Schema tables are filled after this function is invoked, so we can't
      get row count 
    */
    if (!(tl->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) ||
        tl->schema_table)
    {
      maybe_exact_count&= test(!tl->schema_table &&
                               (tl->table->file->ha_table_flags() &
                                HA_HAS_RECORDS));
      is_exact_count= FALSE;
      count= 1;                                 // ensure count != 0
    }
    else
    {
      tl->table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
      count*= tl->table->file->stats.records;
    }
  }

  /*
    Iterate through all items in the SELECT clause and replace
    COUNT(), MIN() and MAX() with constants (if possible).
  */

  while ((item= it++))
  {
    if (item->type() == Item::SUM_FUNC_ITEM)
    {
      Item_sum *item_sum= (((Item_sum*) item));
      switch (item_sum->sum_func()) {
      case Item_sum::COUNT_FUNC:
        /*
          If the expr in COUNT(expr) can never be null we can change this
          to the number of rows in the tables if this number is exact and
          there are no outer joins.
        */
        if (!conds && !((Item_sum_count*) item)->args[0]->maybe_null &&
            !outer_tables && maybe_exact_count)
        {
          if (!is_exact_count)
          {
            if ((count= get_exact_record_count(tables)) == ULONGLONG_MAX)
            {
              /* Error from handler in counting rows. Don't optimize count() */
              const_result= 0;
              continue;
            }
            is_exact_count= 1;                  // count is now exact
          }
          ((Item_sum_count*) item)->make_const((longlong) count);
          recalc_const_item= 1;
        }
        else
          const_result= 0;
        break;
      case Item_sum::MIN_FUNC:
      {
        /*
          If MIN(expr) is the first part of a key or if all previous
          parts of the key is found in the COND, then we can use
          indexes to find the key.
        */
        Item *expr=item_sum->args[0];
        if (expr->real_item()->type() == Item::FIELD_ITEM)
        {
          byte key_buff[MAX_KEY_LENGTH];
          TABLE_REF ref;
          uint range_fl, prefix_len;

          ref.key_buff= key_buff;
          Item_field *item_field= (Item_field*) (expr->real_item());
          TABLE *table= item_field->field->table;

          /* 
            Look for a partial key that can be used for optimization.
            If we succeed, ref.key_length will contain the length of
            this key, while prefix_len will contain the length of 
            the beginning of this key without field used in MIN(). 
            Type of range for the key part for this field will be
            returned in range_fl.
          */
          if ((outer_tables & table->map) ||
              !find_key_for_maxmin(0, &ref, item_field->field, conds,
                                   &range_fl, &prefix_len))
          {
            const_result= 0;
            break;
          }
          error= table->file->ha_index_init((uint) ref.key, 1);

          if (!ref.key_length)
            error= table->file->index_first(table->record[0]);
          else
            error= table->file->index_read(table->record[0],key_buff,
                                           ref.key_length,
                                           range_fl & NEAR_MIN ?
                                           HA_READ_AFTER_KEY :
                                           HA_READ_KEY_OR_NEXT);
          if (!error && reckey_in_range(0, &ref, item_field->field, 
                                        conds, range_fl, prefix_len))
            error= HA_ERR_KEY_NOT_FOUND;
          if (table->key_read)
          {
            table->key_read= 0;
            table->file->extra(HA_EXTRA_NO_KEYREAD);
          }
          table->file->ha_index_end();
          if (error)
          {
            if (error == HA_ERR_KEY_NOT_FOUND || error == HA_ERR_END_OF_FILE)
              return -1;                       // No rows matching WHERE
            /* HA_ERR_LOCK_DEADLOCK or some other error */
            table->file->print_error(error, MYF(0));
            return(error);
          }
          removed_tables|= table->map;
        }
        else if (!expr->const_item() || !is_exact_count)
        {
          /*
            The optimization is not applicable in both cases:
            (a) 'expr' is a non-constant expression. Then we can't
            replace 'expr' by a constant.
            (b) 'expr' is a costant. According to ANSI, MIN/MAX must return
            NULL if the query does not return any rows. Thus, if we are not
            able to determine if the query returns any rows, we can't apply
            the optimization and replace MIN/MAX with a constant.
          */
          const_result= 0;
          break;
        }
        if (!count)
        {
          /* If count == 0, then we know that is_exact_count == TRUE. */
          ((Item_sum_min*) item_sum)->clear(); /* Set to NULL. */
        }
        else
          ((Item_sum_min*) item_sum)->reset(); /* Set to the constant value. */
        ((Item_sum_min*) item_sum)->make_const();
        recalc_const_item= 1;
        break;
      }
      case Item_sum::MAX_FUNC:
      {
        /*
          If MAX(expr) is the first part of a key or if all previous
          parts of the key is found in the COND, then we can use
          indexes to find the key.
        */
        Item *expr=item_sum->args[0];
        if (expr->real_item()->type() == Item::FIELD_ITEM)
        {
          byte key_buff[MAX_KEY_LENGTH];
          TABLE_REF ref;
          uint range_fl, prefix_len;

          ref.key_buff= key_buff;
          Item_field *item_field= (Item_field*) (expr->real_item());
          TABLE *table= item_field->field->table;

          /* 
            Look for a partial key that can be used for optimization.
            If we succeed, ref.key_length will contain the length of
            this key, while prefix_len will contain the length of 
            the beginning of this key without field used in MAX().
            Type of range for the key part for this field will be
            returned in range_fl.
          */
          if ((outer_tables & table->map) ||
                  !find_key_for_maxmin(1, &ref, item_field->field, conds,
                                                   &range_fl, &prefix_len))
          {
            const_result= 0;
            break;
          }
          error= table->file->ha_index_init((uint) ref.key, 1);

          if (!ref.key_length)
            error= table->file->index_last(table->record[0]);
          else
            error= table->file->index_read(table->record[0], key_buff,
                                           ref.key_length,
                                           range_fl & NEAR_MAX ?
                                           HA_READ_BEFORE_KEY :
                                           HA_READ_PREFIX_LAST_OR_PREV);
          if (!error && reckey_in_range(1, &ref, item_field->field, 
                                        conds, range_fl, prefix_len))
            error= HA_ERR_KEY_NOT_FOUND;
          if (table->key_read)
          {
            table->key_read=0;
            table->file->extra(HA_EXTRA_NO_KEYREAD);
          }
          table->file->ha_index_end();
          if (error)
          {
            if (error == HA_ERR_KEY_NOT_FOUND || error == HA_ERR_END_OF_FILE)
              return -1;                       // No rows matching WHERE
            /* HA_ERR_LOCK_DEADLOCK or some other error */
            table->file->print_error(error, MYF(0));
            return(error);
          }
          removed_tables|= table->map;
        }
        else if (!expr->const_item() || !is_exact_count)
        {
          /*
            The optimization is not applicable in both cases:
            (a) 'expr' is a non-constant expression. Then we can't
            replace 'expr' by a constant.
            (b) 'expr' is a costant. According to ANSI, MIN/MAX must return
            NULL if the query does not return any rows. Thus, if we are not
            able to determine if the query returns any rows, we can't apply
            the optimization and replace MIN/MAX with a constant.
          */
          const_result= 0;
          break;
        }
        if (!count)
        {
          /* If count != 1, then we know that is_exact_count == TRUE. */
          ((Item_sum_max*) item_sum)->clear(); /* Set to NULL. */
        }
        else
          ((Item_sum_max*) item_sum)->reset(); /* Set to the constant value. */
        ((Item_sum_max*) item_sum)->make_const();
        recalc_const_item= 1;
        break;
      }
      default:
        const_result= 0;
        break;
      }
    }
    else if (const_result)
    {
      if (recalc_const_item)
        item->update_used_tables();
      if (!item->const_item())
        const_result= 0;
    }
  }
  /*
    If we have a where clause, we can only ignore searching in the
    tables if MIN/MAX optimisation replaced all used tables
    We do not use replaced values in case of:
    SELECT MIN(key) FROM table_1, empty_table
    removed_tables is != 0 if we have used MIN() or MAX().
  */
  if (removed_tables && used_tables != removed_tables)
    const_result= 0;                            // We didn't remove all tables
  return const_result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int reckey_in_range	(	bool	max_fl,
		TABLE_REF *	ref,
		Field *	field,
		COND *	cond,
		uint	range_fl,
		uint	prefix_len
	)			[static]

Definition at line 825 of file opt_sum.cc.

References cond, st_table_ref::key, st_table_ref::key_buff, key_cmp_if_same(), maxmin_in_range(), NO_MAX_RANGE, NO_MIN_RANGE, and Field::table.

Referenced by opt_sum_query().

{
  if (key_cmp_if_same(field->table, ref->key_buff, ref->key, prefix_len))
    return 1;
  if (!cond || (range_fl & (max_fl ? NO_MIN_RANGE : NO_MAX_RANGE)))
    return 0;
  return maxmin_in_range(max_fl, field, cond);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool simple_pred	(	Item_func *	func_item,
		Item **	args,
		bool *	inv_order
	)

Definition at line 427 of file opt_sum.cc.

References args, Item_func::argument_count(), Item_func::arguments(), Item::const_item(), Item::FIELD_ITEM, and Item::type().

Referenced by check_group_min_max_predicates(), and matching_cond().

{
  Item *item;
  *inv_order= 0;
  switch (func_item->argument_count()) {
  case 0:
    /* MULT_EQUAL_FUNC */
    {
      Item_equal *item_equal= (Item_equal *) func_item;
      Item_equal_iterator it(*item_equal);
      args[0]= it++;
      if (it++)
        return 0;
      if (!(args[1]= item_equal->get_const()))
        return 0;
    }
    break;
  case 1:
    /* field IS NULL */
    item= func_item->arguments()[0];
    if (item->type() != Item::FIELD_ITEM)
      return 0;
    args[0]= item;
    break;
  case 2:
    /* 'field op const' or 'const op field' */
    item= func_item->arguments()[0];
    if (item->type() == Item::FIELD_ITEM)
    {
      args[0]= item;
      item= func_item->arguments()[1];
      if (!item->const_item())
        return 0;
      args[1]= item;
    }
    else if (item->const_item())
    {
      args[1]= item;
      item= func_item->arguments()[1];
      if (item->