An error occurred fetching the project authors.
  1. 20 Apr, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#715069 · 43acceeb
      unknown authored
      Analysis:
      The wrong result is a consquence of sorting the subquery
      result and then selecting only the first row due to the
      artificial LIMIT 1 introduced by the fix_fields phase.
      Normally, if there is an ORDER BY in a subquery, the ORDER
      is removed (Item_in_subselect::select_in_like_transformer),
      however if a GROUP BY is transformed into ORDER, this happens
      later, after the removal of the ORDER clause of subqueries, so
      we end up with a subquery with an ORDER clause, and an artificially
      added LIMIT 1.
      
      The reason why the same works in the main 5.3 without MWL#89, is
      that the 5.3 performs all subquery transformations, including
      IN->EXISTS before JOIN::optimize(). The beginning of JOIN::optimize
      does:
        if (having || (select_options & OPTION_FOUND_ROWS))
          select_limit= HA_POS_ERROR;
      which sets the limit back to infinity, thus 5.3 sorts the whole
      subquery result, and IN performs the lookup into all subquery result
      rows.
      
      Solution:
      Sorting of subqueries without LIMIT is meaningless. Since LIMIT in
      subqueries is not supported, the patch removes sorting by setting
        join->skip_sort_order= true
      for each subquery JOIN object. This improves a number of execution
      plans to not perform unnecessary sorting at all.
      43acceeb
  2. 08 Mar, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#719198 · 546a166b
      unknown authored
      Analysis:
      The assert failed because the execution code for
      partial matching is designed with the assumption that
      NULLs on the left side are detected as early as possible,
      and a NULL result is returned before any lookups are
      performed at all.
      
      However, in the case of an Item_cache object on the left
      side, null was not detected properly, because detection
      was done via Item::is_null(), which is not implemented at
      all for Item_cache, and resolved to the default Item::is_null()
      which always returns FALSE.
      
      Solution:
      Use the property Item::null_value instead of is_null(), which
      is properly updated for Item_cache objects as well.
      546a166b
  3. 03 Mar, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#718763 · adce16f9
      unknown authored
      Analysis:
      The reason for the crash was that the inner subquery was executed
      via a scan on a final temporary table applied after all other
      operations. This final operation is implemented by changing the
      contents of the JOIN object of the subquery to represent a table
      scan over the temp table. At the same time query optimization of
      the outer subquery required evaluation of the inner subquery, which
      happened before the actual EXPLAIN. The evaluation left the JOIN
      object of the inner subquery in the changed state, where it represented
      a table scan over a temp table, and EXPLAIN crashed because the temp
      table is not associated with any table reference (TABLE_LIST object).
      The reason the JOIN was not restored was because its saving/restoration
      was controlled by the join->select_lex->uncacheable flag, which was
      not set in the case of materialization.
      
      Solution:
      In the methods Item_in_subselect::[single | row]_value_transformer() set:
          select_lex->uncacheable|= UNCACHEABLE_EXPLAIN;
      In addition, for symmetry, change:
          master_unit->uncacheable|= UNCACHEABLE_EXPLAIN;
      instead of UNCACHEABLE_DEPENDENT because if a subquery was not
      dependent initially, the changed methods do not change this
      fact. The subquery may later become correlated if it is transformed
      to an EXISTS query, but it may stay uncorrelated if executed via
      materialization.
      adce16f9
  4. 18 Feb, 2011 1 commit
  5. 10 Feb, 2011 1 commit
    • unknown's avatar
      MWL#89 · ca373395
      unknown authored
      Fixed a memory leak found by valgrind. The memory leak was
      a result of JOINs corresponding to subselects in a global
      ORDER BY of a UNION not being cleaned up because the
      fake_select of the UNION didn't point down to the subquery
      select.
      ca373395
  6. 18 Jan, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#704337 · 2038256b
      unknown authored
      Analysis:
      The cause for the failing assert was that between preparation
      and execution of a DELETE prepared statement, the server reverted
      back all changes of the item tree. Since the substitution of
      Item_in_subselect by an Item_in_optimizer was recorded via
      change_item_tree, thus the rollback of the item tree affected
      the substitution as well. As a result the execution of the PS
      called Item_in_subselect::val_int(), which was never supposed
      to be called.
      
      Solution:
      Replace change_item_tree with assignment. This is OK because
      the Item objects used for substitution are created in PS memory.
      2038256b
  7. 28 Dec, 2010 1 commit
    • Kent Boortz's avatar
      - Added/updated copyright headers · 85323eda
      Kent Boortz authored
      - Removed files specific to compiling on OS/2
      - Removed files specific to SCO Unix packaging
      - Removed "libmysqld/copyright", text is included in documentation
      - Removed LaTeX headers for NDB Doxygen documentation
      - Removed obsolete NDB files
      - Removed "mkisofs" binaries
      - Removed the "cvs2cl.pl" script
      - Changed a few GPL texts to use "program" instead of "library"
      85323eda
  8. 15 Dec, 2010 1 commit
    • unknown's avatar
      MWL#89 · 0bee625f
      unknown authored
      Post-review fixes. Intermediate commit to address
      review points 1.1, 1.2, 1.3, 1.4, 1.5, and 3.1, 3.2, 3.3.
      0bee625f
  9. 14 Dec, 2010 2 commits
    • unknown's avatar
      Fix LP BUG#685411 · 4f28dcbe
      unknown authored
      Analysis:
      The assert failed because st_select_lex::print() was called for subqueries
      as follows:
      
      Item_subselect::print() ->
        subselect_single_select_engine::print() -> st_select_lex::print()
      
      It was Item_subselect::fix_fields() that set the thd by calling set_thd(),
      so when this print() was called before fix_fields(), subselect_engine::thd
      was NULL.
      
      Solution:
      The patch makes all constructors of all subselect_engine classes to take
      a THD parameter. The default subselect_single_select_engine engine is created
      early during parse time, in the Item_subselect::init call, so we pass the
      correct THD object already at this point.
      4f28dcbe
    • Sergey Glukhov's avatar
      Fixed following problems: · fcb83cbf
      Sergey Glukhov authored
      --Bug#52157 various crashes and assertions with multi-table update, stored function
      --Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb
      --Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846
      --Bug#57352 valgrind warnings when creating view
      --Recently discovered problem when a nested materialized derived table is used
        before being populated and it leads to incorrect result
      
      We have several modes when we should disable subquery evaluation.
      The reasons for disabling are different. It could be
      uselessness of the evaluation as in case of 'CREATE VIEW'
      or 'PREPARE stmt', or we should disable subquery evaluation
      if tables are not locked yet as it happens in bug#54475, or
      too early evaluation of subqueries can lead to wrong result
      as it happened in Bug#19077.
      Main problem is that if subquery items are treated as const
      they are evaluated in ::fix_fields(), ::fix_length_and_dec()
      of the parental items as a lot of these methods have
      Item::val_...() calls inside.
      We have to make subqueries non-const to prevent unnecessary
      subquery evaluation. At the moment we have different methods
      for this. Here is a list of these modes:
      
      1. PREPARE stmt;
      We use UNCACHEABLE_PREPARE flag.
      It is set during parsing in sql_parse.cc, mysql_new_select() for
      each SELECT_LEX object and cleared at the end of PREPARE in
      sql_prepare.cc, init_stmt_after_parse(). If this flag is set
      subquery becomes non-const and evaluation does not happen.
      
      2. CREATE|ALTER VIEW, SHOW CREATE VIEW, I_S tables which
         process FRM files
      We use LEX::view_prepare_mode field. We set it before
      view preparation and check this flag in
      ::fix_fields(), ::fix_length_and_dec().
      Some bugs are fixed using this approach,
      some are not(Bug#57352, Bug#57703). The problem here is
      that we have a lot of ::fix_fields(), ::fix_length_and_dec()
      where we use Item::val_...() calls for const items.
      
      3. Derived tables with subquery = wrong result(Bug19077)
      The reason of this bug is too early subquery evaluation.
      It was fixed by adding Item::with_subselect field
      The check of this field in appropriate places prevents
      const item evaluation if the item have subquery.
      The fix for Bug19077 fixes only the problem with
      convert_constant_item() function and does not cover
      other places(::fix_fields(), ::fix_length_and_dec() again)
      where subqueries could be evaluated.
      
      Example:
      CREATE TABLE t1 (i INT, j BIGINT);
      INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2);
      SELECT * FROM (SELECT MIN(i) FROM t1
      WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3;
      DROP TABLE t1;
      
      4. Derived tables with subquery where subquery
         is evaluated before table locking(Bug#54475, Bug#52157)
      
      Suggested solution is following:
      
      -Introduce new field LEX::context_analysis_only with the following
       possible flags:
       #define CONTEXT_ANALYSIS_ONLY_PREPARE 1
       #define CONTEXT_ANALYSIS_ONLY_VIEW    2
       #define CONTEXT_ANALYSIS_ONLY_DERIVED 4
      -Set/clean these flags when we perform
       context analysis operation
      -Item_subselect::const_item() returns
       result depending on LEX::context_analysis_only.
       If context_analysis_only is set then we return
       FALSE that means that subquery is non-const.
       As all subquery types are wrapped by Item_subselect
       it allow as to make subquery non-const when
       it's necessary.
      
      
      mysql-test/r/derived.result:
        test case
      mysql-test/r/multi_update.result:
        test case
      mysql-test/r/view.result:
        test case
      mysql-test/suite/innodb/r/innodb_multi_update.result:
        test case
      mysql-test/suite/innodb/t/innodb_multi_update.test:
        test case
      mysql-test/suite/innodb_plugin/r/innodb_multi_update.result:
        test case
      mysql-test/suite/innodb_plugin/t/innodb_multi_update.test:
        test case
      mysql-test/t/derived.test:
        test case
      mysql-test/t/multi_update.test:
        test case
      mysql-test/t/view.test:
        test case
      sql/item.cc:
        --removed unnecessary code
      sql/item_cmpfunc.cc:
        --removed unnecessary checks
        --THD::is_context_analysis_only() is replaced with LEX::is_ps_or_view_context_analysis()
      sql/item_func.cc:
        --refactored context analysis checks
      sql/item_row.cc:
        --removed unnecessary checks
      sql/item_subselect.cc:
        --removed unnecessary code
        --added DBUG_ASSERT into Item_subselect::exec()
          which asserts that subquery execution can not happen
          if LEX::context_analysis_only is set, i.e. at context
          analysis stage.
        --Item_subselect::const_item()
          Return FALSE if LEX::context_analysis_only is set.
          It prevents subquery evaluation in ::fix_fields &
          ::fix_length_and_dec at context analysis stage.
      sql/item_subselect.h:
        --removed unnecessary code
      sql/mysql_priv.h:
        --Added new set of flags.
      sql/sql_class.h:
        --removed unnecessary code
      sql/sql_derived.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_lex.cc:
        --init LEX::context_analysis_only field
      sql/sql_lex.h:
        --New LEX::context_analysis_only field
      sql/sql_parse.cc:
        --removed unnecessary code
      sql/sql_prepare.cc:
        --removed unnecessary code
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_select.cc:
        --refactored context analysis checks
      sql/sql_show.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_view.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      fcb83cbf
  10. 29 Nov, 2010 1 commit
    • Michael Widenius's avatar
      Fixed some compiler warnings found when compiling for windows. · ab5e4eef
      Michael Widenius authored
      Changed rows_read and rows_sent status variables to be longlong (to avoid compiler warnings)
      
      
      sql/item_func.cc:
        Fixed wrong usage of alias
      sql/item_subselect.cc:
        Changed buffer size to ulonglong to be able detect buffers bigger than size_t
      sql/item_subselect.h:
        Changed buffer size to ulonglong to be able detect buffers bigger than size_t
      sql/multi_range_read.cc:
        Fixed compiler warning by using correct type for function argument
      sql/mysqld.cc:
        Changed rows_read and rows_sent status variables to be longlong
      sql/opt_subselect.h:
        Fixed compiler warning by using correct type for function argument
      sql/sql_class.cc:
        Changed rows_read and rows_sent status variables to be longlong
      sql/sql_class.h:
        Changed rows_read and rows_sent status variables to be longlong
        Changed max_nulls_in_row to uint as this is number of columns in row.
        This fixed some compiler warnings.
      sql/sql_select.cc:
        Added casts to avoid compiler warnings
      storage/heap/ha_heap.cc:
        Initilize different types separate
      storage/oqgraph/ha_oqgraph.cc:
        Fixed argument to store(longlong) to avoid compiler warnings
      ab5e4eef
  11. 22 Nov, 2010 1 commit
    • unknown's avatar
      Fix LP BUG#680038 · 2fa5df5f
      unknown authored
      Analysis:
      Single-row subqueries are not considered expensive and are
      evaluated both during EXPLAIN in to detect errors like
      "Subquery returns more than 1 row", and during optimization to
      perform constant optimization.
      
      The cause for the failed ASSERT is in JOIN::join_free, where we set
        bool full= (!select_lex->uncacheable && !thd->lex->describe);
      Thus for EXPLAIN statements full == FALSE, and as a result the call to
      JOIN::cleanup doesn't call JOIN_TAB::cleanup which should have
      called table->disable_keyread().
      
      Solution:
      Consider all kinds of subquery predicates as expensive.
      2fa5df5f
  12. 02 Nov, 2010 1 commit
  13. 27 Oct, 2010 1 commit
    • unknown's avatar
      Fixed LP bug #613009 · 3bdede3c
      unknown authored
      The set of Ordered keys of a rowid merge engine is dense. Thus when
      we decide not to create a key for a column that has only NULLs, this
      column shouldn't be counted.
      
      Notice that the caller has already precomputed the correct total
      number of keys that should be created.
      3bdede3c
  14. 26 Oct, 2010 1 commit
    • unknown's avatar
      Fixed LP bug #601156 · b4d5f30a
      unknown authored
      The cause for this bug is that MariaDB 5.3 still processes derived tables
      (subqueries in the FROM clause) by fully executing them during the parse
      phase. This will be remedied by MWL#106 once merged into the main 5.3.
      
      The assert statement is triggered when MATERIALIZATION is ON for EXPLAIN
      EXTENDED for derived tables with an IN subquery as follows:
      - mysql_parse calls JOIN::exec for the derived table as if it is regular
        execution (not explain).
      - When materialization is ON, this call goes all the way to
        subselect_hash_sj_engine::exec, which creates a partial match engine
        because of NULL presence.
      - In order to proceed with normal execution, the hash_sj engine substitutes
        itself with the created partial match engine.
      - After the parse phase it turns out that this execution was part of
        EXPLAIN EXTENDED, which in turn calls
        Item_cond::print -> ... -> Item_subselect::print,
        which calls engine->print().
        Since subselect_hash_sj_engine::exec substituted the current
        Item_subselect engine with a  partial match engine, eventually we call
        its ::print() method. However the partial match engines are designed only
        for execution, hence there is no implementation of this print() method.
      
      The fix temporarily removes the assert, until this code is merged with
      MWL#106.
      b4d5f30a
  15. 23 Oct, 2010 1 commit
  16. 18 Oct, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#56814 Explain + subselect + fulltext crashes server · d0ac4e2c
      Sergey Glukhov authored
      create_sort_index() function overwrites original JOIN_TAB::type field.
      At re-execution of subquery overwritten JOIN_TAB::type(JT_ALL) is
      used instead of JT_FT. It misleads test_if_skip_sort_order() and
      the function tries to find suitable key for the order that should
      not be allowed for FULLTEXT(JT_FT) table.
      The fix is to restore JOIN_TAB strucures for subselect on re-execution
      for EXPLAIN.
      Additional fix:
      Update TABLE::maybe_null field which
      affects list_contains_unique_index() behaviour as it
      could have the value(maybe_null==TRUE) based on the
      assumption that this join is outer
      (see setup_table_map() func).
      
      
      mysql-test/r/explain.result:
        test case
      mysql-test/t/explain.test:
        test case
      sql/item_subselect.cc:
        Make subquery uncacheable in case of EXPLAIN. It allows to keep
        original JOIN_TAB::type(see JOIN::save_join_tab) and restore it
        on re-execution.
      sql/sql_select.cc:
        -restore JOIN_TAB strucures for subselect on re-execution for EXPLAIN
        -Update TABLE::maybe_null field as it could have
         the value(maybe_null==TRUE) based on the assumption
         that this join is outer(see setup_table_map() func).
         This change is not related to the crash problem but
         affects EXPLAIN results in the test case.
      d0ac4e2c
  17. 05 Oct, 2010 1 commit
  18. 01 Oct, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#54488 crash when using explain and prepared statements with subqueries · 233e4d80
      Sergey Glukhov authored
      The crash happens because original join table is replaced with temporary table
      at execution stage and later we attempt to use this temporary table in
      select_describe. It might happen that
      Item_subselect::update_used_tables() method which sets const_item flag
      is not called by some reasons (no where/having conditon in subquery for example).
      It prevents JOIN::join_tmp creation and breaks original join.
      The fix is to call ::update_used_tables() before ::const_item() check.
      
      
      mysql-test/r/ps.result:
        test case
      mysql-test/t/ps.test:
        test case
      sql/item_subselect.cc:
        call ::update_used_tables() before ::const_item() check.
      233e4d80
  19. 30 Sep, 2010 1 commit
    • unknown's avatar
      MWL#89: Cost-based choice between Materialization and IN->EXISTS transformation · 8ec5e13f
      unknown authored
        Phase 3: Implementation of re-optimization of subqueries with injected predicates
                 and cost comparison between Materialization and IN->EXISTS strategies.
      
      The commit contains the following known problems:
      - The implementation of EXPLAIN has not been re-engineered to reflect the
        changes in subquery optimization. EXPLAIN for subqueries is called during
        the execute phase, which results in different code paths during JOIN::optimize
        and thus in differing EXPLAIN messages for constant/system tables.
      - There are some valgrind warnings that need investigation
      - Several EXPLAINs with minor differences need to be reconsidered after fixing
        the EXPLAIN problem above.
      
      This patch also adds one extra optimizer_switch: 'in_to_exists' for complete
      manual control of the subquery execution strategies.
      8ec5e13f
  20. 16 Sep, 2010 1 commit
  21. 09 Sep, 2010 1 commit
    • Alexey Kopytov's avatar
      Bug #54190: Comparison to row subquery produces incorrect · 453107bc
      Alexey Kopytov authored
                  result
      
      Row subqueries producing no rows were not handled as UNKNOWN
      values in row comparison expressions.
      
      That was a result of the following two problems:
      
      1. Item_singlerow_subselect did not mark the resulting row
      value as NULL/UNKNOWN when no rows were produced.
      
      2. Arg_comparator::compare_row() did not take into account that
      a whole argument may be NULL rather than just individual scalar
      values.
      
      Before bug#34384 was fixed, the above problems were hidden
      because an uninitialized (i.e. without any stored value) cached
      object would appear as NULL for scalar values in a row subquery
      returning an empty result. After the fix
      Arg_comparator::compare_row() would try to evaluate
      uninitialized cached objects.
      
      Fixed by removing the aforementioned problems.
      
      
      mysql-test/r/row.result:
        Added a test case for bug #54190.
      mysql-test/r/subselect.result:
        Updated the result for a test relying on wrong behavior.
      mysql-test/t/row.test:
        Added a test case for bug #54190.
      sql/item_cmpfunc.cc:
        If either of the argument rows is NULL, return NULL as the
        result of comparison.
      sql/item_subselect.cc:
        Adjust null_value for Item_singlerow_subselect depending on
        whether a row has been produced by the row subquery.
      453107bc
  22. 07 Sep, 2010 1 commit
    • Martin Hansson's avatar
      Bug#51070: Query with a NOT IN subquery predicate returns a wrong result set · 4f4d03a4
      Martin Hansson authored
            
      The EXISTS transformation has additional switches to catch the known corner
      cases that appear when transforming an IN predicate into EXISTS. Guarded
      conditions are used which are deactivated when a NULL value is seen in the
      outer expression's row. When the inner query block supplies NULL values,
      however, they are filtered out because no distinction is made between the
      guarded conditions; guarded NOT x IS NULL conditions in the HAVING clause that
      filter out NULL values cannot be de-activated in isolation from those that
      match values or from the outer expression or NULL's.
      
      The above problem is handled by making the guarded conditions remember whether
      they have rejected a NULL value or not, and index access methods are taking
      this into account as well. 
      
      The bug consisted of 
      
      1) Not resetting the property for every nested loop iteration on the inner
         query's result.
      
      2) Not propagating the NULL result properly from inner query to IN optimizer.
      
      3) A hack that may or may not have been needed at some point. According to a
         comment it was aimed to fix #2 by returning NULL when FALSE was actually
         the result. This caused failures when #2 was properly fixed. The hack is
         now removed.
      
      The fix resolves all three points.
      4f4d03a4
  23. 06 Sep, 2010 2 commits
    • unknown's avatar
      Fixed LP BUG#615760: Check on double cache assignment added into the transformation methods. · d6a9b522
      unknown authored
      Cache parameters print added in EXPLAIN EXTENDED output.
      
      mysql-test/r/compare.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/group_by.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect3.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect3_jcl6.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect4.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_cache.result:
        Added test suite for LP BUG#615760
      mysql-test/r/subselect_mat.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_no_mat.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_no_opts.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_no_semijoin.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_sj.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/r/subselect_sj_jcl6.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/suite/pbxt/r/subselect.result:
        Cache parameters print added in EXPLAIN EXTENDED output.
      mysql-test/t/subselect_cache.test:
        Cache parameters print added in EXPLAIN EXTENDED output.
      sql/item.cc:
        Item::set_expr_cache result fixed according to its description.
        
        Cache parameters print added in EXPLAIN EXTENDED output.
      sql/item.h:
        Cache parameters print added in EXPLAIN EXTENDED output.
      sql/item_cmpfunc.cc:
        Check on double cache assignment added into the transformation methods.
      sql/item_cmpfunc.h:
        Check on double cache assignment added into the transformation methods.
      sql/item_subselect.cc:
        Check on double cache assignment added into the transformation methods.
      sql/item_subselect.h:
        Check on double cache assignment added into the transformation methods.
      sql/sql_expression_cache.cc:
        Cache parameters print added.
      sql/sql_expression_cache.h:
        Cache parameters print added.
      sql/sql_select.cc:
        Removed unused method (now it is impossible to make double transformation with the cache).
      sql/sql_select.h:
        Removed unused method.
      d6a9b522
    • unknown's avatar
      22a2cce3
  24. 05 Sep, 2010 1 commit
  25. 30 Aug, 2010 1 commit
    • unknown's avatar
      Fixed LP bug #608744 · f5ecf708
      unknown authored
      The bug is a result of the following change by Monty:
        Revision Id: monty@askmonty.org-20100716073301-gstby2062nqd42qv
        Timestamp: Fri 2010-07-16 10:33:01 +0300
      Where Monty changed the queues interface and implementation.
      
      The fix adjusts the queue_remove call to the new interface.
      
      
      mysql-test/r/subselect_partial_match.result:
        Added new file for tests related to MWL#89.
      mysql-test/t/subselect_partial_match.test:
        Added new file for tests related to MWL#89.
      f5ecf708
  26. 18 Jul, 2010 2 commits
    • unknown's avatar
      MWL#89: Cost-based choice between Materialization and IN->EXISTS transformation · aa195b25
      unknown authored
        
      Step2 in the separation of the creation of IN->EXISTS equi-join conditions from
      their injection. The goal of this separation is to make it possible that the
      IN->EXISTS conditions can be used for cost estimation without actually modifying
      the subquery.
        
      This patch separates row_value_in_to_exists_transformer() into two methods:
      - create_row_value_in_to_exists_cond(), and
      - inject_row_value_in_to_exists_cond()
      The patch performs minimal refactoring of the code so that it is easier to solve
      problems resulting from the separation. There is a lot to be simplified in this
      code, but this will be done separately.
      aa195b25
    • unknown's avatar
      MWL#89: Cost-based choice between Materialization and IN->EXISTS transformation · 78ddd9ff
      unknown authored
      Step1 in the separation of the creation of IN->EXISTS equi-join conditions from
      their injection. The goal of this separation is to make it possible that the
      IN->EXISTS conditions can be used for cost estimation without actually modifying
      the subquery.
      
      This patch separates single_value_in_to_exists_transformer() into two methods:
      - create_single_value_in_to_exists_cond(), and
      - inject_single_value_in_to_exists_cond()
      The patch performs minimal refactoring of the code so that it is easier to solve
      problems resulting from the separation. There is a lot to be simplified in this
      code, but this will be done separately.
      78ddd9ff
  27. 16 Jul, 2010 3 commits
    • Michael Widenius's avatar
      Fix for LP#588251: doStartTableScan() result not checked. · e9166ca1
      Michael Widenius authored
      The issue was that we didn't always check result of ha_rnd_init() which caused a problem for handlers that returned an error in this code.
      - Changed prototype of ha_rnd_init() to ensure that we get a compile warning if result is not checked.
      - Added ha_rnd_init_with_error() that prints error on failure.
      - Checked all usage of ha_rnd_init() and ensure we generate an error message on failures.
      - Changed init_read_record() to return 1 on failure.
      
      
      
      
      sql/create_options.cc:
        Fixed wrong printf
      sql/event_db_repository.cc:
        Check result from init_read_record()
      sql/events.cc:
        Check result from init_read_record()
      sql/filesort.cc:
        Check result from ha_rnd_init()
      sql/ha_partition.cc:
        Check result from ha_rnd_init()
      sql/ha_partition.h:
        Fixed compiler warning
      sql/handler.cc:
        Added ha_rnd_init_with_error()
        Check result from ha_rnd_init()
      sql/handler.h:
        Added ha_rnd_init_with_error()
        Changed prototype of ha_rnd_init() to ensure that we get a compile warning if result is not checked
      sql/item_subselect.cc:
        Check result from ha_rnd_init()
      sql/log.cc:
        Check result from ha_rnd_init()
      sql/log_event.cc:
        Check result from ha_rnd_init()
      sql/log_event_old.cc:
        Check result from ha_rnd_init()
      sql/mysql_priv.h:
        init_read_record() now returns error code on failure
      sql/opt_range.cc:
        Check result from ha_rnd_init()
      sql/records.cc:
        init_read_record() now returns error code on failure
        Check result from ha_rnd_init()
      sql/sql_acl.cc:
        Check result from init_read_record()
      sql/sql_cursor.cc:
        Print error if ha_rnd_init() fails
      sql/sql_delete.cc:
        Check result from init_read_record()
      sql/sql_help.cc:
        Check result from init_read_record()
      sql/sql_plugin.cc:
        Check result from init_read_record()
      sql/sql_select.cc:
        Check result from ha_rnd_init()
        Print error if ha_rnd_init() fails.
      sql/sql_servers.cc:
        Check result from init_read_record()
      sql/sql_table.cc:
        Check result from init_read_record()
      sql/sql_udf.cc:
        Check result from init_read_record()
      sql/sql_update.cc:
        Check result from init_read_record()
      storage/example/ha_example.cc:
        Don't return error on rnd_init()
      storage/ibmdb2i/ha_ibmdb2i.cc:
        Removed not relevant comment
      e9166ca1
    • unknown's avatar
      MWL#89: Cost-based choice between Materialization and IN->EXISTS transformation · 875bd20a
      unknown authored
      1. Changed the lazy optimization for subqueries that can be
         materialized into bottom-up optimization during the optimization of
         the main query.
      
         The main change is implemented by the method
         Item_in_subselect::setup_engine.
        
         All other changes were required to correct problems resulting from
         changing the order of optimization. Most of these problems followed
         the same pattern - there are some shared structures between a
         subquery and its parent query. Depending on which one is optimized
         first (parent or child query), these shared strucutres may get
         different values, thus resulting in an inconsistent query plan.
      
      2. Changed the code-generation for subquery materialization to be
         performed in runtime memory for each (re)execution, instead of in
         statement memory (once per prepared statement).
         - Item_in_subselect::setup_engine() no longer creates materialization
           related objects in statement memory.
         - Merged subselect_hash_sj_engine::init_permanent and
           subselect_hash_sj_engine::init_runtime into
           subselect_hash_sj_engine::init, which is called for each
           (re)execution.
         - Fixed deletion of the temp table accordingly.
      
      
      mysql-test/r/subselect_mat.result:
        Adjusted changed EXPLAIN because of earlier optimization of subqueries.
      875bd20a
    • Michael Widenius's avatar
      Improved speed of thr_alarm from O(N) to O(1). thr_alarm is used to handle... · ecbcddc0
      Michael Widenius authored
      Improved speed of thr_alarm from O(N) to O(1). thr_alarm is used to handle timeouts and kill of connections.
      Fixed compiler warnings.
      queues.h and queues.c are now based on the UNIREG code and thus made BSD.
      Fix code to use new queue() interface. This mostly affects how you access elements in the queue.
      If USE_NET_CLEAR is not set, don't clear connection from unexpected characters. This should give a speed up when doing a lot of fast queries.
      Fixed some code in ma_ft_boolean_search.c that had not made it from myisam/ft_boolean_search.c
      
      
      include/queues.h:
        Use UNIREG code base (BSD)
        Changed init_queue() to take all initialization arguments.
        New interface to access elements in queue
      include/thr_alarm.h:
        Changed to use time_t instead of ulong (portability)
        Added index_in_queue, to be able to remove random element from queue in O(1)
      mysys/queues.c:
        Use UNIREG code base (BSD)
        init_queue() and reinit_queue() now takes more initialization arguments. (No need for init_queue_ex() anymore)
        Now one can tell queue_insert() to store in the element a pointer to where element is in queue. This allows one to remove elements from queue in O(1) instead of O(N)
      mysys/thr_alarm.c:
        Use new option in queue() to allow fast removal of elements.
        Do less inside LOCK_alarm mutex.
        This should give a major speed up of thr_alarm usage when there is many threads
      sql/create_options.cc:
        Fixed wrong printf
      sql/event_queue.cc:
        Use new queue interface()
      sql/filesort.cc:
        Use new queue interface()
      sql/ha_partition.cc:
        Use new queue interface()
      sql/ha_partition.h:
        Fixed compiler warning
      sql/item_cmpfunc.cc:
        Fixed compiler warning
      sql/item_subselect.cc:
        Use new queue interface()
        Removed not used variable
      sql/net_serv.cc:
        If USE_NET_CLEAR is not set, don't clear connection from unexpected characters.
        This should give a speed up when doing a lot of fast queries at the disadvantage that if there is a bug in the client protocol the connection will be dropped instead of being unnoticed.
      sql/opt_range.cc:
        Use new queue interface()
        Fixed compiler warnings
      sql/uniques.cc:
        Use new queue interface()
      storage/maria/ma_ft_boolean_search.c:
        Copy code from myisam/ft_boolean_search.c
        Use new queue interface()
      storage/maria/ma_ft_nlq_search.c:
        Use new queue interface()
      storage/maria/ma_sort.c:
        Use new queue interface()
      storage/maria/maria_pack.c:
        Use new queue interface()
        Use queue_fix() instead of own loop to fix queue.
      storage/myisam/ft_boolean_search.c:
        Use new queue interface()
      storage/myisam/ft_nlq_search.c:
        Use new queue interface()
      storage/myisam/mi_test_all.sh:
        Remove temporary file from last run
      storage/myisam/myisampack.c:
        Use new queue interface()
        Use queue_fix() instead of own loop to fix queue.
      storage/myisam/sort.c:
        Use new queue interface()
      storage/myisammrg/myrg_queue.c:
        Use new queue interface()
      storage/myisammrg/myrg_rnext.c:
        Use new queue interface()
      storage/myisammrg/myrg_rnext_same.c:
        Use new queue interface()
      storage/myisammrg/myrg_rprev.c:
        Use new queue interface()
      ecbcddc0
  28. 15 Jul, 2010 1 commit
  29. 10 Jul, 2010 1 commit
    • unknown's avatar
      Subquery cache (MWL#66) added. · ceb5468f
      unknown authored
      libmysqld/Makefile.am:
        The new file added.
      mysql-test/r/index_merge_myisam.result:
        subquery_cache optimization option added.
      mysql-test/r/myisam_mrr.result:
        subquery_cache optimization option added.
      mysql-test/r/subquery_cache.result:
        The subquery cache tests added.
      mysql-test/r/subselect3.result:
        Subquery cache switched off to avoid changing read statistics.
      mysql-test/r/subselect3_jcl6.result:
        Subquery cache switched off to avoid changing read statistics.
      mysql-test/r/subselect_no_mat.result:
        subquery_cache optimization option added.
      mysql-test/r/subselect_no_opts.result:
        subquery_cache optimization option added.
      mysql-test/r/subselect_no_semijoin.result:
        subquery_cache optimization option added.
      mysql-test/r/subselect_sj.result:
        subquery_cache optimization option added.
      mysql-test/r/subselect_sj_jcl6.result:
        subquery_cache optimization option added.
      mysql-test/t/subquery_cache.test:
        The subquery cache tests added.
      mysql-test/t/subselect3.test:
        Subquery cache switched off to avoid changing read statistics.
      sql/CMakeLists.txt:
        The new file added.
      sql/Makefile.am:
        The new files added.
      sql/item.cc:
        Expression cache item (Item_cache_wrapper) added.
        Item_ref and Item_field fixed for correct usage of result field and fast resolwing in SP.
      sql/item.h:
        Expression cache item (Item_cache_wrapper) added.
        Item_ref and Item_field fixed for correct usage of result field and fast resolwing in SP.
      sql/item_cmpfunc.cc:
        Subquery cache added.
      sql/item_cmpfunc.h:
        Subquery cache added.
      sql/item_subselect.cc:
        Subquery cache added.
      sql/item_subselect.h:
        Subquery cache added.
      sql/item_sum.cc:
        Registration of subquery parameters added.
      sql/mysql_priv.h:
        subquery_cache optimization option added.
      sql/mysqld.cc:
        subquery_cache optimization option added.
      sql/opt_range.cc:
        Fix due to subquery cache.
      sql/opt_subselect.cc:
        Parameters of the function cahnged.
      sql/procedure.h:
        .h file guard added.
      sql/sql_base.cc:
        Registration of subquery parameters added.
      sql/sql_class.cc:
        Option to allow add indeces to temporary table.
      sql/sql_class.h:
        Item iterators added.
        Option to allow add indeces to temporary table.
      sql/sql_expression_cache.cc:
        Expression cache for caching subqueries added.
      sql/sql_expression_cache.h:
        Expression cache for caching subqueries added.
      sql/sql_lex.cc:
        Registration of subquery parameters added.
      sql/sql_lex.h:
        Registration of subqueries and subquery parameters added.
      sql/sql_select.cc:
        Subquery cache added.
      sql/sql_select.h:
        Subquery cache added.
      sql/sql_union.cc:
        A new parameter to the function added.
      sql/sql_update.cc:
        A new parameter to the function added.
      sql/table.cc:
        Procedures to manage temporarty tables index added.
      sql/table.h:
        Procedures to manage temporarty tables index added.
      storage/maria/ha_maria.cc:
        Fix of handler to allow destoy a table in case of error during the table creation.
      storage/maria/ha_maria.h:
        .h file guard added.
      storage/myisam/ha_myisam.cc:
        Fix of handler to allow destoy a table in case of error during the table creation.
      ceb5468f
  30. 06 Jul, 2010 1 commit
    • Sergey Petrunya's avatar
      Fix buildbot valgrind failure · e5f238a0
      Sergey Petrunya authored
      - Item_in_subselect::init_left_expr_cache() should not try to 
        guess whether the left expression is accessed "over the grouping operation"
        (i.e. the subselect is evaluated after the grouping while the left_expr is
         an Item_ref that wraps an expression from before the grouping). Instead, 
        let new_Cached_item not to try accessing item->real_item() when creating 
        left expr cache.
      e5f238a0
  31. 10 Jun, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#42733: Type-punning warnings when compiling MySQL -- · 0f9ddfa9
      Davi Arnaut authored
                  strict aliasing violations.
      
      One somewhat major source of strict-aliasing violations and
      related warnings is the SQL_LIST structure. For example,
      consider its member function `link_in_list` which takes
      a pointer to pointer of type T (any type) as a pointer to
      pointer to unsigned char. Dereferencing this pointer, which
      is done to reset the next field, violates strict-aliasing
      rules and might cause problems for surrounding code that
      uses the next field of the object being added to the list.
      
      The solution is to use templates to parametrize the SQL_LIST
      structure in order to deference the pointers with compatible
      types. As a side bonus, it becomes possible to remove quite
      a few casts related to acessing data members of SQL_LIST.
      
      sql/handler.h:
        Use the appropriate template type argument.
      sql/item.cc:
        Remove now-unnecessary cast.
      sql/item_subselect.cc:
        Remove now-unnecessary casts.
      sql/item_sum.cc:
        Use the appropriate template type argument.
        Remove now-unnecessary cast.
      sql/mysql_priv.h:
        Move SQL_LIST structure to sql_list.h
        Use the appropriate template type argument.
      sql/sp.cc:
        Remove now-unnecessary casts.
      sql/sql_delete.cc:
        Use the appropriate template type argument.
        Remove now-unnecessary casts.
      sql/sql_derived.cc:
        Remove now-unnecessary casts.
      sql/sql_lex.cc:
        Remove now-unnecessary casts.
      sql/sql_lex.h:
        SQL_LIST now takes a template type argument which must
        match the type of the elements of the list. Use forward
        declaration when the type is not available, it is used
        in pointers anyway.
      sql/sql_list.h:
        Rename SQL_LIST to SQL_I_List. The template parameter is
        the type of object that is stored in the list.
      sql/sql_olap.cc:
        Remove now-unnecessary casts.
      sql/sql_parse.cc:
        Remove now-unnecessary casts.
      sql/sql_prepare.cc:
        Remove now-unnecessary casts.
      sql/sql_select.cc:
        Remove now-unnecessary casts.
      sql/sql_show.cc:
        Remove now-unnecessary casts.
      sql/sql_table.cc:
        Remove now-unnecessary casts.
      sql/sql_trigger.cc:
        Remove now-unnecessary casts.
      sql/sql_union.cc:
        Remove now-unnecessary casts.
      sql/sql_update.cc:
        Remove now-unnecessary casts.
      sql/sql_view.cc:
        Remove now-unnecessary casts.
      sql/sql_yacc.yy:
        Remove now-unnecessary casts.
      storage/myisammrg/ha_myisammrg.cc:
        Remove now-unnecessary casts.
      0f9ddfa9
  32. 06 Apr, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#52120 create view cause Assertion failed: 0, file .\item_subselect.cc, line 817 · ba229d79
      Sergey Glukhov authored
      We should disable const subselect item evaluation because
      subselect transformation does not happen in view_prepare_mode
      and thus val_...() methods can not be called.
      
      
      mysql-test/r/ctype_ucs.result:
        test case
      mysql-test/r/view.result:
        test case
      mysql-test/t/ctype_ucs.test:
        test case
      mysql-test/t/view.test:
        test case
      sql/item.cc:
        disabled const subselect item evaluation in
        view prepare mode.
      sql/item_subselect.cc:
        added Item_subselect::safe_charset_converter which
        prevents const item evaluation in view prepare mode.
      sql/item_subselect.h:
        added Item_subselect::safe_charset_converter which
        prevents const item evaluation in view prepare mode.
      ba229d79
  33. 29 Mar, 2010 1 commit
  34. 09 Mar, 2010 2 commits
    • unknown's avatar
      Fix a buildbot memory leak due to JOIN::destroy() not being called for EXPLAIN · 0230d51b
      unknown authored
      query:
      - When subquery is located in ORDER BY, EXPLAIN will run as follows:
        select_describe() will run JOIN::prepare()/optimize() for the subquery;
        then at some point subselect_single_select_engine::prepare() will be called,
        which will create another join and run join->prepare().
      
        In mainline mysql this is not a problem because subquery's join will be 
        destroyed after the first call. 
        In MariaDB, it won't (table elimination needs to keep JOIN objects around
        for longer in order to know which tables were eliminated when constructing
        EXPLAIN EXTENDED warning).
      
        Fix the problem of memory leak by calling select_lex->cleanup() in 
        subselect_single_select_engine::prepare().
      0230d51b
    • unknown's avatar
      A number of after-merge fixes following merge of MySQL 5.1.44 into MariaDB. · c9dffa99
      unknown authored
      Bug#46949: memory leak with failed alter table to create partitions based on extract()
      
      Bug#51830: Incorrect partition pruning on range partition (regression)
      
      Fixed valgrind failure in select_describe(), read of uninitialized 
        Item_subselect::eliminated.
      
      PBXT test file updates to reflect changes done in MySQL.
      
      mysql-test/suite/pbxt/r/partition_error.result:
        Result file update following MySQL 5.1.44 changes.
      mysql-test/suite/pbxt/r/partition_pruning.result:
        Result file update following MySQL 5.1.44 changes.
      mysql-test/suite/pbxt/t/partition_error.test:
        Test file update following MySQL 5.1.44 changes.
      sql/item_subselect.cc:
          Fixed valgrind failure in select_describe(), read of uninitialized 
          Item_subselect::eliminated: 
          - it turns out we can call select_describe() without having fixed 
            subquery items for child subselects. These are not the kind of subqueries
            that we could eliminate, so the fix is to ensure that 
            item_subselect->eliminated==FALSE even before fix_fields is called.
            Also added code to reset item_subselect->eliminated back to FALSE in
            Item::reset() call.
      sql/item_subselect.h:
          Fixed valgrind failure in select_describe(), read of uninitialized 
          Item_subselect::eliminated: 
          - it turns out we can call select_describe() without having fixed 
            subquery items for child subselects. These are not the kind of subqueries
            that we could eliminate, so the fix is to ensure that 
            item_subselect->eliminated==FALSE even before fix_fields is called.
            Also added code to reset item_subselect->eliminated back to FALSE in
            Item::reset() call.
      sql/sql_partition.cc:
        Fix Bug#51830: Revert part of the patch for Bug#49742, which caused the regression.
      sql/table.cc:
        Fix Bug#46949: memory leak in failed ALTER TABLE with partitioning.
      c9dffa99