← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

Merge from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
249
249
             (Subquery is non-correlated ||
250
250
              Subquery is correlated to any query outer to IN predicate ||
251
251
              (Subquery is correlated to the immediate outer query &&
252
 
               Subquery !contains {GROUP BY, order_st BY [LIMIT],
 
252
               Subquery !contains {GROUP BY, ORDER BY [LIMIT],
253
253
               aggregate functions) && subquery predicate is not under "NOT IN"))
254
254
          6. No execution method was already chosen (by a prepared statement).
255
255
 
654
654
    }
655
655
 
656
656
    /*
657
 
      If we are using order_st BY NULL or order_st BY const_expression,
 
657
      If we are using ORDER BY NULL or ORDER BY const_expression,
658
658
      return result in any order (even if we are using a GROUP BY)
659
659
    */
660
660
    if (!order && org_order)
685
685
        We have found that grouping can be removed since groups correspond to
686
686
        only one row anyway, but we still have to guarantee correct result
687
687
        order. The line below effectively rewrites the query from GROUP BY
688
 
        <fields> to order_st BY <fields>. There are two exceptions:
 
688
        <fields> to ORDER BY <fields>. There are two exceptions:
689
689
        - if skip_sort_order is set (see above), then we can simply skip
690
690
          GROUP BY;
691
 
        - we can only rewrite order_st BY if the order_st BY fields are 'compatible'
 
691
        - we can only rewrite ORDER BY if the ORDER BY fields are 'compatible'
692
692
          with the GROUP BY ones, i.e. either one is a prefix of another.
693
 
          We only check if the order_st BY is a prefix of GROUP BY. In this case
 
693
          We only check if the ORDER BY is a prefix of GROUP BY. In this case
694
694
          test_if_subpart() copies the ASC/DESC attributes from the original
695
 
          order_st BY fields.
 
695
          ORDER BY fields.
696
696
          If GROUP BY is a prefix of order_st BY, then it is safe to leave
697
697
          'order' as is.
698
698
       */
731
731
      - We are scanning the whole table without LIMIT
732
732
        This can happen if:
733
733
        - We are using CALC_FOUND_ROWS
734
 
        - We are using an order_st BY that can't be optimized away.
 
734
        - We are using an ORDER BY that can't be optimized away.
735
735
 
736
736
      We don't want to use this optimization when we are using LIMIT
737
737
      because in this case we can just create a temporary table that
763
763
          {
764
764
            /*
765
765
              Force MySQL to read the table in sorted order to get result in
766
 
              order_st BY order.
 
766
              ORDER BY order.
767
767
            */
768
768
            tmp_table_param.quick_group=0;
769
769
          }
820
820
    This has to be done if all tables are not already read (const tables)
821
821
    and one of the following conditions holds:
822
822
    - We are using DISTINCT (simple distinct's are already optimized away)
823
 
    - We are using an order_st BY or GROUP BY on fields not in the first table
824
 
    - We are using different order_st BY and GROUP BY orders
 
823
    - We are using an ORDER BY or GROUP BY on fields not in the first table
 
824
    - We are using different ORDER BY and GROUP BY orders
825
825
    - The user wants us to buffer the result.
826
826
  */
827
827
  need_tmp= (const_tables != tables &&
1000
1000
                                                                     (order_st*) 0);
1001
1001
    /*
1002
1002
      Pushing LIMIT to the temporary table creation is not applicable
1003
 
      when there is order_st BY or GROUP BY or there is no GROUP BY, but
 
1003
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
1004
1004
      there are aggregate functions, because in all these cases we need
1005
1005
      all result rows.
1006
1006
    */
1273
1273
  if (select_options & SELECT_DESCRIBE)
1274
1274
  {
1275
1275
    /*
1276
 
      Check if we managed to optimize order_st BY away and don't use temporary
 
1276
      Check if we managed to optimize ORDER BY away and don't use temporary
1277
1277
      table to resolve order_st BY: in that case, we only may need to do
1278
1278
      filesort for GROUP BY.
1279
1279
    */