An error occurred fetching the project authors.
  1. 01 Nov, 2011 1 commit
    • unknown's avatar
      Fix of LP BUG#872775. · b40bc2b3
      unknown authored
      The problem was that merged views has its own nest_level numbering =>
      when we compare nest levels we should take into considiration basis (i.e. 0 level),
      if it is different then nest levels are not comparable.
      b40bc2b3
  2. 19 Jul, 2011 1 commit
    • unknown's avatar
      Fixed LP BUG#800696. · 99cce189
      unknown authored
      The problem was that optimizer removes some outer references (it they are
      constant for example) and the list of outer items built during prepare phase is
      not actual during execution phase when we need it as the cache parameters.
      First solution was use pointer on pointer on outer reference Item and
      initialize temporary table on demand. This solved most problem except case
      when optimiser also reduce Item which contains outer references ('OR' in
      this bug test suite).
      
      The solution is to build the list of outer reference items on execution
      phase (after optimization) on demand (just before temporary table creation)
      by walking Item tree and finding outer references among Item_ident
      (Item_field/Item_ref) and Item_sum items.
      
      Removed depends_on list (because it is not neede any mnore for the cache, in the place where it was used it replaced with upper_refs).
      
      Added processor (collect_outer_ref_processor) and get_cache_parameters() methods to collect outer references (or other expression parameters in future).
      
      mysql-test/r/subselect_cache.result:
        A new test added.
      mysql-test/r/subselect_scache.result:
        Changes in creating the cache and its paremeters order or adding arguments of aggregate function (which is a parameter also, but this has no influence on the result).
      mysql-test/t/subselect_cache.test:
        Added a new test.
      sql/item.cc:
        depends_on removed.
        
        Added processor (collect_outer_ref_processor) and get_cache_parameters() methods to collect outer references.
        
        Item_cache_wrapper collect parameters befor initialization of its cache.
      sql/item.h:
        depends_on removed.
        
        Added processor (collect_outer_ref_processor) and get_cache_parameters() methods to collect outer references.
      sql/item_cmpfunc.cc:
        depends_on removed.
        
        Added processor (collect_outer_ref_processor) to collect outer references.
      sql/item_cmpfunc.h:
        Added processor (collect_outer_ref_processor) to collect outer references.
      sql/item_subselect.cc:
        depends_on removed.
        Added processor get_cache_parameters() method to collect outer references.
      sql/item_subselect.h:
        depends_on removed.
        Added processor get_cache_parameters() method to collect outer references.
      sql/item_sum.cc:
        Added processor (collect_outer_ref_processor) method to collect outer references.
      sql/item_sum.h:
        Added processor (collect_outer_ref_processor) and get_cache_parameters() methods to collect outer references.
      sql/opt_range.cc:
        depends_on removed.
      sql/sql_base.cc:
        depends_on removed.
      sql/sql_class.h:
        New iterator added.
      sql/sql_expression_cache.cc:
        Build of list of items resolved in outer query done just before creating expression cache on the first execution of the subquery which removes influence of optimizer removing items (all optimization already done).
      sql/sql_expression_cache.h:
        Build of list of items resolved in outer query done just before creating expression cache on the first execution of the subquery which removes influence of optimizer removing items (all optimization already done).
      sql/sql_lex.cc:
        depends_on removed.
      sql/sql_lex.h:
        depends_on removed.
      sql/sql_list.h:
        Added add_unique method to add only unique elements to the list.
      sql/sql_select.cc:
        Support of new Item list added.
      sql/sql_select.h:
        Support of new Item list added.
      99cce189
  3. 27 Jun, 2011 1 commit
    • Michael Widenius's avatar
      New status variables: Rows_tmp_read, Handler_tmp_update and Handler_tmp_write · ba9a890f
      Michael Widenius authored
      Split status variable Rows_read to Rows_read and Rows_tmp_read so that one can see how much real data is read.
      Same was done with with Handler_update and Handler_write.
      Fixed bug in MEMORY tables where some variables was counted twice.
      Added new internal handler call 'ha_close()' to have one place to gather statistics.
      Fixed bug where thd->open_options was set to wrong value when doing admin_recreate_table()
      
      
      mysql-test/r/status.result:
        Updated test results and added new tests
      mysql-test/r/status_user.result:
        Udated test results
      mysql-test/t/status.test:
        Added new test for temporary table status variables
      sql/ha_partition.cc:
        Changed to call ha_close() instead of close()
      sql/handler.cc:
        Added internal_tmp_table variable for easy checking of temporary tables.
        Added new internal handler call 'ha_close()' to have one place to gather statistics.
        Gather statistics for internal temporary tables.
      sql/handler.h:
        Added handler variables internal_tmp_table, rows_tmp_read.
        Split function update_index_statistics() to two.
        Added ha_update_tmp_row() for faster tmp table handling with more statistics.
      sql/item_sum.cc:
        ha_write_row() -> ha_write_tmp_row()
      sql/multi_range_read.cc:
        close() -> ha_close()
      sql/mysqld.cc:
        New status variables: Rows_tmp_read, Handler_tmp_update and Handler_tmp_write
      sql/opt_range.cc:
        close() -> ha_close()
      sql/sql_base.cc:
        close() -> ha_close()
      sql/sql_class.cc:
        Added handling of rows_tmp_read
      sql/sql_class.h:
        Added new satistics variables.
        rows_read++  ->  update_rows_read() to be able to correctly count reads to internal temp tables.
        Added handler::ha_update_tmp_row()
      sql/sql_connect.cc:
        Added comment
      sql/sql_expression_cache.cc:
        ha_write_row() -> ha_write_tmp_row()
      sql/sql_select.cc:
        close() -> ha_close()
        ha_update_row() -> ha_update_tmp_row()
      sql/sql_show.cc:
        ha_write_row() -> ha_write_tmp_row()
      sql/sql_table.cc:
        Fixed bug where thd->open_options was set to wrong value when doing admin_recreate_table()
      sql/sql_union.cc:
        ha_write_row() -> ha_write_tmp_row()
      sql/sql_update.cc:
        ha_write_row() -> ha_write_tmp_row()
      sql/table.cc:
        close() -> ha_close()
      storage/heap/ha_heap.cc:
        Removed double counting of statistic variables.
        close -> ha_close() to get tmp table statistics.
      storage/maria/ha_maria.cc:
        close -> ha_close() to get tmp table statistics.
      ba9a890f
  4. 10 Jun, 2011 1 commit
  5. 09 Jun, 2011 1 commit
    • Sergei Golubchik's avatar
      bugfixes: · c3f665dc
      Sergei Golubchik authored
        microsecond(TIME)
        alter table datetime<->datetime(6)
        max(TIME), mix(TIME) 
      
      mysql-test/t/func_if.test:
        fix the test case of avoid overflow
      sql/field.cc:
        don't use make_date() and make_time()
      sql/field.h:
        correct eq_def() for temporal fields
      sql/item.cc:
        move datetime caching from Item_cache_int
        to Item_cache_temporal
      sql/item.h:
        move datetime caching from Item_cache_int
        to Item_cache_temporal
      sql/item_func.cc:
        use existing helper methods, don't duplicate
      sql/item_sum.cc:
        argument cache must use argument's cmp_type, not result_type.
      sql/item_timefunc.cc:
        use existing methods, don't tuplicate.
        remove unused function.
        fix micorseconds() to support TIME argument
      sql/mysql_priv.h:
        dead code
      sql/time.cc:
        dead code
      c3f665dc
  6. 06 Jun, 2011 1 commit
    • Sergei Golubchik's avatar
      revert a suggested "optimization" that introduced a bug · 4d128777
      Sergei Golubchik authored
      compilation error in mysys/my_getsystime.c fixed
      some redundant code removed
      sec_to_time, time_to_sec, from_unixtime, unix_timestamp, @@timestamp now
        use decimal, not double for numbers with a fractional part.
      purge_master_logs_before_date() fixed
      many bugs in corner cases fixed
      
      mysys/my_getsystime.c:
        compilation failure fixed
      sql/sql_parse.cc:
        don't cut corners. it backfires.
      4d128777
  7. 28 May, 2011 1 commit
  8. 12 Apr, 2011 1 commit
    • Sergey Glukhov's avatar
      Bug#11766270 59343: YEAR(4): INCORRECT RESULT AND VALGRIND WARNINGS WITH MIN/MAX, UNION · 7fa7a0ca
      Sergey Glukhov authored
      When we create temporary result table for UNION
      incorrect max_length for YEAR field is used and
      it leads to incorrect field value and incorrect
      result string length as YEAR field value calculation
      depends on field length.
      The fix is to use underlying item max_length for
      Item_sum_hybrid::max_length intialization.
      
      
      mysql-test/r/func_group.result:
        test case
      mysql-test/t/func_group.test:
        test case
      sql/field.cc:
        added assert
      sql/item_sum.cc:
        init Item_sum_hybrid::max_length with 
        use underlying item max_length for
        INT result type.
      7fa7a0ca
  9. 24 Mar, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#715738 · ec239491
      unknown authored
      Analysis:
      A query with implicit grouping is one with aggregate functions and
      no GROUP BY clause. MariaDB inherits from MySQL an SQL extenstion
      that allows mixing aggregate functions with non-aggregate fields.
      If a query with such mixed select clause produces an empty result
      set, the meaning of aggregate functions is well defined - either
      NULL (MIN, MAX, etc.), or 0 (count(*)). However the non-aggregated
      fields must also have some value, and the only reasonable value in
      the case of empty result is NULL.
      
      The cause of the many wrong results was that if a field is declared
      as non-nullable (e.g. because it is a PK or NOT NULL), the semantic
      analysis and the optimization phases treat this field as non-nullable,
      and generate all related query plan elements based on this assumption.
      
      Later during execution, these incorrectly configured/generated query
      plan elements result in a wrong result because the selected fields
      are not null due to the not-null assumption during optimization.
      
      Solution:
      Detect before the context analysys phase that a query uses implicit
      grouping with mixed aggregates/non-aggregates, and set all fields
      as nullable. The parser already walks the SELECT clause, and
      already sets Item::with_sum_func for Items that reference aggreagate
      functions. The patch adds a symmetric Item::with_field so that all
      Items that reference an Item_field are marked during their
      construction at parse time in the same way as with aggregate function
      use.
      ec239491
  10. 01 Mar, 2011 1 commit
    • Sergei Golubchik's avatar
      wl#173 - temporal types with sub-second resolution · a8a757c6
      Sergei Golubchik authored
               and collateral changes.
      
      * introduce my_hrtime_t, my_timediff_t, and conversion macros
      * inroduce TIME_RESULT, but it can only be returned from Item::cmp_type(),
        never from Item::result_type()
      * pack_time/unpack_time function for "packed" representation of
        MYSQL_TIME in a longlong that can be compared
      * ADDTIME()/SUBTIME()/+- INTERVAL now work with TIME values
      * numbers aren't quoted in EXPLAIN EXTENDED
      * new column I_S.COLUMNS.DATETIME_PRECISION
      * date/time values are compares to anything as date/time, not as strings or numbers.
      * old timestamp(X) is no longer supported
      * MYSQL_TIME to string conversion functions take precision as an argument
      * unified the warnings from Field_timestamp/datetime/time/date/newdate store methods
      * Field_timestamp_hires, Field_datetime_hires, Field_time_hires
      * Field_temporal
      * Lazy_string class to pass a value (string, number, time) polymorphically down the stack
      * make_truncated_value_warning and Field::set_datetime_warning use Lazy_string as an argument, removed char*/int/double variants
      * removed Field::can_be_compared_as_longlong(). Use Field::cmp_type() == INT_RESULT instead
      * introduced Item::cmp_result() instead of Item::is_datetime() and Item::result_as_longlong()
      * in many cases date/time types are treated like other types, not as special cases
      * greatly simplified Arg_comparator (regarding date/time/year code)
      * SEC_TO_TIME is real function, not integer.
      * microsecond precision in NOW, CURTIME, etc
      * Item_temporal. All items derived from it only provide get_date, but no val* methods
      * replication of NOW(6)
      * Protocol::store(time) now takes the precision as an argument
      * @@TIMESTAMP is a double
      
      client/mysqlbinlog.cc:
        remove unneded casts
      include/my_sys.h:
        introduce my_hrtime_t, my_timediff_t, and conversion macros
      include/my_time.h:
        pack_time/unpack_time, etc.
        convenience functions to work with MYSQL_TIME::second_part
      libmysql/libmysql.c:
        str_to_time() is gone. str_to_datetime() does it now.
        my_TIME_to_str() takes the precision as an argument
      mysql-test/include/ps_conv.inc:
        time is not equal to datetime anymore
      mysql-test/r/distinct.result:
        a test for an old MySQL bug
      mysql-test/r/explain.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/func_default.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/func_sapdb.result:
        when decimals=NOT_FIXED_DEC it means "not fixed" indeed
      mysql-test/r/func_test.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/func_time.result:
        ADDTIME()/SUBTIME()/+- INTERVAL now work with TIME values
      mysql-test/r/having.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/information_schema.result:
        new column I_S.COLUMNS.DATETIME_PRECISION
      mysql-test/r/join_outer.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/metadata.result:
        TIMESTAMP no longer has zerofill flag
      mysql-test/r/range.result:
        invalid datetime is not compared with as a string
      mysql-test/r/select.result:
        NO_ZERO_IN_DATE, etc only affect storage - according to the manual
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/subselect.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/sysdate_is_now.result:
        when decimals=NOT_FIXED_DEC it means "not fixed" indeed
      mysql-test/r/type_blob.result:
        TIMESTAMP(N) is not deprecated
      mysql-test/r/type_timestamp.result:
        old TIMESTAMP(X) semantics is not supported anymore
      mysql-test/r/union.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/r/varbinary.result:
        numbers aren't quoted in EXPLAIN EXTENDED
      mysql-test/t/distinct.test:
        test for an old MySQL bug
      mysql-test/t/func_time.test:
        +- INTERVAL now works with TIME values
      mysql-test/t/select.test:
        typo
      mysql-test/t/subselect.test:
        only one error per statement, please
      mysql-test/t/system_mysql_db_fix40123.test:
        old timestamp(X) is no longer supported
      mysql-test/t/system_mysql_db_fix50030.test:
        old timestamp(X) is no longer supported
      mysql-test/t/system_mysql_db_fix50117.test:
        old timestamp(X) is no longer supported
      mysql-test/t/type_blob.test:
        old timestamp(X) is no longer supported
      mysql-test/t/type_timestamp.test:
        old timestamp(X) is no longer supported
      mysys/my_getsystime.c:
        functions to get the time with microsecond precision
      mysys/my_init.c:
        move the my_getsystime.c initialization code to my_getsystime.c
      mysys/my_static.c:
        no need to make these variables extern
      mysys/my_static.h:
        no need to make these variables extern
      scripts/mysql_system_tables.sql:
        old timestamp(X) is no longer supported
      scripts/mysql_system_tables_fix.sql:
        old timestamp(X) is no longer supported
      scripts/mysqlhotcopy.sh:
        old timestamp(X) is no longer supported
      sql-common/my_time.c:
        * call str_to_time from str_to_datetime, as appropriate
        * date/time to string conversions take precision as an argument
        * number_to_time()
        * TIME_to_double()
        * pack_time() and unpack_time()
      sql/event_data_objects.cc:
        cast is not needed
        my_datetime_to_str() takes precision as an argument
      sql/event_db_repository.cc:
        avoid dangerous downcast (because the pointer is
        not always Field_timestamp, see events_1.test)
      sql/event_queue.cc:
        avoid silly double-work for cond_wait
        (having an endpoint of wait, subtract the current time to get the timeout,
        and use set_timespec() macro to fill in struct timespec, by adding the current
        time to the timeout)
      sql/field.cc:
        * remove virtual Field::get_time(), everyone should use only Field::get_date()
        * remove lots of #ifdef WORDS_BIGENDIAN
        * unified the warnings from Field_timestamp/datetime/time/date/newdate store methods
        * Field_timestamp_hires, Field_datetime_hires, Field_time_hires
        * Field_temporal
        * make_truncated_value_warning and Field::set_datetime_warning use Lazy_string as an argument, removed char*/int/double variants
      sql/field.h:
        * remove virtual Field::get_time(), everyone should use only Field::get_date()
        * remove lots of #ifdef WORDS_BIGENDIAN
        * unified the warnings from Field_timestamp/datetime/time/date/newdate store methods
        * Field_timestamp_hires, Field_datetime_hires, Field_time_hires
        * Field_temporal
        * make_truncated_value_warning and Field::set_datetime_warning use Lazy_string as an argument, removed char*/int/double variants
        * removed Field::can_be_compared_as_longlong(). Use Field::cmp_type() == INT_RESULT instead
      sql/filesort.cc:
        TIME_RESULT, cmp_time()
      sql/item.cc:
        * numbers aren't quoted in EXPLAIN EXTENDED
        * Item::cmp_result() instead of Item::is_datetime() and Item::result_as_longlong()
        * virtual Item::get_time() is gone
        * Item_param::field_type() is set correctly
        * Item_datetime, for a datetime constant
        * time to anything is compared as a time
        * Item_cache::print() prints the value is available
        * bug fixed in Item_cache_int::val_str()
      sql/item.h:
        * Item::print_value(), to be used from Item_xxx::print() when needed
        * Item::cmp_result() instead of Item::is_datetime() and Item::result_as_longlong()
        * virtual Item::get_time() is gone
        * Item_datetime, for a datetime constant
        * better default for cast_to_int_type()
        * Item_cache objects now *always* have the field_type() set
      sql/item_cmpfunc.cc:
        * get_year_value, get_time_value are gone. get_datetime_value does it all
        * get_value_a_func, get_value_b_func are gone
        * can_compare_as_dates() is gone too, TIME_RESULT is used instead
        * cmp_type() instead or result_type() when doing a comparison
        * compare_datetime and compate_e_datetime in the comparator_matrix, is_nulls_eq is gone
        * Item::cmp_result() instead of Item::is_datetime() and Item::result_as_longlong()
      sql/item_cmpfunc.h:
        greatly simplified Arg_comparator
      sql/item_create.cc:
        * fix a bug in error messages in CAST
      sql/item_func.cc:
        Item::cmp_result() instead of Item::is_datetime() and Item::result_as_longlong()
        mention all possibitiles in switch over Item_result values, or use default:
      sql/item_row.h:
        overwrite the default cmp_type() for Item_row,
        as no MYSQL_TYPE_xxx value corresponds to ROW_RESULT
      sql/item_timefunc.cc:
        rewrite make_datetime to support precision argument
        SEC_TO_TIME is real function, not integer.
        many functions that returned temporal values had duplicate code in val_* methods,
        some of them did not have get_date() which resulted in unnecessary date->str->date conversions. 
        Now they all are derived from Item_temporal_func and *only* provide get_date, not val* methods.
        many fixes to set decimals (datetime precision) correctly.
      sql/item_timefunc.h:
        SEC_TO_TIME is real function, not integer.
        many functions that returned temporal values had duplicate code in val_* methods,
        some of them did not have get_date() which resulted in unnecessary date->str->date conversions. 
        Now they all are derived from Item_temporal_func and *only* provide get_date, not val* methods.
        many fixes to set decimals (datetime precision) correctly.
      sql/log_event.cc:
        replication of NOW(6)
      sql/log_event.h:
        replication of NOW(6)
      sql/mysql_priv.h:
        Lazy_string class to pass a value (string, number, time) polymorphically down the stack.
        make_truncated_value_warning() that uses it.
      sql/mysqld.cc:
        datetime in Arg_comparator::comparator_matrix
      sql/opt_range.cc:
        cleanup: don't disable warnings before calling save_in_field_no_warnings()
      sql/protocol.cc:
        Protocol::store(time) now takes the precision as an argument
      sql/protocol.h:
        Protocol::store(time) now takes the precision as an argument
      sql/rpl_rli.cc:
        small cleanup
      sql/set_var.cc:
        SET TIMESTAMP=double
      sql/set_var.h:
        @@TIMESTAMP is a double
      sql/share/errmsg.txt:
        precision and scale are unsigned
      sql/slave.cc:
        replication of NOW(6)
      sql/sp_head.cc:
        cleanup
      sql/sql_class.cc:
        support for NOW(6)
      sql/sql_class.h:
        support for NOW(6)
      sql/sql_insert.cc:
        support for NOW(6)
      sql/sql_select.cc:
        use item->cmp_type().
        move a comment where it belongs
      sql/sql_show.cc:
        new column I_S.COLUMNS.DATETIME_PRECISION
      sql/sql_yacc.yy:
        TIME(X), DATETIME(X), cast, NOW(X), CURTIME(X), etc
      sql/time.cc:
        fix date_add_interval() to support MYSQL_TIMESTAMP_TIME argument
      storage/myisam/ha_myisam.cc:
        TIMESTAMP no longer carries ZEROFIELD flag, still we keep MYI file compatible.
      strings/my_vsnprintf.c:
        warnings
      tests/mysql_client_test.c:
        old timestamp(X) does not work anymore
        datetime is no longer equal to time
      a8a757c6
  11. 11 Feb, 2011 1 commit
    • unknown's avatar
      Fix LP BUG#715034 · cd349466
      unknown authored
      Analysis:
      The failed assert is a result of calling Item_sum_distinct::clear()
      on an incomplete object for which Item_sum_distinct::setup() was
      not yet called.
      
      The reason is that JOIN::exec for the outer query calls JOIN::reinit()
      for all its subqueries, which in turn calls clear() for all aggregate
      functions of the subqueries. The call stack is:
      mysql_explain_union -> mysql_select -> JOIN::exec -> select_desribe ->
      mysql_explain_union -> mysql_select -> JOIN::reinit
      
      This assert doesn't fail in the main 5.3 because constant subqueries
      are being executed during the optimize phase of the outer query,
      thus the Unique object is created before calling JOIN::exec for the
      outer query, and Item_sum_distinct::clear() actually cleans the
      Unique object.
      
      Solution:
      The best solution is the obvious one - substitute the assert with
      a test whether Item_sum_distinct::tree is NULL.
      cd349466
  12. 09 Feb, 2011 1 commit
    • MySQL Build Team's avatar
      Backport into build-201102032246-5.1.52sp1 · 00447ead
      MySQL Build Team authored
      > ------------------------------------------------------------
      > revno: 3517
      > revision-id: sergey.glukhov@oracle.com-20101213103926-okypkn10adeeyns8
      > parent: davi.arnaut@oracle.com-20101207150620-s49dstok48oy585o
      > committer: Sergey Glukhov <sergey.glukhov@oracle.com>
      > branch nick: mysql-5.1-bugteam
      > timestamp: Mon 2010-12-13 13:39:26 +0300
      > message:
      >   Bug#58396 group_concat and explain extended are still crashy
      >   Explain fails at fix_fields stage and some items are left unfixed,
      >   particulary Item_group_concat. Item_group_concat::orig_args field
      >   is uninitialized in this case and Item_group_concat::print call 
      >   leads to crash.
      >   The fix:
      >   move the initialization of Item_group_concat::orig_args
      >   into constructor.
      00447ead
  13. 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
  14. 21 Dec, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#58030 crash in Item_func_geometry_from_text::val_str · e2db8e6c
      Sergey Glukhov authored
      Item_sum_max/Item_sum_min incorrectly set null_value flag and
      attempt to get result in parent functions leads to crash.
      This happens due to double evaluation of the function argumet.
      First evaluation happens in the comparator and second one
      happens in Item_cache::cache_value().
      The fix is to introduce new Item_cache object which
      holds result of the argument and use this cached value
      as an argument of the comparator.
      
      mysql-test/r/func_group.result:
        test case
      mysql-test/t/func_group.test:
        test case
      sql/item.cc:
        added assertion that ether we have some result or result is NULL.
      sql/item_sum.cc:
        introduce new Item_cache object which
        holds result of the argument and use this cached value
        as an argument of the comparator.
      sql/item_sum.h:
        introduce new Item_cache object which
        holds result of the argument and use this cached value
        as an argument of the comparator.
      e2db8e6c
  15. 14 Dec, 2010 1 commit
    • Gleb Shchepa's avatar
      backport of bug #54476 fix from 5.1-bugteam to 5.0-bugteam. · 086130e3
      Gleb Shchepa authored
      Original revid: alexey.kopytov@sun.com-20100723115254-jjwmhq97b9wl932l
      
       > Bug #54476: crash when group_concat and 'with rollup' in
       >                      prepared statements
       >
       > Using GROUP_CONCAT() together with the WITH ROLLUP modifier
       > could crash the server.
       >
       > The reason was a combination of several facts:
       >
       > 1. The Item_func_group_concat class stores pointers to ORDER
       > objects representing the columns in the ORDER BY clause of
       > GROUP_CONCAT().
       >
       > 2. find_order_in_list() called from
       > Item_func_group_concat::setup() modifies the ORDER objects so
       > that their 'item' member points to the arguments list
       > allocated in the Item_func_group_concat constructor.
       >
       > 3. In some cases (e.g. in JOIN::rollup_make_fields) a copy of
       > the original Item_func_group_concat object could be created by
       > using the Item_func_group_concat::Item_func_group_concat(THD
       > *thd, Item_func_group_concat *item) copy constructor. The
       > latter essentially creates a shallow copy of the source
       > object. Memory for the arguments array is allocated on
       > thd->mem_root, but the pointers for arguments and ORDER are
       > copied verbatim.
       >
       > What happens in the test case is that when executing the query
       > for the first time, after a copy of the original
       > Item_func_group_concat object has been created by
       > JOIN::rollup_make_fields(), find_order_in_list() is called for
       > this new object. It then resolves ORDER BY by modifying the
       > ORDER objects so that they point to elements of the arguments
       > array which is local to the cloned object. When thd->mem_root
       > is freed upon completing the execution, pointers in the ORDER
       > objects become invalid. Those ORDER objects, however, are also
       > shared with the original Item_func_group_concat object which is
       > preserved between executions of a prepared statement. So the
       > first call to find_order_in_list() for the original object on
       > the second execution tries to dereference an invalid pointer.
       >
       > The solution is to create copies of the ORDER objects when
       > copying Item_func_group_concat to not leave any stale pointers
       > in other instances with different lifecycles.
      
      
      mysql-test/r/func_gconcat.result:
        Test case for bug #54476.
      mysql-test/t/func_gconcat.test:
        Test case for bug #54476.
      sql/item_sum.cc:
        Copy the ORDER objects pointed to by the elements of the
        'order' array in the copy constructor of
        Item_func_group_concat.
      sql/table.h:
        Removed the unused 'item_copy' member of the ORDER class.
      086130e3
  16. 13 Dec, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#58396 group_concat and explain extended are still crashy · 6330815a
      Sergey Glukhov authored
      Explain fails at fix_fields stage and some items are left unfixed,
      particulary Item_group_concat. Item_group_concat::orig_args field
      is uninitialized in this case and Item_group_concat::print call 
      leads to crash.
      The fix:
      move the initialization of Item_group_concat::orig_args
      into constructor.
      
      
      mysql-test/r/func_gconcat.result:
        test case
      mysql-test/t/func_gconcat.test:
        test case
      sql/item_sum.cc:
        move the initialization of Item_group_concat::orig_args
        into constructor.
      6330815a
  17. 29 Oct, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#57194 group_concat cause crash and/or invalid memory reads with type errors · c04bf683
      Sergey Glukhov authored
      The problem is caused by bug49487 fix and became visible
      after after bug56679 fix.
      Items are cleaned up and set to unfixed state after filling derived table.
      So we can not rely on item::fixed state in Item_func_group_concat::print
      and we can not use 'args' array as items there may be cleaned up.
      The fix is always to use orig_args array of items as it
      always should contain the correct data.
      
      
      mysql-test/r/func_gconcat.result:
        test case
      mysql-test/t/func_gconcat.test:
        test case
      sql/item_sum.cc:
        The fix is always to use orig_args array of items.
      c04bf683
  18. 23 Sep, 2010 1 commit
    • Michael Widenius's avatar
      Change some my_bool in C++ classes and a few functions to bool to detect wrong... · bdba1d11
      Michael Widenius authored
      Change some my_bool in C++ classes and a few functions to bool to detect wrong usage of bool/my_bool.
      Fix some bugs where we stored values other than 0 or 1 in my_bool
      Fixed some compiler warnings
      
      
      client/mysql.cc:
        Changed interrupted_query from my_bool to int, as we stored 2 in it.
      client/mysqladmin.cc:
        Changed return variable type to same type as function value type
      client/mysqltest.cc:
        Changed 'found' to int as we store other values than 0 or 1 into it
        Changed type for parameter of set_reconnect() to match usage.
      extra/libevent/evbuffer.c:
        Added __attribute__((unused))
      extra/libevent/event.c:
        Added __attribute__((unused))
      extra/libevent/signal.c:
        Added __attribute__((unused))
      sql/event_data_objects.h:
        my_bool -> bool
      sql/event_db_repository.cc:
        my_bool -> bool
      sql/event_db_repository.h:
        my_bool -> bool
      sql/event_parse_data.h:
        my_bool -> bool
      sql/events.cc:
        my_bool -> bool
      sql/events.h:
        my_bool -> bool
      sql/field.cc:
        my_bool -> bool
      sql/field.h:
        my_bool -> bool
      sql/hash_filo.h:
        my_bool -> bool
      sql/item.cc:
        my_bool -> bool
      sql/item.h:
        my_bool -> bool
      sql/item_cmpfunc.h:
        my_bool -> bool
        Changed result_for_null_param from my_bool to int as we stored -1 in it.
      sql/item_func.cc:
        my_bool -> bool
        Modified udf wrapper functions so that the UDF functions would continue to use my_bool. (To keep compatibility with UDF:s)
      sql/item_func.h:
        my_bool -> bool
      sql/item_subselect.h:
        my_bool -> bool
      sql/item_sum.cc:
        Modified udf wrapper functions so that the UDF functions would continue to use my_bool. (To keep compatibility with UDF:s)
      sql/parse_file.h:
        my_bool -> bool
      sql/rpl_mi.h:
        my_bool -> bool
      sql/sp_rcontext.h:
        my_bool -> bool
      sql/sql_analyse.h:
        my_bool -> bool
      sql/sql_base.cc:
        Change some assignments so that we don't initialize bool variables with int's.
      sql/sql_bitmap.h:
        my_bool -> bool
      sql/sql_cache.cc:
        my_bool -> bool
      sql/sql_cache.h:
        my_bool -> bool
      sql/sql_class.h:
        my_bool -> bool
      sql/sql_insert.cc:
        Change some assignments so that we don't initialize bool variables with int's.
      sql/sql_prepare.cc:
        my_bool -> bool
      sql/table.h:
        my_bool -> bool
      storage/maria/ma_check.c:
        Removed duplicate assignment
      strings/decimal.c:
        Fixed wrong variable usage.
        Don't do complex arithmetic on bool when simple works.
      bdba1d11
  19. 03 Sep, 2010 1 commit
  20. 27 Aug, 2010 1 commit
    • Alexey Kopytov's avatar
      Bug #54465: assert: field_types == 0 || field_types[field_pos] · d7d0f639
      Alexey Kopytov authored
                  == MYSQL_TYPE_LONGLONG
      
      A MIN/MAX() function with a subquery as its argument could lead
      to a debug assertion on debug builds or wrong data on release
      ones.
      
      The problem was a combination of the following factors:
      
      - Item_sum_hybrid::fix_fields() might use the argument
      (args[0]) to calculate 'hybrid_field_type' which was later used
      to decide how the data should be sent to the client.
      
      - Item_sum::make_field() might use the argument again to
      calculate the field's type when sending result set metadata to
      the client.
      
      - The argument could be changed in between these two calls via
        Item::set_arg() leading to inconsistent metadata being
        reported.
      
      Here is what was happening for the bug's test case:
      
      1. Item_sum_hybrid::fix_fields() calculates hybrid_field_type
      as MYSQL_TYPE_LONGLONG based on args[0] which is an
      Item::SUBSELECT_ITEM at that time.
      
      2. A temporary table is created to execute the
      query. create_tmp_field_from_item() creates a Field_long object
      according to the subselect's max_length.
      
      3. The subselect item in Item_sum_hybrid is replaced by the
      Item_field object referencing the newly created Field_long.
      
      4. Item_sum::make_field() rightfully returns the
      MYSQL_TYPE_LONG type when calculating the result set metadata.
      
      5. When sending the actual data, Item::send() relies on the
      virtual field_type() function which in our case returns
      previously calculated hybrid_field_type == MYSQL_TYPE_LONGLONG.
      
      It looks like the only solution is to never refer to the
      argument's metadata after the result metadata has been
      calculated in fix_fields(), since the argument itself may be
      different by then. In this sense, Item_sum::make_field() should
      never be used, because it may rely on the argument's metadata
      and is only called after fix_fields(). The "default"
      implementation in Item::make_field() should be used instead as
      it relies only on field_type(), but not on the argument's type.
      
      Fixed by removing Item_sum::make_field() so that the superclass
      implementation Item::make_field() is always used.
      
      mysql-test/r/func_group.result:
        Added a test case for bug #54465.
      mysql-test/t/func_group.test:
        Added a test case for bug #54465.
      sql/item_sum.cc:
        Removed Item_sum::make_field() so that the superclass
        implementation Item::make_field() is always used.
      sql/item_sum.h:
        Removed Item_sum::make_field() so that the superclass
        implementation Item::make_field() is always used.
      d7d0f639
  21. 23 Aug, 2010 1 commit
    • Michael Widenius's avatar
      Fix for LP#612894 Some aggregate functions (such as MIN MAX) work incorrectly... · b6fe4713
      Michael Widenius authored
      Fix for LP#612894 Some aggregate functions (such as MIN MAX) work incorrectly in subqueries after getting NULL value
      
      
      mysql-test/r/group_by.result:
        Added test that showed problems that no_rows_in_results() didn't work for expressions
      mysql-test/r/subselect4.result:
        Test case for LP#612894
      mysql-test/t/group_by.test:
        Added test that showed problems that no_rows_in_results() didn't work for expressions
      mysql-test/t/subselect4.test:
        Test case for LP#612894
      sql/item.h:
        Added restore_to_before_no_rows_in_result()
        Added function processor for no_rows_in_results() and restore_to_before_no_rows_in_results() to ensure it works with functions
        Fix that above functions are handled by Item_ref()
      sql/item_func.h:
        Ensure that no_rows_in_results() and restore_to_before_no_rows_in_result() are called for all function arguments
      sql/item_sum.cc:
        Added restore_to_before_no_rows_in_result() to restore settings after Item_sum_hybrid::no_rows_in_result() was called.
        This is needed to handle the case where we have made 'make_const()' on the item in opt_sum(), but the item will be reused again in a sub query.
        Ignore multiple calls to no_rows_in_result() as Item_ref is calling it twice.
      sql/item_sum.h:
        Added restore_to_before_no_rows_in_result();
      sql/sql_select.cc:
        Added reset of no_rows_in_result() for JOIN::reinit()
      sql/sql_select.h:
        Added marker if no_rows_in_result() is called.
      b6fe4713
  22. 13 Aug, 2010 1 commit
    • Georgi Kodinov's avatar
      Bug #55580 : segfault in read_view_sees_trx_id · 790852c0
      Georgi Kodinov authored
      The server was not checking for errors generated during
      the execution of Item::val_xxx() methods when copying
      data to the group, order, or distinct temp table's row.
      Fixed by extending the copy_funcs() to return an error
      code and by checking for that error code on the places
      copy_funcs() is called. 
      Test case added.
      790852c0
  23. 23 Jul, 2010 1 commit
    • Alexey Kopytov's avatar
      Bug #54476: crash when group_concat and 'with rollup' in · 1837dcfe
      Alexey Kopytov authored
                           prepared statements
      
      Using GROUP_CONCAT() together with the WITH ROLLUP modifier
      could crash the server.
      
      The reason was a combination of several facts:
      
      1. The Item_func_group_concat class stores pointers to ORDER
      objects representing the columns in the ORDER BY clause of
      GROUP_CONCAT().
      
      2. find_order_in_list() called from
      Item_func_group_concat::setup() modifies the ORDER objects so
      that their 'item' member points to the arguments list
      allocated in the Item_func_group_concat constructor.
      
      3. In some cases (e.g. in JOIN::rollup_make_fields) a copy of
      the original Item_func_group_concat object could be created by
      using the Item_func_group_concat::Item_func_group_concat(THD
      *thd, Item_func_group_concat *item) copy constructor. The
      latter essentially creates a shallow copy of the source
      object. Memory for the arguments array is allocated on
      thd->mem_root, but the pointers for arguments and ORDER are
      copied verbatim.
      
      What happens in the test case is that when executing the query
      for the first time, after a copy of the original
      Item_func_group_concat object has been created by
      JOIN::rollup_make_fields(), find_order_in_list() is called for
      this new object. It then resolves ORDER BY by modifying the
      ORDER objects so that they point to elements of the arguments
      array which is local to the cloned object. When thd->mem_root
      is freed upon completing the execution, pointers in the ORDER
      objects become invalid. Those ORDER objects, however, are also
      shared with the original Item_func_group_concat object which is
      preserved between executions of a prepared statement. So the
      first call to find_order_in_list() for the original object on
      the second execution tries to dereference an invalid pointer.
      
      The solution is to create copies of the ORDER objects when
      copying Item_func_group_concat to not leave any stale pointers
      in other instances with different lifecycles.
      
      
      
      mysql-test/r/func_gconcat.result:
        Test case for bug #54476.
      mysql-test/t/func_gconcat.test:
        Test case for bug #54476.
      sql/item_sum.cc:
        Copy the ORDER objects pointed to by the elements of the 
        'order' array in the copy constructor of 
        Item_func_group_concat.
      sql/table.h:
        Removed the unused 'item_copy' member of the ORDER class.
      1837dcfe
  24. 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
  25. 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
  26. 31 Mar, 2010 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#52397: another crash with explain extended and group_concat · 55852670
      Ramil Kalimullin authored
      Problem: EXPLAIN EXTENDED was trying to resolve references to 
      freed temporary table fields for GROUP_CONCAT()'s ORDER BY arguments.
      
      Fix: use stored original GROUP_CONCAT()'s arguments in such a case.
      
      
      mysql-test/r/func_gconcat.result:
        Fix for bug#52397: another crash with explain extended and group_concat
          - test result.
      mysql-test/t/func_gconcat.test:
        Fix for bug#52397: another crash with explain extended and group_concat
          - test case.
      sql/item_sum.cc:
        Fix for bug#52397: another crash with explain extended and group_concat
          - use "pargs", printing ORDER BY arguments in the 
        Item_func_group_concat::print() instead of "order" to avoid
        possible reference resolving to (freed) temporary table fields.
      55852670
  27. 28 Mar, 2010 1 commit
    • Michael Widenius's avatar
      Fixed compiler warnings and sporadic failures in test cases · 1fec5af7
      Michael Widenius authored
      mysql-test/extra/rpl_tests/rpl_tmp_table_and_DDL.test:
        Added missing sync_slave_with_master; Fixes random failures
      mysql-test/include/default_mysqld.cnf:
        default-character-set -> character-set-server (removes warning in error files for usage of deprecated options)
      mysql-test/lib/My/SafeProcess/safe_process.cc:
        Fixed compiler warning
      mysql-test/lib/v1/mysql-test-run.pl:
        default-character-set -> character-set-server (removes warning in error files for usage of deprecated options)
      mysql-test/suite/rpl/r/rpl_do_grant.result:
        Updated test results
      mysql-test/suite/rpl/t/rpl_do_grant.test:
        Added missing sync_slave_with_master; Fixes random failures
        Had to explictely do stop slave before DROP USER to avoid failure on slave as the user is already dropped on slave.
      mysql-test/suite/rpl/t/rpl_name_const.test:
        Added missing sync_slave_with_master; Fixes random failures
      mysql-test/suite/rpl/t/rpl_row_basic_11bugs.test:
        Added missing sync_slave_with_master; Fixes random failures
      mysql-test/t/bug47671-master.opt:
        default-character-set -> character-set-server (removes warning in error files for usage of deprecated options)
      mysql-test/t/ctype_latin1_de-master.opt:
        default-character-set -> character-set-server (removes warning in error files for usage of deprecated options)
      mysql-test/t/ctype_ucs2_def-master.opt:
        default-character-set -> character-set-server (removes warning in error files for usage of deprecated options)
      sql-common/client.c:
        Fixed compiler warning
      sql/item.cc:
        Renamed function to remove compiler warnings (with gcc)
      sql/item.h:
        Renamed function to remove compiler warnings (with gcc)
      sql/item_cmpfunc.cc:
        Renamed function to remove compiler warnings (with gcc)
      sql/item_create.cc:
        Renamed function to remove compiler warnings (with gcc)
      sql/item_create.h:
        Renamed function to remove compiler warnings (with gcc)
      sql/item_sum.cc:
        Renamed function to remove compiler warnings (with gcc)
      sql/item_sum.h:
        Renamed function to remove compiler warnings (with gcc)
      sql/set_var.cc:
        Don't use bit_do_set() / bot_is_set() / bit_do_clear() as this generates compiler warnings
        (They are also of no use as we know the value can hold the bits)
      sql/sql_yacc.yy:
        Renamed function to remove compiler warnings (with gcc)
      storage/example/ha_example.h:
        Fixed old read_time() prototype
      storage/maria/ma_search.c:
        Added extra variables to remove compiler warnings
      storage/maria/maria_def.h:
        Added extra variables to remove compiler warnings
      storage/myisam/ft_stopwords.c:
        Added cast to get rid of compiler warning
      storage/xtradb/fil/fil0fil.c:
        Added cast to get rid of compiler warning
      storage/xtradb/include/page0page.h:
        Added const to get rid of compiler warning
      storage/xtradb/include/page0page.ic:
        Added const to get rid of compiler warning
      support-files/compiler_warnings.supp:
        Added suppression of strict-aliasing
      1fec5af7
  28. 14 Mar, 2010 1 commit
    • Staale Smedseng's avatar
      Bug #49829 Many "hides virtual function" warnings with · c7fad393
      Staale Smedseng authored
      SunStudio
            
      SunStudio compilers of late warn about methods that might hide
      methods in base classes due to the use of overloading combined
      with overriding. SunStudio also warns about variables defined
      in local socpe or method arguments that have the same name as
      a member attribute of the class.
            
      This patch renames methods that might hide base class methods,
      to make it easier both for humans and compilers to see what is
      actually called. It also renames variables in local scope.
      
      
      sql/field.cc:
        Local scope variable or method argument same as class 
        attribute.
      sql/item_cmpfunc.cc:
        Local scope variable or method argument same as class 
        attribute.
      sql/item_create.cc:
        Renaming base class create() to create_func().
      sql/item_create.h:
        Renaming base class create() to create_func().
      sql/protocol.cc:
        Local scope variable or method argument same as class 
        attribute.
      sql/sql_profile.cc:
        Local scope variable or method argument same as class 
        attribute.
      sql/sql_select.cc:
        Local scope variable or method argument same as class 
        attribute.
      sql/sql_yacc.yy:
        Renaming base class create() to create_func().
      storage/federated/ha_federated.cc:
        Local scope variable or method argument same as class 
        attribute.
      storage/myisammrg/ha_myisammrg.cc:
        Local scope variable or method argument same as class 
        attribute.
      c7fad393
  29. 19 Feb, 2010 1 commit
    • Tatiana A. Nurnberg's avatar
      Bug#49487: crash with explain extended and group_concat in a derived table · 1fc1f462
      Tatiana A. Nurnberg authored
      When EXPLAIN EXTENDED tries to print column names, it checks whether the
      referenced table is CONST (in which case, the column's value rather than
      its name will be printed). If no proper table is reference (i.e. because
      a derived table was used that has since gone out of scope), this will fail
      spectacularly.
      
      This ports an equivalent of the fix for Bug 43354.
      
      mysql-test/r/func_gconcat.result:
        Show that EXPLAIN EXTENDED on a GROUP_CONCAT() on a derived table
        no longer crashes the server.
      mysql-test/t/func_gconcat.test:
        Show that EXPLAIN EXTENDED on a GROUP_CONCAT() on a derived table
        no longer crashes the server.
      sql/item_sum.cc:
        Do not de-ref what cannot be, that is, temp-tables that have gone away.
        This is of questionable utility anyway, since our deref has the sole
        purpose of checking whether the table is const (in which case, we'll
        substitute the column with its value in EXPLAIN EXTENDED - that is all).
      1fc1f462
  30. 11 Feb, 2010 1 commit
  31. 25 Nov, 2009 1 commit
    • MySQL Build Team's avatar
      Backport into build-200911241145-5.1.40sp1 · ffea9806
      MySQL Build Team authored
      > ------------------------------------------------------------
      > revno: 3148.8.5
      > revision-id: davi.arnaut@sun.com-20091102112139-pztthzy6qj8jzomn
      > parent: svoj@sun.com-20091103091902-vwszwwpfi1f4zrpn
      > committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      > branch nick: 48370-5.1
      > timestamp: Mon 2009-11-02 09:21:39 -0200
      > message:
      >   Bug#48370: Absolutely wrong calculations with GROUP BY and decimal fields when using IF
      >   Bug#45261: Crash, stored procedure + decimal
      >   
      >   Revert fix for Bug#45261 due to unforeseen bugs.
      ffea9806
  32. 20 Nov, 2009 1 commit
    • Georgi Kodinov's avatar
      Bug #45261 : Crash, stored procedure + decimal · a21cd97c
      Georgi Kodinov authored
      Bug #48370  Absolutely wrong calculations with GROUP BY and
        decimal fields when using IF
      
      Added the test cases in the above two bugs for regression
      testing.
      Added additional tests that demonstrate a incomplete fix.
      Added a new factory method for Field_new_decimal to 
      create a field from an (decimal returning) Item.
      In the new method made sure that all the precision and 
      length variables are capped in a proper way. 
      This is required because Item's can have larger precision
      than the decimal fields and thus need to be capped when
      creating a field based on an Item type.
      Fixed the wrong typecast to Item_decimal.
      a21cd97c
  33. 17 Nov, 2009 1 commit
    • Evgeny Potemkin's avatar
      Bug#43668: Wrong comparison and MIN/MAX for YEAR(2) · bc43bff7
      Evgeny Potemkin authored
      MySQL manual describes values of the YEAR(2) field type as follows:
      values 00 - 69 mean 2000 - 2069 years and values 70 - 99 mean 1970 - 1999
      years. MIN/MAX and comparison functions was comparing them as int values
      thus producing wrong result.
      
      Now the Arg_comparator class is extended with compare_year function which
      performs correct comparison of the YEAR type.
      The Item_sum_hybrid class now uses Item_cache and Arg_comparator objects to
      correctly calculate its value.
      To allow Arg_comparator to use func_name() function for Item_func and Item_sum
      objects the func_name declaration is moved to the Item_result_field class.
      A helper function is_owner_equal_func is added to the Arg_comparator class.
      It checks whether the Arg_comparator object owner is the <=> function or not.
      A helper function setup is added to the Item_sum_hybrid class. It sets up
      cache item and comparator.
      
      mysql-test/r/func_group.result:
        Added a test case for the bug#43668.
      mysql-test/t/func_group.test:
        Added a test case for the bug#43668.
      sql/item.cc:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        Now Item_cache_int returns the type of cached item.
      sql/item.h:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        To allow Arg_comparator to use func_name() function for Item_func and Item_sum
        objects the func_name declaration is moved to the Item_result_field class.
      sql/item_cmpfunc.cc:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        The Arg_comparator class is extended with compare_year function which
        performs correct comparison of the YEAR type.
      sql/item_cmpfunc.h:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        The year_as_datetime variable is added to the Arg_comparator class.
        It's set to TRUE when YEAR value should be converted to the
        YYYY-00-00 00:00:00 format for correct YEAR-DATETIME comparison.
      sql/item_geofunc.cc:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        Item_func_spatial_rel::val_int chenged to use Arg_comparator's string
        buffers.
      sql/item_subselect.h:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        Added an implementation of the virtual func_name function.
      sql/item_sum.cc:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        The Item_sum_hybrid class now uses Item_cache and Arg_comparator objects to
        correctly calculate its value.
        A helper function setup is added to the Item_sum_hybrid class. It sets up
        cache item and comparator.
      sql/item_sum.h:
        Bug#43668: Wrong comparison and MIN/MAX for YEAR(2)
        The Item_sum_hybrid class now uses Item_cache and Arg_comparator objects to
        correctly calculate its value.
        Added an implementation of the virtual func_name function.
      bc43bff7
  34. 02 Nov, 2009 1 commit
  35. 24 Aug, 2009 1 commit
    • Davi Arnaut's avatar
      Bug#45261: Crash, stored procedure + decimal · fc394595
      Davi Arnaut authored
      The problem was that creating a DECIMAL column from a decimal
      value could lead to a failed assertion as decimal values can
      have a higher precision than those attached to a table. The
      assert could be triggered by creating a table from a decimal
      with a large (> 30) scale. Also, there was a problem in
      calculating the number of digits in the integral and fractional
      parts if both exceeded the maximum number of digits permitted
      by the new decimal type.
      
      The solution is to ensure that truncation procedure is executed
      when deducing a DECIMAL column from a decimal value of higher
      precision. If the integer part is equal to or bigger than the
      maximum precision for the DECIMAL type (65), the integer part
      is truncated to fit and the fractional becomes zero. Otherwise,
      the fractional part is truncated to fit into the space left
      after the integer part is copied.
      
      This patch borrows code and ideas from Martin Hansson's patch.
      
      mysql-test/r/type_newdecimal.result:
        Add test case result for Bug#45261. Also, update test case to
        reflect that an additive operation increases the precision of
        the resulting type by 1.
      mysql-test/t/type_newdecimal.test:
        Add test case for Bug#45261
      sql/field.cc:
        Added DBUG_ASSERT to ensure object's invariant is maintained.
        Implement method to create a field to hold a decimal value
        from an item.
      sql/field.h:
        Explain member variable. Add method to create a new decimal field.
      sql/item.cc:
        The precision should only be capped when storing the value
        on a table. Also, this makes it impossible to calculate the
        integer part if Item::decimals (the scale) is larger than the
        precision.
      sql/item.h:
        Simplify calculation of integer part.
      sql/item_cmpfunc.cc:
        Do not limit the precision. It will be capped later.
      sql/item_func.cc:
        Use new method for allocating a new decimal field.
        Add a specialized method for retrieving the precision
        of a user variable item.
      sql/item_func.h:
        Add method to return the precision of a user variable.
      sql/item_sum.cc:
        Use new method for allocating a new decimal field.
      sql/my_decimal.h:
        The integer part could be improperly calculated for a decimal
        with 31 digits in the fractional part.
      sql/sql_select.cc:
        Use new method which truncates the integer or decimal parts
        as needed.
      fc394595
  36. 10 Jul, 2009 1 commit
  37. 03 Jul, 2009 1 commit
    • Alexey Kopytov's avatar
      Bug #45262: Bad effects with CREATE TABLE and DECIMAL · 096c12b2
      Alexey Kopytov authored
       
      Using DECIMAL constants with more than 65 digits in CREATE 
      TABLE ... SELECT led to bogus errors in release builds or 
      assertion failures in debug builds. 
       
      The problem was in inconsistency in how DECIMAL constants and 
      fields are handled internally. We allow arbitrarily long 
      DECIMAL constants, whereas DECIMAL(M,D) columns are limited to 
      M<=65 and D<=30. my_decimal_precision_to_length() was used in 
      both Item and Field code and truncated precision to 
      DECIMAL_MAX_PRECISION when calculating value length without 
      adjusting precision and decimals. As a result, a DECIMAL 
      constant with more than 65 digits ended up having length less 
      than precision or decimals which led to assertion failures. 
       
      Fixed by modifying my_decimal_precision_to_length() so that 
      precision is truncated to DECIMAL_MAX_PRECISION only for Field 
      object which is indicated by the new 'truncate' parameter. 
       
      Another inconsistency fixed by this patch is how DECIMAL 
      constants and expressions are handled for CREATE ... SELECT. 
      create_tmp_field_from_item() (which is used for constants) was 
      changed as a part of the bugfix for bug #24907 to handle long 
      DECIMAL constants gracefully. Item_func::tmp_table_field() 
      (which is used for expressions) on the other hand was still 
      using a simplistic approach when creating a Field_new_decimal 
      from a DECIMAL expression. 
      
      mysql-test/r/type_newdecimal.result:
        Added a test case for bug #45262.
      mysql-test/t/type_newdecimal.test:
        Added a test case for bug #45262.
      sql/item.cc:
        Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
      sql/item_cmpfunc.cc:
        Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
      sql/item_func.cc:
        1. Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
        
        2. Do not truncate decimal precision to DECIMAL_MAX_PRECISION
        for additive expressions involving long DECIMAL constants.
        
        3. Fixed an incosistency in how DECIMAL constants and 
        expressions are handled for CREATE ... SELECT.
      sql/item_func.h:
        Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
      sql/item_sum.cc:
        Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
      sql/my_decimal.h:
        Do not truncate precision to DECIMAL_MAX_PRECISION
        when calculating length in 
        my_decimal_precision_to_length() if 'truncate' parameter
        is FALSE.
      sql/sql_select.cc:
        1. Use the new 'truncate' parameter in 
        my_decimal_precision_to_length().
        
        2. Use a more correct logic when adjusting value's length.
      096c12b2
  38. 22 Jun, 2009 1 commit
    • Sergey Petrunia's avatar
      MWL#17: Table elimination · 9e65634b
      Sergey Petrunia authored
      - Make elimination check to be able detect cases like  t.primary_key_col1=othertbl.col AND t.primary_key_col2=func(t.primary_key_col1).
        These are needed to handle e.g. the case of func() being a correlated subquery that selects the latest value.
      - If we've removed a condition with subquery predicate, EXPLAIN [EXTENDED] won't show the subquery anymore
      
      sql/item.cc:
        MWL#17: Table elimination
        - Add tem_field::check_column_usage_processor(). it allows to check which key parts a condition depends on.
      sql/item.h:
        MWL#17: Table elimination
        - Add tem_field::check_column_usage_processor(). it allows to check which key parts a condition depends on.
      sql/item_subselect.cc:
        MWL#17: Table elimination
        - Item_subselect got 'eliminated' attribute. It is used only to determine if the subselect should be printed by EXPLAIN.
        - Item_subselect got List<Item> refers_to - a list of item in the current select that are referred to from within the subselect.
        - Added Item_*::check_column_usage_processor(). it allows to check which key parts a condition depends on.
        - Added a comment about possible problem in Item_subselect::walk
      sql/item_subselect.h:
        MWL#17: Table elimination
        - Item_subselect got 'eliminated' attribute. It is used only to determine if the subselect should be printed by EXPLAIN.
        - Item_subselect got List<Item> refers_to - a list of item in the current select that are referred to from within the subselect.
        - Added Item_*::check_column_usage_processor(). it allows to check which key parts a condition depends on.
      sql/item_sum.cc:
        MWL#17: Table elimination
      sql/sql_lex.cc:
        MWL#17: Table elimination
      sql/sql_lex.h:
        MWL#17: Table elimination
      sql/sql_select.h:
        MWL#17: Table elimination
      9e65634b
  39. 09 Jun, 2009 2 commits
    • Sergey Petrunia's avatar
      MWL#17: Table elimination · fd485ad9
      Sergey Petrunia authored
      - Make elimination work with aggregate functions. The problem was that aggregate functions 
        reported all table bits in used_tables(), and that prevented table elimination. Fixed by 
        making aggregate functions return more correct value from used_tables(). 
      
      mysql-test/r/ps_11bugs.result:
        MWL#17: Table elimination
        - Update test results. The difference is because of Item_ref change: outer references to constants
          are now recognized as constants, too.
      mysql-test/r/subselect.result:
        - Update test results. The difference is because of Item_ref change: outer references to constants
          are now recognized as constants, too.
      mysql-test/r/table_elim.result:
        MWL#17: Table elimination
        - Check that elimination works in presense of aggreagate functions
      mysql-test/t/table_elim.test:
        MWL#17: Table elimination
        - Check that elimination works in presense of aggreagate functions
      sql/item.h:
        MWL#17: Table elimination
        - Add Item_ref::const_item() which calls (*ref)->const_item(). Before this diff Item_ref used the 
          default implementation of const_item(){ return used_tables()==0; }. This is no longer true, as 
          COUNT(*) now has used_tables()==0 but const_item()==FALSE.
      sql/item_sum.cc:
        MWL#17: Table elimination
        - Make Item_sum() and it descendants not to return all bits in used_tables(). This is needed 
          because otherwise table elimination can't work in presense of aggregate functions
        - COUNT(*) now has used_tables()==0 and const_item()==FALSE. Had to change 
          Item_ref::const_item() to account for this.
      sql/item_sum.h:
        MWL#17: Table elimination
        - Add comments
      fd485ad9
    • Staale Smedseng's avatar
      Bug #43414 Parenthesis (and other) warnings compiling MySQL · a073ee45
      Staale Smedseng authored
      with gcc 4.3.2
            
      Compiling MySQL with gcc 4.3.2 and later produces a number of 
      warnings, many of which are new with the recent compiler
      versions.
            
      This bug will be resolved in more than one patch to limit the
      size of changesets. This is the first patch, fixing a number 
      of the warnings, predominantly "suggest using parentheses 
      around && in ||", and empty for and while bodies.
      a073ee45