← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

  • Committer: Stewart Smith
  • Date: 2010-07-20 16:36:01 UTC
  • mfrom: (1638.7.6)
  • mto: (1638.9.6) (1685.1.5 build)
  • mto: This revision was merged to the branch mainline in revision 1688.
  • Revision ID: stewart@flamingspork.com-20100720163601-252o9fljtutp1gxa
Merged bug600635-table-proto-default-null-false into varchar-text-keylength-in-proto-as-characters-not-bytes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
598
598
      if (field->getValue()->type() == Item::NULL_ITEM &&
599
599
          ! field->getField()->real_maybe_null())
600
600
      {
601
 
        field->getField()->table->reginfo.not_exists_optimize= 1;
 
601
        field->getField()->getTable()->reginfo.not_exists_optimize= 1;
602
602
      }
603
603
    }
604
604
  }
933
933
bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)
934
934
{
935
935
  bool error;
936
 
  Table *table= field->table;
 
936
  Table *table= field->getTable();
937
937
  Session *session= table->in_use;
938
938
  ha_rows cuted_fields=session->cuted_fields;
939
939
 
1159
1159
          Item *notnull;
1160
1160
          assert(item->type() == Item::FIELD_ITEM);
1161
1161
          Item_field *not_null_item= (Item_field*)item;
1162
 
          JoinTable *referred_tab= not_null_item->field->table->reginfo.join_tab;
 
1162
          JoinTable *referred_tab= not_null_item->field->getTable()->reginfo.join_tab;
1163
1163
          /*
1164
1164
            For UPDATE queries such as:
1165
1165
            UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);
1288
1288
  case Item::FIELD_ITEM:
1289
1289
    {
1290
1290
      Item_field *item_field= (Item_field*)item;
1291
 
      if (item_field->field->table != tbl)
 
1291
      if (item_field->field->getTable() != tbl)
1292
1292
        return true;
1293
1293
      return item_field->field->part_of_key.test(keyno);
1294
1294
    }
2324
2324
  if (outer_ref)
2325
2325
    return cmp;
2326
2326
  JoinTable **idx= (JoinTable **) table_join_idx;
2327
 
  cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];
 
2327
  cmp= idx[field2->field->getTable()->tablenr]-idx[field1->field->getTable()->tablenr];
2328
2328
  return cmp < 0 ? -1 : (cmp ? 1 : 0);
2329
2329
}
2330
2330
 
2571
2571
      while ((item_field= it++))
2572
2572
      {
2573
2573
        Field *field= item_field->field;
2574
 
        JoinTable *stat= field->table->reginfo.join_tab;
 
2574
        JoinTable *stat= field->getTable()->reginfo.join_tab;
2575
2575
        key_map possible_keys= field->key_start;
2576
 
        possible_keys&= field->table->keys_in_use_for_query;
 
2576
        possible_keys&= field->getTable()->keys_in_use_for_query;
2577
2577
        stat[0].const_keys|= possible_keys;
2578
2578
 
2579
2579
        /*
2583
2583
        */
2584
2584
        if (possible_keys.any())
2585
2585
        {
2586
 
          Table *field_tab= field->table;
 
2586
          Table *field_tab= field->getTable();
2587
2587
          optimizer::KeyUse *use;
2588
2588
          for (use= stat->keyuse; use && use->getTable() == field_tab; use++)
2589
2589
            if (possible_keys.test(use->getKey()) &&
2850
2850
  @endverbatim
2851
2851
 
2852
2852
  @param join       Join being processed
2853
 
  @param last_tab   Last table in current partial join order (this function is
2854
 
                    not called for empty partial join orders)
2855
2853
  @param next_tab   Table we're going to extend the current partial join with
2856
2854
 
2857
2855
  @retval
2860
2858
  @retval
2861
2859
    true   Requested join order extension not allowed.
2862
2860
*/
2863
 
bool check_interleaving_with_nj(JoinTable *last_tab, JoinTable *next_tab)
 
2861
bool check_interleaving_with_nj(JoinTable *next_tab)
2864
2862
{
2865
2863
  TableList *next_emb= next_tab->table->pos_in_table_list->getEmbedding();
2866
 
  Join *join= last_tab->join;
 
2864
  Join *join= next_tab->join;
2867
2865
 
2868
2866
  if ((join->cur_embedding_map & ~next_tab->embedding_map).any())
2869
2867
  {
3027
3025
    {
3028
3026
      Field *field= ((Item_field*) args[0])->field;
3029
3027
      if (field->flags & AUTO_INCREMENT_FLAG 
3030
 
          && ! field->table->maybe_null 
 
3028
          && ! field->getTable()->maybe_null 
3031
3029
          && session->options & OPTION_AUTO_IS_NULL
3032
3030
          && (
3033
3031
            session->first_successful_insert_id_in_prev_stmt > 0 
3085
3083
  /*
3086
3084
    TODO:
3087
3085
    Excluding all expensive functions is too restritive we should exclude only
3088
 
    materialized IN because it is created later than this phase, and cannot be
3089
 
    evaluated at this point.
3090
 
    The condition should be something as (need to fix member access):
3091
 
      !(cond->type() == Item::FUNC_ITEM &&
3092
 
        ((Item_func*)cond)->func_name() == "<in_optimizer>" &&
3093
 
        ((Item_in_optimizer*)cond)->is_expensive()))
 
3086
    materialized IN subquery predicates because they can't yet be evaluated
 
3087
    here (they need additional initialization that is done later on).
 
3088
 
 
3089
    The proper way to exclude the subqueries would be to walk the cond tree and
 
3090
    check for materialized subqueries there.
 
3091
 
3094
3092
  */
3095
3093
  {
3096
3094
    *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
4276
4274
{
4277
4275
  Field *field=left_item->field;
4278
4276
  // No need to change const test. We also have to keep tests on LEFT JOIN
4279
 
  if (!field->table->const_table && !field->table->maybe_null)
 
4277
  if (not field->getTable()->const_table && !field->getTable()->maybe_null)
4280
4278
  {
4281
 
    Item *ref_item=part_of_refkey(field->table,field);
 
4279
    Item *ref_item=part_of_refkey(field->getTable(),field);
4282
4280
    if (ref_item && ref_item->eq(right_item,1))
4283
4281
    {
4284
4282
      right_item= right_item->real_item();
6145
6143
          saved value
6146
6144
        */
6147
6145
        field= item->field;
6148
 
        item->result_field=field->new_field(session->mem_root,field->table, 1);
 
6146
        item->result_field=field->new_field(session->mem_root,field->getTable(), 1);
6149
6147
              /*
6150
6148
                We need to allocate one extra byte for null handling and
6151
6149
                another extra byte to not get warnings from purify in
6278
6276
      }
6279
6277
      else if ((field= item->get_tmp_table_field()))
6280
6278
      {
6281
 
        if (item->type() == Item::SUM_FUNC_ITEM && field->table->group)
 
6279
        if (item->type() == Item::SUM_FUNC_ITEM && field->getTable()->group)
6282
6280
          item_field= ((Item_sum*) item)->result_item(field);
6283
6281
        else
6284
6282
          item_field= (Item*) new Item_field(field);