An error occurred fetching the project authors.
  1. 09 Oct, 2007 1 commit
    • unknown's avatar
      Fix for bug #31249: Assertion `!table || (!table->write_set || · 1a5f13a1
      unknown authored
      bitmap_is_set(table->write_set, fiel
      
      Problem: creating a temporary table we allocate the group buffer if needed
      followed by table bitmaps (see create_tmp_table()). Reserving less memory for 
      the group buffer than actually needed (used) for values retrieval may lead 
      to overlapping with followed bitmaps in the memory pool that in turn leads 
      to unpredictable consequences.
      
      As we use Item->max_length sometimes to calculate group buffer size,
      it must be set to proper value. In this particular case 
      Item_datetime_typecast::max_length is too small.
      
      Another problem is that we use max_length to calculate the group buffer
      key length for items represented as DATE/TIME fields which is superfluous.
      
      Fix: set Item_datetime_typecast::max_length properly,
      accurately calculate the group buffer key length for items 
      represented as DATE/TIME fields in the buffer.
      
      
      mysql-test/r/type_datetime.result:
        Fix for bug #31249: Assertion `!table || (!table->write_set || 
        bitmap_is_set(table->write_set, fiel
          - test result.
      mysql-test/t/type_datetime.test:
        Fix for bug #31249: Assertion `!table || (!table->write_set || 
        bitmap_is_set(table->write_set, fiel
          - test case.
      sql/item_timefunc.h:
        Fix for bug #31249: Assertion `!table || (!table->write_set || 
        bitmap_is_set(table->write_set, fiel
          - set Item_datetime_typecast::max_length properly.
      sql/sql_select.cc:
        Fix for bug #31249: Assertion `!table || (!table->write_set || 
        bitmap_is_set(table->write_set, fiel
          - the group buffer key length for items represented as 
        DATE/TIME fields in the buffer should be calculated using
        the maximum pack length of such fields (== 8), using 
        max_length here is redundant.
      1a5f13a1
  2. 14 Sep, 2007 1 commit
    • unknown's avatar
      Bug #31001: ORDER BY DESC in InnoDB not working · ad496be0
      unknown authored
      The optimizer sets index traversal in reverse order only if there are 
       used key parts that are not compared to a constant.
      However using the primary key as an ORDER BY suffix rendered the check
      incomplete : going in reverse order must still be used even if 
      all the parts of the secondary key are compared to a constant.
      
      Fixed by relaxing the check and set reverse traversal even when all
      the secondary index keyparts are compared to a const.
      Also account for the case when all the primary keys are compared to a
      constant.
      
      
      mysql-test/r/innodb_mysql.result:
        Bug #31001: test case
      mysql-test/t/innodb_mysql.test:
        Bug #31001: test case
      sql/sql_select.cc:
        Bug #31001: 
         - account for the case when all the primary key parts are compared
           to a constant
         - force test_if_skip_sort_order to go backwards over the key even 
           when the number of keyparts used is the same as the number of 
           keyparts equal to a constant. (because of the primary key 
           suffix).
      ad496be0
  3. 28 Aug, 2007 1 commit
    • unknown's avatar
      Bug #30377: EXPLAIN loses last_query_cost when used with UNION · 310afbd4
      unknown authored
      Currently the Last_query_cost session status variable shows
      only the cost of a single flat subselect. For complex queries
      (with subselects or unions etc) Last_query_cost is not valid
      as it was showing the cost for the last optimized subselect.
      Fixed by reseting to zero Last_query_cost when the complete
      cost of the query cannot be determined.
      Last_query_cost will be non-zero only for single flat queries.
      
      
      mysql-test/r/status.result:
        Bug #30377: test case
      mysql-test/t/status.test:
        Bug #30377: test case
      sql/sql_lex.h:
        Bug #30377: helper function
      sql/sql_select.cc:
        Bug #30377: don't assign cost if not on single level statement
      310afbd4
  4. 27 Aug, 2007 1 commit
    • unknown's avatar
      Bug #30596 GROUP BY optimization gives wrong result order · 23686646
      unknown authored
      The optimization that uses a unique index to remove GROUP BY, did not 
      ensure that the index was actually used, thus violating the ORDER BY
      that is impled by GROUP BY.
      Fixed by replacing GROUP BY with ORDER BY if the GROUP BY clause contains
      a unique index. In case GROUP BY ... ORDER BY null is used, GROUP BY is
      simply removed.
      
      
      BitKeeper/etc/ignore:
        Added support-files/mysqld_multi.server tests/bug25714 cscope.in.out cscope.out cscope.po.out to the ignore list
      mysql-test/r/distinct.result:
        Bug#30596: Changed test case. 
        Prior to Bug#16458, These queries use temp table and filesort. The
        bug was that they used a temp table. However, that patch removed
        filesort also, in which case we can no longer gurantee correct ordering.
      mysql-test/r/group_by.result:
        Bug#30596: Correct result
      mysql-test/r/innodb_mysql.result:
        Bug#30596: Test case for innodb. Here, as opposed to for MyISAM, row 
        lookup is done using index whenever the index covers the group list.
      mysql-test/t/group_by.test:
        Bug#30596: Test case
      mysql-test/t/innodb_mysql.test:
        Bug#30596: Test case
      sql/sql_select.cc:
        Bug#30596: The fix, replacing GROUP BY with ORDER BY unless 
        ORDER BY [NULL|<constant>]
      23686646
  5. 25 Aug, 2007 1 commit
    • unknown's avatar
      sql_select.cc: · 5b03876f
      unknown authored
        Additional fix for the bug#30245.
      
      
      sql/sql_select.cc:
        Additional fix for the bug#30245.
      5b03876f
  6. 20 Aug, 2007 1 commit
    • unknown's avatar
      Fixed bug #30287. · 7c3d5bc5
      unknown authored
      The server created temporary tables for filesort in the working directory
      instead of the specified tmpdir directory.
      
      
      sql/item.cc:
        Fixed bug #30287.
        The Item_field::set_field method has been modified to reset the any_privileges
        flag to false in case of system temporary table. This modification prevents the
        server from unnecessary checking of user privileges to access system temporary
        tables.
      sql/sql_select.cc:
        Fixed bug #30287.
        Bugfix for #29015 has been removed: TABLE_SHARE::table_name of system
        temporary tables contains full path to table file basename again.
      sql/sql_view.cc:
        Fixed bug #30287.
        Commentary has been added.
      7c3d5bc5
  7. 17 Aug, 2007 1 commit
    • unknown's avatar
      Bug#30245: A wrong type of a BIT field is reported when grouped by it. · d280a06e
      unknown authored
      HEAP tables can't index BIT fields. Due to this when grouping by such fields is
      needed they are converted to a fields of the LONG type when temporary table
      is being created. But a side effect of this is that a wrong type of BIT
      fields is returned to a client.
      
      Now the JOIN::prepare and the create_distinct_group functions are create
      additional hidden copy of BIT fields to preserve original fields untouched.
      New hidden fields are used for grouping instead.
      
      
      mysql-test/t/type_bit.test:
        Added a test case for the bug#30245: A wrong type of a BIT field is reported when grouped by it.
      mysql-test/r/type_bit.result:
        Added a test case for the bug#30245: A wrong type of a BIT field is reported when grouped by it.
      sql/sql_select.cc:
        Bug#30245: A wrong type of a BIT field is reported when grouped by it.
        Now the JOIN::prepare and the create_distinct_group functions are create
        additional hidden copy of BIT fields to preserve original fields untouched.
        New hidden fields are used for grouping instead.
      d280a06e
  8. 15 Aug, 2007 1 commit
    • unknown's avatar
      Fixed bug #30396. · a8f8e548
      unknown authored
      The bug caused memory corruption for some queries with top OR level
      in the WHERE condition if they contained equality predicates and 
      other sargable predicates in disjunctive parts of the condition.
      
      The corruption happened because the upper bound of the memory
      allocated for KEY_FIELD and SARGABLE_PARAM internal structures
      containing info about potential lookup keys was calculated incorrectly
      in some cases. In particular it was calculated incorrectly when the
      WHERE condition was an OR formula with disjuncts being AND formulas
      including equalities and other sargable predicates.
      
      
      mysql-test/r/select.result:
        Added a test case for bug #30396.
      mysql-test/t/select.test:
        Added a test case for bug #30396.
      sql/item_cmpfunc.h:
        Removed max_members from the COND_EQUAL class as not useful anymore.
      sql/sql_base.cc:
        Added the max_equal_elems field to the st_select_lex structure.
      sql/sql_lex.cc:
        Added the max_equal_elems field to the st_select_lex structure.
      sql/sql_lex.h:
        Added the max_equal_elems field to the st_select_lex structure.
        The field contains the maximal number of elements in multiple equalities
        built for the query conditions.
      sql/sql_select.cc:
        Fixed bug #30396.
        The bug caused memory corruption for some queries with top OR level
        in the WHERE condition if they contained equality predicates and 
        other sargable predicates in disjunctive parts of the condition.
        
        The corruption happened because the upper bound of the memory
        allocated for KEY_FIELD and SARGABLE_PARAM internal structures
        containing info about potential lookup keys was calculated incorrectly
        in some cases. In particular it was calculated incorrectly when the
        WHERE condition was an OR formula with disjuncts being AND formulas
        including equalities and other sargable predicates.
         
        The max_equal_elems field to the st_select_lex structure is used now
        to calculate the above mentioned upper bound. The field contains the
        maximal number of elements in multiple equalities built for the query
        conditions.
      a8f8e548
  9. 31 Jul, 2007 2 commits
    • unknown's avatar
      BUG#29582: huge memory consumption with union, subselect, joins: · 8a68e7d2
      unknown authored
      - Don't call mysql_select() several times for the select that enumerates
        a temporary table with the results of the UNION. Making this call for
        every subquery execution caused O(#enumerated-rows-in-the-outer-query) 
        memory allocations.
      - Instead, call join->reinit() and join->exec(), and
        = disable constant table detection for such joins,  
        = provide special handling for table-less constant subqueries.
      
      
      sql/sql_select.cc:
        BUG#29582: huge memory consumption with union, subselect, joins:
         - Don't mark tables as constant if JOIN::no_const_tables flag is set
      sql/sql_select.h:
        BUG#29582: huge memory consumption with union, subselect, joins:
         - Don't mark tables as constant if JOIN::no_const_tables flag is set
      sql/sql_union.cc:
        BUG#29582: huge memory consumption with union, subselect, joins:
        - Don't call mysql_select() several times for the select that enumerates
          a temporary table with UNION results. 
        - Instead, call join->reinit() and join->exec().
        - Provide special handling for table-less constant subqueries.
      8a68e7d2
    • unknown's avatar
      Bug #29717 INSERT INTO SELECT inserts values even if · 791584ae
      unknown authored
       SELECT statement itself returns empty.
      
      As a result of this bug 'SELECT AGGREGATE_FUNCTION(fld) ... GROUP BY'
      can return one row instead of an empty result set.
      
      When GROUP BY only has fields of constant tables
      (with a single row), the optimizer deletes the group_list.
      After that we lose the information about whether we had an
      GROUP BY statement. Though it's important
      as SELECT min(x) from empty_table; and
         SELECT min(x) from empty_table GROUP BY y; have to return
      different results - the first query should return one row,
      second - an empty result set.
      So here we add the 'group_optimized_away' flag to remember this case
      when GROUP BY exists in the query and is removed
      by the optimizer, and check this flag in end_send_group()
      
      
      mysql-test/r/group_by.result:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        test result
      mysql-test/r/insert_select.result:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        test result
      mysql-test/t/group_by.test:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        This is additional testcase that is more basic than the
        original bug's testcase and has the same reason.
      mysql-test/t/insert_select.test:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        test case
      sql/sql_select.cc:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        Remember the 'GROUP BY was optimized away' case in the JOIN::group_optimized
        and check this in the end_send_group()
      sql/sql_select.h:
        Bug #29717 INSERT INTO SELECT inserts values even if
         SELECT statement itself returns empty.
        
        JOIN::group_optimized member added to remember the 'GROUP BY optimied away'
        case
      791584ae
  10. 27 Jul, 2007 1 commit
    • unknown's avatar
      Bug #29419 "Specifying a join_buffer > 4GB on 64 bit machines not possible." · 575fea4a
      unknown authored
      Use size_t instead of uint when calculating join buffer size, because uint can be overflown on 64-bit platforms and join_buffer_size > 4 GB.
      
      The test case for this bug is a part of the test suite for bug #5731.
      
      
      sql/sql_select.cc:
        Use size_t instead of uint when calculating join buffer size, because uint can be overflown on 64-bit platforms and join_buffer_size > 4G.
      575fea4a
  11. 26 Jul, 2007 1 commit
    • unknown's avatar
      BUG#28591: make the fix work for BDB tables too: · 9206f684
      unknown authored
       - make ha_berkeley::cmp_ref() take into account that auto-generated PKs 
         are stored in LSB-first order. 
       - Remove the temporary code that made the bugfix work for innodb only 
      
      
      mysql-test/r/bdb.result:
        Adjust test-results.
      sql/ha_berkeley.cc:
        BUG#28591: make the fix work for BDB tables too:
         - make ha_berkeley::cmp_ref() take into account that auto-generated PKs 
           are stored in LSB-first order.
      sql/sql_select.cc:
        BUG#28591: Remove "innodb only" clause as the fix now works for BDB too
      sql/table.cc:
        BUG#28591: Remove "innodb only" clause as the fix now works for BDB too
      9206f684
  12. 23 Jul, 2007 1 commit
    • unknown's avatar
      table.cc, sql_select.cc: · c38fa3f3
      unknown authored
        Limit the fix for bug 28591 to InnoDB only
      
      
      sql/sql_select.cc:
        Limit the fix for bug 28591 to InnoDB only
      sql/table.cc:
        Limit the fix for bug 28591 to InnoDB only
      c38fa3f3
  13. 21 Jul, 2007 1 commit
    • unknown's avatar
      Fixed bug #29911. · 72c6c789
      unknown authored
      This bug manifested itself for join queries with GROUP BY and HAVING clauses
      whose SELECT lists contained DISTINCT. It occurred when the optimizer could
      deduce that the result set would have not more than one row.
      The bug could lead to wrong result sets for queries of this type because
      HAVING conditions were erroneously ignored in some cases in the function
      remove_duplicates.   
      
      
      mysql-test/r/having.result:
        Added a test case for bug #29911.
      mysql-test/t/having.test:
        Added a test case for bug #29911.
      72c6c789
  14. 20 Jul, 2007 1 commit
    • unknown's avatar
      Bug #28591: MySQL need not sort the records in case of · 95a8c6c3
      unknown authored
      ORDER BY primary_key on InnoDB table
      
      Queries that use an InnoDB secondary index to retrieve
      data don't need to sort in case of ORDER BY primary key
      if the secondary index is compared to constant(s).
      They can also skip sorting if ORDER BY contains both the
      the secondary key parts and the primary key parts (in
      that order).
      This is because InnoDB returns the rows in order of the
      primary key for rows with the same values of the secondary
      key columns.
      Fixed by preventing temp table sort for the qualifying 
      queries.
      
      
      mysql-test/r/innodb_mysql.result:
        Bug #28591: test case
      mysql-test/t/innodb_mysql.test:
        Bug #28591: test case
      sql/sql_select.cc:
        Bug #28591: Use the primary key as suffix when testing
        if the key can be used for ORDER BY on supporting engines.
      sql/table.cc:
        Bug #28591: can use the primary key
        as a suffix for the secondary keys
      95a8c6c3
  15. 12 Jul, 2007 1 commit
    • unknown's avatar
      Fixed bug #29604. · b1e55680
      unknown authored
      A bug in the restore_prev_nj_state function allowed interleaving 
      inner tables of outer join operations with outer tables. With the
      current implementation of the nested loops algorithm it could lead
      to wrong result sets for queries with nested outer joins.
      Another bug in this procedure effectively blocked evaluation of some
      valid execution plans for queries with nested outer joins. 
      
      
      mysql-test/r/join_nested.result:
        Added a test case for bug #29604.
      mysql-test/t/join_nested.test:
        Added a test case for bug #29604.
      b1e55680
  16. 06 Jul, 2007 1 commit
    • unknown's avatar
      Remove typedef st_table_list TABLE_LIST and always use name 'TABLE_LIST'. · 360a5ebc
      unknown authored
      The need arose when working on Bug 26141, where it became
      necessary to replace TABLE_LIST with its forward declaration in a few
      headers, and this involved a lot of s/TABLE_LIST/st_table_list/.
      Although other workarounds exist, this patch is in line
      with our general strategy of moving away from typedef-ed names.
      Sometime in future we might also rename TABLE_LIST to follow the
      coding style, but this is a huge change.
      
      
      sql/item.cc:
        st_table_list -> TABLE_LIST
      sql/item.h:
        st_table_list -> TABLE_LIST
      sql/mysql_priv.h:
        st_table_list -> TABLE_LIST
      sql/sql_base.cc:
        st_table_list -> TABLE_LIST
      sql/sql_lex.cc:
        st_table_list -> TABLE_LIST
      sql/sql_lex.h:
        st_table_list -> TABLE_LIST
      sql/sql_select.cc:
        st_table_list -> TABLE_LIST
      sql/sql_show.cc:
        st_table_list -> TABLE_LIST
      sql/sql_udf.h:
        Was not needed.
      sql/table.cc:
        st_table_list -> TABLE_LIST
      sql/table.h:
        st_table_list -> TABLE_LIST
      360a5ebc
  17. 29 Jun, 2007 1 commit
    • unknown's avatar
      Bug#27333: subquery grouped for aggregate of outer · c2e961cf
      unknown authored
      query / no aggregate of subquery
       The optimizer counts the aggregate functions that 
       appear as top level expressions (in all_fields) in 
       the current subquery. Later it makes a list of these
       that it uses to actually execute the aggregates in
       end_send_group().
       That count is used in several places as a flag whether
       there are aggregates functions.
       While collecting the above info it must not consider
       aggregates that are not aggregated in the current 
       context. It must treat them as normal expressions 
       instead. Not doing that leads to incorrect data about
       the query, e.g. running a query that actually has no
       aggregate functions as if it has some (and hence is
       expected to return only one row).
       Fixed by ignoring the aggregates that are not aggregated
       in the current context. 
       One other smaller omission discovered and fixed in the 
       process : the place of aggregation was not calculated for
       user defined functions. Fixed by calling 
       Item_sum::init_sum_func_check() and 
       Item_sum::check_sum_func() as it's done for the rest of 
       the aggregate functions.
      
      
      mysql-test/r/subselect.result:
        Bug #27333: test case
      mysql-test/t/subselect.test:
        Bug #27333: test case
      sql/item_subselect.cc:
        Bug#27333: need select_lex to filter out
         aggregates that are not aggregated in
         the current select.
      sql/item_sum.cc:
        Bug#27333: need select_lex to filter out
         aggregates that are not aggregated in
         the current select.
      sql/item_sum.h:
        Bug#27333: calculate the place of 
         aggregation for user defined functions.
      sql/sql_select.cc:
        Bug#27333: When counting the aggregated functions
         and collecting a list of them we must not consider
         the aggregates that are not aggregated in the local
         context as "local" : i.e. we must treat them as 
         normal functions and not add them to the aggregate
         functions list.
      sql/sql_select.h:
        Bug#27333: need select_lex to filter out
         aggregates that are not aggregated in
         the current select.
      c2e961cf
  18. 24 Jun, 2007 1 commit
    • unknown's avatar
      Fixed bug #25602. A query with DISTINCT in the select list to which · e009b764
      unknown authored
      the loose scan optimization for grouping queries was applied returned 
      a wrong result set when the query was used with the SQL_BIG_RESULT
      option.
      
      The SQL_BIG_RESULT option forces to use sorting algorithm for grouping
      queries instead of employing a suitable index. The current loose scan
      optimization is applied only for one table queries when the suitable
      index is covering. It does not make sense to use sort algorithm in this
      case. However the create_sort_index function does not take into account
      the possible choice of the loose scan to implement the DISTINCT operator
      which makes sorting unnecessary. Moreover the current implementation of
      the loose scan for queries with distinct assumes that sorting will
      never happen. Thus in this case create_sort_index should not call
      the function filesort.
      
      
      mysql-test/r/group_min_max.result:
        Added a test case for bug #25602.
      mysql-test/t/group_min_max.test:
        Added a test case for bug #25602.
      e009b764
  19. 23 Jun, 2007 1 commit
    • unknown's avatar
      Fixed bug #29095. · 1bab1ddc
      unknown authored
      INSERT into table from SELECT from the same table
      with ORDER BY and LIMIT was inserting other data
      than sole SELECT ... ORDER BY ... LIMIT returns.
      
      One part of the patch for bug #9676 improperly pushed
      LIMIT to temporary table in the presence of the ORDER BY
      clause.
      That part has been removed.
      
      
      sql/sql_select.cc:
        Fixed bug #29095.
        One part of the patch for bug #9676 improperly pushed
        LIMIT to temporary table in the presence of the ORDER BY
        clause.
        That part has been removed.
      mysql-test/t/insert_select.test:
        Expanded the test case for bug #9676.
        Created a test case for bug #29095.
      mysql-test/r/insert_select.result:
        Expanded the test case for bug #9676.
        Created a test case for bug #29095.
      1bab1ddc
  20. 20 Jun, 2007 1 commit
    • unknown's avatar
      Fixed bug #28898. · e855bf33
      unknown authored
      For a join query with GROUP BY and/or ORDER BY and a view reference
      in the FROM list the metadata erroneously showed empty table aliases
      and database names for the view columns.
      
      
      
      sql/item.h:
        Fixed bug #28898.
        Body of Item_ref::get_tmp_table_item method has been moved
        to item.cc file.
      mysql-test/t/metadata.test:
        Updated test case for bug #28898.
      sql/item.cc:
        Fixed bug #28898.
        The Item_ref::get_tmp_table_item method has been modified
        to copy pointers to the table alias and database name to the new
        Item_field object created for a field stored in the temporary
        table.
      mysql-test/r/metadata.result:
        Updated test case for bug #28898.
      sql/sql_select.cc:
        Fixed bug #28898.
        The change_to_use_tmp_fields function has been modified to
        to copy pointers to the table alias and database name from
        the Item_ref objects to the new Item_field objects created
        for fields stored in the temporary table.
      e855bf33
  21. 18 Jun, 2007 1 commit
    • unknown's avatar
      Bug#28677: SELECT on missing column gives extra error · 3d31e3d6
      unknown authored
      The method select_insert::send_error does two things, it rolls back a statement
      being executed and outputs an error message. But when a 
      nonexistent column is referenced, an error message has been published already and
      there is no need to publish another.
      Fixed by moving all functionality beyond publishing an error message into 
      select_insert::abort() and calling only that function.
      
      
      mysql-test/r/errors.result:
        Bug#28677: test result
      mysql-test/t/errors.test:
        Bug#28677: test case
      sql/sql_class.h:
        Bug#28677: overriding abort()
      sql/sql_insert.cc:
        Bug#28677: 
        - moved everything beyond producing an error message out of select_insert::send_error 
        and into new override select_insert::abort() 
        - made corresponding move of code from select_create::send_error to select_create::abort
      sql/sql_select.cc:
        Bug#28677: No need to pusblish an error here
      3d31e3d6
  22. 11 Jun, 2007 1 commit
    • unknown's avatar
      Fix for bug #29015 "Stack overflow in processing temporary table name when tmpdir path is long" · 1c4ab310
      unknown authored
      In create_tmp_table() don't set full table path as a table name. Other code assumes table names to not exceed NAME_LEN bytes.
      
      
      sql/sql_select.cc:
        In create_tmp_table() don't set full table path as a table name. Other code assumes table names to not exceed NAME_LEN bytes.
      mysql-test/r/long_tmpdir.result:
        Added testcase for bug #29015 "Stack overflow in processing temporary table name when tmpdir path is long"
      mysql-test/t/long_tmpdir-master.opt:
        Added testcase for bug #29015 "Stack overflow in processing temporary table name when tmpdir path is long"
      mysql-test/t/long_tmpdir-master.sh:
        Added testcase for bug #29015 "Stack overflow in processing temporary table name when tmpdir path is long"
      mysql-test/t/long_tmpdir.test:
        Added testcase for bug #29015 "Stack overflow in processing temporary table name when tmpdir path is long"
      1c4ab310
  23. 07 Jun, 2007 1 commit
    • unknown's avatar
      Fixed bug #28449: a crash may happen at some rare conditions when · 89d96dd4
      unknown authored
      a temporary table has grown out of heap memory reserved for it and 
      the remaining disk space is not big enough to store the table as
      a MyISAM table.
      
      The crash happens because the function create_myisam_from_heap
      does not handle safely the mem_root structure associated 
      with the converted table in the case when an error has occurred.
      
      
      sql/sql_select.cc:
        Fixed bug #28449: a crash may happen at some rare conditions when
        a temporary table has grown out of heap memory reserved for it and 
        the remaining disk space is not big enough to store the table as
        a MyISAM table.
        
        The crash happens because the function create_myisam_from_heap
        does not handle safely the mem_root structure associated 
        with the converted table in the case when an error has occurred.
        
        As it's hard to create a sitiation that would throw an error 
        a special code has been added that raises an error for a newly 
        created test called error_simulation.
      mysql-test/r/error_simulation.result:
        New BitKeeper file ``mysql-test/r/error_simulation.result''
        
        Added a test case for bug #28449.
      mysql-test/t/error_simulation-master.opt:
        New BitKeeper file ``mysql-test/t/error_simulation-master.opt''
      mysql-test/t/error_simulation.test:
        New BitKeeper file ``mysql-test/t/error_simulation.test''
        
        Added a test case for bug #28449.
      89d96dd4
  24. 02 Jun, 2007 1 commit
    • unknown's avatar
      Fixed bug #28728: a crash when executing EXPLAIN EXTENDED for a query · 8c4ff24b
      unknown authored
      using a derived table over a grouping subselect.
      
      This crash happens only when materialization of the derived tables 
      requires creation of auxiliary temporary table, for example when
      a grouping operation is carried out with usage of a temporary table.
      
      The crash happened because EXPLAIN EXTENDED when printing the query
      expression made an attempt to use the objects created in the mem_root
      of the temporary table which has been already freed by the moment
      when printing is called.
      
      This bug appeared after the method Item_field::print() had been 
      introduced.    
      
      
      mysql-test/r/subselect.result:
        Added a test case for bug #28728.
      mysql-test/t/subselect.test:
        Added a test case for bug #28728.
      sql/sql_select.cc:
        Fixed bug #28728: a crash when executing EXPLAIN EXTENDED for a query
        using a derived table over a grouping subselect.
        The crash happened because EXPLAIN EXTENDED when printing the query
        expression made an attempt to use the objects created in the mem_root
        of the temporary table which has been already freed by the moment
        when printing is accomplished.
        The fix in JOIN::exec() ensures using existing objects when printing 
        subselects for a derived tables by EXPLAIN EXTENDED.
      8c4ff24b
  25. 31 May, 2007 2 commits
    • unknown's avatar
      Fix for bug #27643 "query failed : 1114 (The table '' is full) · f18a10c6
      unknown authored
      Problem:
      
      HASH indexes on VARCHAR columns with binary collations did not ignore trailing spaces from strings before comparisons. This could result in duplicate records being successfully inserted into a MEMORY table with unique key constraints.
      
      As a direct consequence of the above, internal MEMORY tables used for GROUP BY calculation in testcases for bug #27643 contained duplicate rows which resulted in duplicate key errors when converting those temporary tables to MyISAM. Additionally, that error was incorrectly converted to the 'table is full' error.
      
      Solution:
      
      - ignore trailing spaces in VARCHAR fields with binary collations when calculating hashes.
      - return a proper error from create_myisam_from_heap() when conversion fails.
      
      
      mysql-test/r/ctype_ucs2_def.result:
        Added a testcase for bug #27643.
      mysql-test/r/heap_hash.result:
        Added a testcase for bug #27643.
      mysql-test/t/ctype_ucs2_def.test:
        Added a testcase for bug #27643.
      mysql-test/t/heap_hash.test:
        Added a testcase for bug #27643.
      sql/sql_select.cc:
        Return an appropriate error instead of 'table is full' when conversion from MEMORY to MyISAM fails.
      strings/ctype-bin.c:
        Added my_hash_sort_8bit_bin() which ignores trailing spaces when calculating hashes, and is now used for VARCHAR columns instead of my_hash_sort_bin().
      strings/ctype-mb.c:
        Ignore trailing spaces when calculating a string hash in my_hash_sort_mb_bin().
      strings/ctype-ucs2.c:
        Ignore trailing spaces when calculating a string hash in my_hash_sort_ucs2_bin().
      f18a10c6
    • unknown's avatar
      Fixed bug #28598. · ebedff77
      unknown authored
      mysqld crashed when a long-running explain query was killed from
      another connection.
      
      When the current thread caught a kill signal executing the function
      best_extension_by_limited_search it just silently returned to  
      the calling function greedy_search without initializing elements of
      the join->best_positions array.
      However, the greedy_search function ignored thd->killed status
      after a calls to the best_extension_by_limited_search function, and
      after several calls the greedy_search function used an uninitialized
      data from the join->best_positions[idx] to search position in the
      join->best_ref array. 
      That search failed, and greedy_search tried to call swap_variables
      function with NULL argument - that caused a crash.
      
      
      sql/sql_select.cc:
        Fixed bug #28598.
        choose_plan(), greedy_search(), best_extension_by_limited_search()
        and find_best() functions have been changed to return TRUE in case
        of fatal error.
      mysql-test/t/kill.test:
        Updated test case for bug #28598.
      mysql-test/r/kill.result:
        Updated test case for bug #28598.
      ebedff77
  26. 30 May, 2007 1 commit
    • unknown's avatar
      Bug #28492: subselect returns LONG in >5.0.24a and LONGLONG in <=5.0.24a · 4e9cef54
      unknown authored
      Integer values with 10 digits may or may not fit into an int column 
      (e.g. 2147483647 vs 6147483647).
      Thus when creating a temp table column for such an int we must
      use bigint instead.
      Fixed to use bigint.
      Also subsituted a "magic number" with a named constant.
      
      
      mysql-test/r/analyse.result:
        Bug #28492: Adjusted the results after having fixed the bug
      mysql-test/r/metadata.result:
        Bug #28492: test case
      mysql-test/r/olap.result:
        Bug #28492: Adjusted the results after having fixed the bug
      mysql-test/r/sp.result:
        Bug #28492: Adjusted the results after having fixed the bug
      mysql-test/r/view.result:
        Bug #28492: Adjusted the results after having fixed the bug
      mysql-test/t/metadata.test:
        Bug #28492: test case
      sql/field.h:
        Bug #28492: Replaced a magic number with a constant
      sql/sql_select.cc:
        Bug #28492: Treat integers with 10 and more digits as 
        bigint.
      4e9cef54
  27. 26 May, 2007 2 commits
    • unknown's avatar
      Avoided warnings on Windows. · 5f99cf96
      unknown authored
      5f99cf96
    • unknown's avatar
      Fixed bug #28571. Outer join queries with ON conditions over · 90484de3
      unknown authored
      constant outer tables did not return null complemented
      rows when conditions were evaluated to FALSE.
      Wrong results were returned because the conditions over constant
      outer tables, when being pushed down, were erroneously enclosed 
      into the guard function used for WHERE conditions.
      
      
      mysql-test/r/join_outer.result:
        Added a test case for bug #28571.
      mysql-test/t/join_outer.test:
        Added a test case for bug #28571.
      sql/sql_select.cc:
        Fixed bug #28571. Outer join queries with ON conditions over
        constant outer tables did not return null complemented
        rows when conditions were evaluated to FALSE.
        Wrong results were returned because the conditions over constant
        outer tables, when being pushed down, were erroneously enclosed 
        into the guard function used for WHERE conditions.
        The problem is fixed in the function make_join_select. Now the
        conditions over constant tables from ON expressions are pushed
        down after the conditions from WHERE has been pushed down.
      90484de3
  28. 24 May, 2007 1 commit
    • unknown's avatar
      Fixed bug #28561: assertion abort for update on multi-table view with · 48af05a8
      unknown authored
      CHECK OPTION and a subquery in WHERE condition.
      The abort was triggered by setting the value of join->tables for
      subqueries in the function JOIN::cleanup. This function was called
      after an invocation of the JOIN::join_free method for subqueries
      used in WHERE condition.
      
      
      mysql-test/r/view.result:
        Added a test case for bug #28561.
      mysql-test/t/view.test:
        Added a test case for bug #28561.
      sql/sql_select.cc:
        Fixed bug #28561: assertion abort for update on multi-table view with
        CHECK OPTION and a subquery in WHERE condition.
        The abort was triggered by setting the value of join->tables for
        subqueries in the function JOIN::cleanup. This function was called
        after an invocation of the JOIN::join_free method for subqueries
        used in WHERE condition.
        Setting the value of join->tables to for a subquery created serious
        problems for checking WHERE condition after update of the multi-table
        view as this check is performed in the do_select function right
        after a call of the JOIN::join_free method.
        In fact setting join->tables to 0 in JOIN::cleanup is not needed 
        anywhere in the current code.
      48af05a8
  29. 22 May, 2007 1 commit
    • unknown's avatar
      Bug #28476: force index on a disabled myisam index gives error 124 · 3332b801
      unknown authored
      When processing the USE/FORCE index hints
      the optimizer was not checking if the indexes 
      specified are enabled (see ALTER TABLE).
      Fixed by:
       Backporting the fix for bug 20604 to 5.0
      
      
      mysql-test/r/key.result:
        Test for BUG 20604.
        The important part of the test is the explain output that 
        tests what indexes are used.
      mysql-test/r/myisam.result:
        Bug #28476: test cases
      mysql-test/t/key.test:
        Bug 20604: 
        The minimal test case that reveals the bug. The optimizer for 
        aggregates relies on keys disabled with ALTER TABLE ... DISABLE KEYS
        not being in the set TABLE::keys_in_use_for_query.
        When the execution engine tries to use a disabled index, MyISAM
        returns an error.
      mysql-test/t/myisam.test:
        Bug #28476: test cases
      sql/sql_base.cc:
        Bug #28476: 
         - Ignore disabled indexes in USE/FORCE index
      sql/sql_select.cc:
        Bug 20604 : The intersection operation between table->s->keys_in_use 
        and table->keys_in_use_for_query is no longer necessary.
        We can trust that the latter is a subset of the former.
      sql/table.h:
        Bug 20604:
        Added comments to TABLE_SHARE::keys_in_use and
        TABLE::keys_in_use_for_query.
      3332b801
  30. 21 May, 2007 1 commit
  31. 15 May, 2007 1 commit
    • unknown's avatar
      Fixed bug #28272: crash that occurs when running an EXPLAIN command · 8762539d
      unknown authored
      for a query over an empty table right after its creation. 
      The crash is the result of an attempt made by JOIN::optimize to evaluate
      the WHERE condition when no records have been actually read.
      The added test case can reproduce the crash only with InnoDB tables and
      only with 5.0.x.
       
      
      
      mysql-test/r/innodb_mysql.result:
        Added a test case for bug #28272.
      mysql-test/t/innodb_mysql.test:
        Added a test case for bug #28272.
      sql/sql_select.cc:
        Fixed bug #28272: crash that occurs when running an EXPLAIN command
        for a query over an empty table right after its creation. 
        The crash is the result of an attempt made by JOIN::optimize to evaluate
        the WHERE condition when no records have been actually read.
        Such attempts could be observed only with EXPLAIN commands.
        Now at the optimization phase the WHERE condition is never evaluated if 
        there is no record previously read from the table.
      8762539d
  32. 10 May, 2007 1 commit
  33. 04 May, 2007 3 commits
    • unknown's avatar
      bug #27531: · 359b0e59
      unknown authored
       fixed coverage of out-of-mem errors
      
      
      359b0e59
    • unknown's avatar
      Bug #27531: the 4.1 fix. · 353b6f26
      unknown authored
      When checking for applicability of join cache
      we must disable its usage only if there is no
      temp table in use.
      When a temp table is used we can use join
      cache (and it will not make the result-set 
      unordered) to fill the temp table. The filesort() 
      operation is then applied to the data in the temp 
      table and hence is not affected by join cache
      usage.
      Fixed by narrowing the condition for disabling 
      join cache to exclude the case where temp table
      is used.
      
      
      mysql-test/r/join.result:
        Bug #27531: test case
      mysql-test/t/join.test:
        Bug #27531: test case
      sql/sql_select.cc:
        Bug #27531: 
        Disable join cache only if not using temp table
      353b6f26
    • unknown's avatar
      Bug #27807. · 0ad4e1b2
      unknown authored
      Non-correlated scalar subqueries may get executed
      in EXPLAIN at the optimization phase if they are
      part of a right hand sargable expression.
      If the scalar subquery uses a temp table to 
      materialize its results it will replace the 
      subquery structure from the parser with a simple
      select from the materialization table.
      As a result the EXPLAIN will crash as the 
      temporary materialization table is not to be shown
      in EXPLAIN at all.
      Fixed by preserving the original query structure
      right after calling optimize() for scalar subqueries
      with temp tables executed during EXPLAIN.
      
      
      mysql-test/r/subselect.result:
        Bug #27807: test case
      mysql-test/t/subselect.test:
        Bug #27807: test case
      sql/item_subselect.cc:
        Bug #27807: preserve the join structure
      sql/sql_select.cc:
        Bug #27807: introduce initialization function for tmp_join
      sql/sql_select.h:
        Bug #27807: introduce initialization function for tmp_join
      0ad4e1b2
  34. 02 May, 2007 1 commit
    • unknown's avatar
      Fixed bug #28188: performance degradation for outer join queries to which · 8e8ece72
      unknown authored
      'not exists' optimization is applied.
      
      In fact 'not exists' optimization did not work anymore after the patch
      introducing the evaluate_join_record function had been applied.
      
      Corrected the evaluate_join_record function to respect the 'not_exists'
      optimization.
      
      
      mysql-test/r/join_outer.result:
        Added a test case for bug #28188.
      mysql-test/t/join_outer.test:
        Added a test case for bug #28188.
      sql/sql_select.cc:
        Fixed bug #28188: performance degradation for outer join queries to which
        'not exists' optimization is applied.
        
        Corrected the evaluate_join_record function to respect the 'not_exists'
        optimization.
      8e8ece72
  35. 30 Apr, 2007 1 commit