An error occurred fetching the project authors.
  1. 12 Jan, 2012 1 commit
    • Alexander Barkov's avatar
      BUG#13354387 - CRASH IN IN MY_DECIMAL::OPERATOR FOR VIEW AND FUNCTION UNIX_TIME · dacd7424
      Alexander Barkov authored
      Fixing the 5.5 part (the 5.6 part will go in a separate commit soon).
      
      Problem:
        Item_direct_ref::get_date() incorrectly calculated its "null_value",
        which made UNIX_TIMESTAMP(view_column) incorrectly return NULL
        for a NOT NULL view_column.
      
      Fix:
        Make Item_direct_ref::get_date() calculate null_value
        in the similar way with the other methods 
        (val_real,val_str,val_int,val_decimal):
        copy null_value from the referenced Item.
      
      modified:
        mysql-test/r/func_time.result
        mysql-test/t/func_time.test
        sql/item.cc
      dacd7424
  2. 05 Dec, 2011 1 commit
    • Tor Didriksen's avatar
      Bug#13013970 MORE CRASHES IN FIELD_BLOB::GET_KEY_IMAGE · 1d5607fc
      Tor Didriksen authored
      The predicate is re-written from
      ((`test`.`g1`.`a` = geometryfromtext('')) or ...
      to
      ((`test`.`g1`.`a` = <cache>(geometryfromtext(''))) or ...
      
      The range optimizer calls save_in_field_no_warnings, in order to fetch keys.
      save_in_field_no_warnings returns 0 because of the cache wrapper,
      and get_mm_leaf() proceeded to call Field_blob::get_key_image() 
      which accesses un-initialized data.
      
      
      
      
      mysql-test/r/gis.result:
        New test case.
      mysql-test/t/gis.test:
        New test case.
      sql/item.cc:
        If we have cached a null_value, then verify that the Field can accept it.
      1d5607fc
  3. 30 Jun, 2011 1 commit
  4. 11 May, 2011 1 commit
    • Georgi Kodinov's avatar
      Bug #11744875: 4082: integer lengths cause truncation with distinct concat · b5ef16eb
      Georgi Kodinov authored
      and innodb
      
      The 5.5 version of the patch.
      
      The server doesn't restrict the data that can be inserted into integer columns 
      with explicitly specified length that's smaller than what the type can handle,
      e.g. 1234 can be inserted into an INT(2) column just fine.
      Thus, when calcualting the maximum width of expressions involving such 
      restricted integer columns we need to use the implicit maximum width of 
      the field instead of the explicitly speficied one.
      Fixed the server to use the implicit maximum in such cases and made sure 
      the implicit maximum is addjusted the same way as the explicit one wrt
      signedness.
      
      Fixed several test case results (ctype_*.result, metadata.result and 
      type_ranges.result) to reflect the extended column widths.
      
      Added a regression test case in distinct.test.
      
      Note : this is the behavior preserving fix that makes 5.5 behave as 5.1 and 
      earlier. In the mysql trunk we'll add a insert time check for the explict 
      maximum size.
      b5ef16eb
  5. 09 May, 2011 1 commit
    • Alexander Nozdrin's avatar
      Patch for Bug#12362125 (SP INOUT HANDLING IS BROKEN FOR TEXT TYPE). · 542c88c8
      Alexander Nozdrin authored
      Attempts to assign value to a table column from trigger by using
      NEW.column_name pseudo-variable might result in garbled data.
      That happened when:
        - the column had a BLOB-based type (e.g. TEXT)
          and
        - the value being assigned was retrieved from stored routine variable
          of the same type.
      
      The problem was that BLOB values were not copied correctly in this
      case. Instead of doing a copy of a real value, the value's representation
      in record buffer was copied. This representation is essentially a
      pointer to a buffer associated with the virtual table for routine
      variables where the real value is stored. Since this buffer got
      freed once trigger was left or could have changed its contents when
      new value was assigned to corresponding routine variable such a shallow
      copying resulted in garbled data in NEW.colum_name column.
      
      It worked in 5.1 due to a subtle bug in create_virtual_tmp_table():
        - in 5.1 create_virtual_tmp_table() returned a table which
          had db_low_byte_first == false.
        - in 5.5 and up create_virtual_tmp_table() returns a table which
          has db_low_byte_first == true.
      Actually, db_low_byte_first == false only for ISAM storage engine,
      which was deprecated and removed in 5.0.
      
      Having db_low_byte_first == false led to getting false in the
      complex condition for the 2nd "if" in field_conv(), which in turn
      led to copy-blob-behavior as a fall-back strategy:
        - to->table->s->db_low_byte_first was true (correct value)
        - from->table->s->db_low_byte_first was false (incorrect value)
      
      In 5.5 and up that condition is true, which means blob-values are
      not copied.
      542c88c8
  6. 06 May, 2011 2 commits
    • Alexander Nozdrin's avatar
      Patch for Bug#11848763 / 60025 · f9a86592
      Alexander Nozdrin authored
      (SUBSTRING inside a stored function works too slow).
      
      The user-visible problem was that the server started to consume memory if a
      stored-routine of some sort is executed subsequently. The memory was freed
      only after the corresponding connection was closed.
      
      Technically, the problem was that the memory needed for temporary string
      conversions was allocated on the connection ("persistent") memory root,
      instead of statement one.
      
      The root cause of this problem was the incorrect patch for Bug 55744.
      That patch wrongly fixed a crash in prepared-statement-mode introduced by
      another patch. The patch for Bug 55744 used wrong condition to check if
      prepared statement mode is active (or whether the connection-scoped or
      statement-scoped memory root should be used). The thing is that for
      prepared statements such conversions should be done in the connection
      memory root, so that that the transformations of item-tree were correctly
      remembered in the PREPARE-phase.
      
      The fix is to use proper condition to detect prepared-statement-mode and
      use proper memory root.
      f9a86592
    • Alexander Nozdrin's avatar
      Preliminary patch for Bug#11848763 / 60025 · 1df8afdc
      Alexander Nozdrin authored
      (SUBSTRING inside a stored function works too slow).
      
      Background:
        - THD classes derives from Query_arena, thus inherits the 'state'
          attribute and related operations (is_stmt_prepare() & co).
      
        - Although these operations are available in THD, they must not
          be used. THD has its own attribute to point to the active
          Query_arena -- stmt_arena.
      
        - So, instead of using thd->is_stmt_prepare(),
          thd->stmt_arena->is_stmt_prepare() must be used. This was the root
          cause of Bug 60025.
      
      This patch enforces the proper way of calling those operations.
      is_stmt_prepare() & co are declared as private operations
      in THD (thus, they are hidden from being called on THD instance).
      
      The patch tries to minimize changes in 5.5.
      1df8afdc
  7. 04 May, 2011 1 commit
    • Tor Didriksen's avatar
      Bug#12329653 - EXPLAIN, UNION, PREPARED STATEMENT, CRASH, SQL_FULL_GROUP_BY · ab3c7688
      Tor Didriksen authored
      The query was re-written *after* we had tagged it with NON_AGG_FIELD_USED.
      Remove the flag before continuing.
      
      
      mysql-test/r/explain.result:
        Update test case for Bug#48295.
      mysql-test/r/subselect.result:
        New test case.
      mysql-test/t/explain.test:
        Update test case for Bug#48295.
      mysql-test/t/subselect.test:
        New test case.
      sql/item.cc:
        Use accessor functions for non_agg_field_used/agg_func_used.
      sql/item_subselect.cc:
        Remove non_agg_field_used when we rewrite query '1 < some (...)' => '1 < max(...)'
      sql/item_sum.cc:
        Use accessor functions for non_agg_field_used/agg_func_used.
      sql/mysql_priv.h:
        Remove unused #defines.
      sql/sql_lex.cc:
        Initialize new member variables.
      sql/sql_lex.h:
        Replace full_group_by_flag with two boolean flags,
        and itroduce accessors for manipulating them.
      sql/sql_select.cc:
        Use accessor functions for non_agg_field_used/agg_func_used.
      ab3c7688
  8. 08 Apr, 2011 2 commits
    • Alexander Barkov's avatar
      Bug#11926811 / Bug#60625 Illegal mix of collations · 6d4d2158
      Alexander Barkov authored
      Problem: comparison of a DATETIME sp variable and NOW()
      led to Illegal mix of collations error when 
      character_set_connection=utf8.
      Introduced by "WL#2649 Number-to-string conversions".
      
      Error happened in Arg_comparator::set_compare_func(),
      because the first argument was errouneously converted to utf8,
      while the second argument was not.
      
      Fix: separate agg_arg_charsets_for_comparison() into two functions:
      
      - agg_arg_charsets_for_comparison() - for pure comparison,
        when we don't need to return any string result and therefore
        don't need to convert arguments to @@character_set_connection:
          SELECT a = b;
      
      - agg_arg_charsets_for_string_results_with_comparison() - when
        we need to return a string result, but we also need to do
        comparison internally: SELECT REPLACE(a,b,c)
        If all arguments are numbers:
          SELECT REPLACE(123,2,3) -> 133
        we convert arguments to @@character_set_connection.
      
      
        @ mysql-test/include/ctype_numconv.inc
        @ mysql-test/r/ctype_binary.result
        @ mysql-test/r/ctype_cp1251.result
        @ mysql-test/r/ctype_latin1.result
        @ mysql-test/r/ctype_ucs.result
        @ mysql-test/r/ctype_utf8.result
        Adding tests
      
        @ sql/item.cc
        @ sql/item.h
        @ sql/item_func.cc
        @ sql/item_func.h
        @ sql/item_strfunc.cc
      
        Introducing and using new function
         agg_item_charsets_for_string_result_with_comparison() and
        its Item_func wrapper agg_arg_charsets_for_string_result_with_comparison().
      6d4d2158
    • Gleb Shchepa's avatar
      Bug #11829681 - 60295: ERROR 1356 ON VIEW THAT EXECUTES FINE AS A QUERY · c64d72f3
      Gleb Shchepa authored
      Select from a view with the underlying HAVING clause failed with a
      message: "1356: View '...' references invalid table(s) or column(s)
      or function(s) or definer/invoker of view lack rights to use them"
      
      The bug is a regression of the fix for bug 11750328 - 40825 (similar
      case, but the HAVING cause references an aliased field).
      In the old fix for bug 40825 the Item_field::name_length value has
      been used in place of the real length of Item_field::name. However,
      in some cases Item_field::name_length is not in sync with the
      actual name length (TODO: combine name and name_length into a
      solid String field).
      
      The Item_ref::print() method has been modified to calculate actual
      name length every time.
      
      
      mysql-test/r/view.result:
        Test case for bug #11829681
      mysql-test/t/view.test:
        Test case for bug #11829681
      sql/item.cc:
        Bug #11829681 - 60295: ERROR 1356 ON VIEW THAT EXECUTES FINE AS A QUERY
        
        The Item_ref::print() method has been modified to calculate actual
        name length every time.
      sql/item.h:
        Minor commentary.
      c64d72f3
  9. 31 Mar, 2011 1 commit
    • Gleb Shchepa's avatar
      Bug #11766094 - 59132: MIN() AND MAX() REMOVE UNSIGNEDNESS · 43a1bda6
      Gleb Shchepa authored
      In the string context the MIN() and MAX() functions don't take
      into account the unsignedness of the UNSIGNED BIGINT argument
      column.
      
      I.e.:
              CREATE TABLE t1 (a BIGINT UNSIGNED);
              INSERT INTO t1 VALUES (18446668621106209655);
              SELECT CONCAT(MAX(a)) FROM t1;
      
      returns -75452603341961.
      
      
      mysql-test/r/func_group.result:
        Test case for bug #11766094.
      mysql-test/t/func_group.test:
        Test case for bug #11766094.
      sql/item.cc:
        Bug #11766094 - 59132: MIN() AND MAX() REMOVE UNSIGNEDNESS
        
        The Item_cache_int::val_str() method has been modified to
        take into account the unsigned_flag value when converting
        data to string.
      43a1bda6
  10. 30 Mar, 2011 1 commit
  11. 15 Mar, 2011 1 commit
    • Dmitry Shulga's avatar
      Fixed Bug#11764168 "56976: SEVERE DENIAL OF SERVICE IN PREPARED STATEMENTS". · 0dd27502
      Dmitry Shulga authored
      The problem was that server didn't check resulting size of prepared
      statement argument which was set using mysql_send_long_data() API.
      By calling mysql_send_long_data() several times it was possible
      to create overly big string and thus force server to allocate
      memory for it. There was no way to limit this allocation.
      
      The solution is to add check for size of result string against
      value of max_long_data_size start-up parameter. When intermediate
      string exceeds max_long_data_size value an appropriate error message
      is emitted.
      
      We can't use existing max_allowed_packet parameter for this purpose
      since its value is limited by 1GB and therefore using it as a limit
      for data set through mysql_send_long_data() API would have been an
      incompatible change. Newly introduced max_long_data_size parameter
      gets value from max_allowed_packet parameter unless its value is
      specified explicitly. This new parameter is marked as deprecated
      and will be eventually replaced by max_allowed_packet parameter.
      Value of max_long_data_size parameter can be set only at server
      startup.
      
      
      mysql-test/t/variables.test:
        Added checking for new start-up parameter max_long_data_size.
      sql/item.cc:
        Added call to my_message() when accumulated string exceeds
        max_long_data_size value. my_message() calls error handler
        that was installed in mysql_stmt_get_longdata before call
        to Item_param::set_longdata.
        
        The error handler then sets state, last_error and last_errno
        fields for current statement to values which correspond to
        error which was caught.
      sql/mysql_priv.h:
        Added max_long_data_size variable declaration.
      sql/mysqld.cc:
        Added support for start-up parameter 'max_long_data_size'.
        This parameter limits size of data which can be sent from
        client to server using mysql_send_long_data() API.
      sql/set_var.cc:
        Added variable 'max_long_data_size' into list of variables
        displayed by command 'show variables'.
      sql/sql_prepare.cc:
        Added error handler class Set_longdata_error_handler.
        This handler is used to catch any errors that can be
        generated during execution of Item_param::set_longdata().
        
        Source code snippet that makes checking for statement's state 
        during statement execution is moved from Prepared_statement::execute()
        to Prepared_statement::execute_loop() in order not to call
        set_parameters() when statement has failed during
        set_long_data() execution. If this hadn't been done
        the call to set_parameters() would have failed.
      tests/mysql_client_test.c:
        A testcase for the bug #56976 was added.
      0dd27502
  12. 04 Mar, 2011 1 commit
    • Alexander Barkov's avatar
      Bug#11764503 (Bug#57341) Query in EXPLAIN EXTENDED shows wrong characters · 1010315b
      Alexander Barkov authored
        @ mysql-test/r/ctype_latin1.result
        @ mysql-test/r/ctype_utf8.result
        @ mysql-test/t/ctype_latin1.test
        @ mysql-test/t/ctype_utf8.test
        Adding tests
      
        @ sql/mysqld.h
        @ sql/item.cc
        @ sql/sql_parse.cc
        @ sql/sql_view.cc
      
        Refactoring (thanks to Guilhem for the idea):
      
        Item_string::print() was hard to understand because of the different
        QT_ constants: in "query_type==QT_x", QT_x is explicitely included
        but the other two QT_ are implicitely excluded. The combinations
        with '||' and '&&' make this even harder.
        - logic is now more "explicit" by changing QT_ constants to a bitmap of flags:
          QT_ORDINARY: no change,
          QT_IS -> QT_TO_SYSTEM_CHARSET | QT_WITHOUT_INTRODUCERS,
          QT_EXPLAIN -> QT_TO_SYSTEM_CHARSET
          (QT_EXPLAIN was introduced in the first version of the Bug#57341 patch)
        - Item_string::print() is rewritten using those flags
      
        Bugfix itself:
      
        When QT_TO_SYSTEM_CHARSET is used alone (with no QT_WITHOUT_INTRODUCERS),
        we print string literals as follows:
      
        - display introducers if they were in the original query
        - print ASCII characters as is
        - print non-ASCII characters using hex-escape
        Note: as "EXPLAIN" output is only for human readability purposes
        and does not need to be a pasrable SQL, so using hex-escape is Ok.
        ErrConvString class perfectly suites for hex escaping purposes.
      1010315b
  13. 17 Feb, 2011 1 commit
    • Tor Didriksen's avatar
      Bug #11766860 - 60085: CRASH IN ITEM::SAVE_IN_FIELD() WITH TIME DATA TYPE · 8176dec7
      Tor Didriksen authored
      This assumption in Item_cache_datetime::cache_value_int
      was wrong:
      -  /* Assume here that the underlying item will do correct conversion.*/
      -  int_value= example->val_int_result();
      
      
      mysql-test/r/subselect_innodb.result:
        New test case.
      mysql-test/t/subselect_innodb.test:
        New test case.
      sql/item.cc:
        In Item_cache_datetime::cache_value_int()
         - call get_time() or get_date() depending on desired type
         - convert the returned MYSQL_TIME value to longlong depending on desired type
      sql/item.h:
        The cached int_value in Item_cache_datetime should not be unsigned:
         - it is used mostly in signed context
         - it can actually have negative value (for TIME data type)
      sql/item_cmpfunc.cc:
        Add comment on Bug#59685
      sql/item_subselect.cc:
        Add some DBUG_TRACE for easier bug-hunting.
      8176dec7
  14. 09 Feb, 2011 1 commit
    • MySQL Build Team's avatar
      Backport into build-201102032246-5.1.52sp1 · 33e74cf1
      MySQL Build Team authored
      > ------------------------------------------------------------
      > revno: 3520
      > revision-id: sergey.glukhov@oracle.com-20101214093303-wmo9mqcb8rz0wv9f
      > parent: tor.didriksen@oracle.com-20101213161301-81lprlbune7r98dl
      > committer: Sergey Glukhov <sergey.glukhov@oracle.com>
      > branch nick: mysql-5.1-bugteam
      > timestamp: Tue 2010-12-14 12:33:03 +0300
      > message:
      >   Fixed following problems:
      >   --Bug#52157 various crashes and assertions with multi-table update, stored function
      >   --Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb
      >   --Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846
      >   --Bug#57352 valgrind warnings when creating view
      >   --Recently discovered problem when a nested materialized derived table is used
      >     before being populated and it leads to incorrect result
      >   
      >   We have several modes when we should disable subquery evaluation.
      >   The reasons for disabling are different. It could be
      >   uselessness of the evaluation as in case of 'CREATE VIEW'
      >   or 'PREPARE stmt', or we should disable subquery evaluation
      >   if tables are not locked yet as it happens in bug#54475, or
      >   too early evaluation of subqueries can lead to wrong result
      >   as it happened in Bug#19077.
      >   Main problem is that if subquery items are treated as const
      >   they are evaluated in ::fix_fields(), ::fix_length_and_dec()
      >   of the parental items as a lot of these methods have
      >   Item::val_...() calls inside.
      >   We have to make subqueries non-const to prevent unnecessary
      >   subquery evaluation. At the moment we have different methods
      >   for this. Here is a list of these modes:
      >   
      >   1. PREPARE stmt;
      >   We use UNCACHEABLE_PREPARE flag.
      >   It is set during parsing in sql_parse.cc, mysql_new_select() for
      >   each SELECT_LEX object and cleared at the end of PREPARE in
      >   sql_prepare.cc, init_stmt_after_parse(). If this flag is set
      >   subquery becomes non-const and evaluation does not happen.
      >   
      >   2. CREATE|ALTER VIEW, SHOW CREATE VIEW, I_S tables which
      >      process FRM files
      >   We use LEX::view_prepare_mode field. We set it before
      >   view preparation and check this flag in
      >   ::fix_fields(), ::fix_length_and_dec().
      >   Some bugs are fixed using this approach,
      >   some are not(Bug#57352, Bug#57703). The problem here is
      >   that we have a lot of ::fix_fields(), ::fix_length_and_dec()
      >   where we use Item::val_...() calls for const items.
      >   
      >   3. Derived tables with subquery = wrong result(Bug19077)
      >   The reason of this bug is too early subquery evaluation.
      >   It was fixed by adding Item::with_subselect field
      >   The check of this field in appropriate places prevents
      >   const item evaluation if the item have subquery.
      >   The fix for Bug19077 fixes only the problem with
      >   convert_constant_item() function and does not cover
      >   other places(::fix_fields(), ::fix_length_and_dec() again)
      >   where subqueries could be evaluated.
      >   
      >   Example:
      >   CREATE TABLE t1 (i INT, j BIGINT);
      >   INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2);
      >   SELECT * FROM (SELECT MIN(i) FROM t1
      >   WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3;
      >   DROP TABLE t1;
      >   
      >   4. Derived tables with subquery where subquery
      >      is evaluated before table locking(Bug#54475, Bug#52157)
      >   
      >   Suggested solution is following:
      >   
      >   -Introduce new field LEX::context_analysis_only with the following
      >    possible flags:
      >    #define CONTEXT_ANALYSIS_ONLY_PREPARE 1
      >    #define CONTEXT_ANALYSIS_ONLY_VIEW    2
      >    #define CONTEXT_ANALYSIS_ONLY_DERIVED 4
      >   -Set/clean these flags when we perform
      >    context analysis operation
      >   -Item_subselect::const_item() returns
      >    result depending on LEX::context_analysis_only.
      >    If context_analysis_only is set then we return
      >    FALSE that means that subquery is non-const.
      >    As all subquery types are wrapped by Item_subselect
      >    it allow as to make subquery non-const when
      >    it's necessary.
      33e74cf1
  15. 12 Jan, 2011 1 commit
    • Evgeny Potemkin's avatar
      Bug#59330: Incorrect result when comparing an aggregate function with · 5c56bce3
      Evgeny Potemkin authored
      TIMESTAMP.
      
      Item_cache::get_cache wasn't treating TIMESTAMP as a DATETIME value thus
      returning string cache for items with TIMESTAMP type. This led to incorrect
      TIMESTAMP -> INT conversion and to a wrong query result.
      
      Fixed by using Item::is_datetime function to check for DATETIME type group.
      
      
      mysql-test/r/type_timestamp.result:
        Added a test case for the bug#59330.
      mysql-test/t/type_timestamp.test:
        Added a test case for the bug#59330.
      sql/item.cc:
        Bug#59330: Incorrect result when comparing an aggregate function with
        TIMESTAMP.
        Item_cache::get_cache now uses is_datetime member function to detect DATETIME
        type group.
      5c56bce3
  16. 21 Dec, 2010 1 commit
    • Sergey Glukhov's avatar
      Bug#58030 crash in Item_func_geometry_from_text::val_str · 8246b5a4
      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.
      8246b5a4
  17. 14 Dec, 2010 1 commit
    • Sergey Glukhov's avatar
      Fixed following problems: · dda99909
      Sergey Glukhov authored
      --Bug#52157 various crashes and assertions with multi-table update, stored function
      --Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb
      --Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846
      --Bug#57352 valgrind warnings when creating view
      --Recently discovered problem when a nested materialized derived table is used
        before being populated and it leads to incorrect result
      
      We have several modes when we should disable subquery evaluation.
      The reasons for disabling are different. It could be
      uselessness of the evaluation as in case of 'CREATE VIEW'
      or 'PREPARE stmt', or we should disable subquery evaluation
      if tables are not locked yet as it happens in bug#54475, or
      too early evaluation of subqueries can lead to wrong result
      as it happened in Bug#19077.
      Main problem is that if subquery items are treated as const
      they are evaluated in ::fix_fields(), ::fix_length_and_dec()
      of the parental items as a lot of these methods have
      Item::val_...() calls inside.
      We have to make subqueries non-const to prevent unnecessary
      subquery evaluation. At the moment we have different methods
      for this. Here is a list of these modes:
      
      1. PREPARE stmt;
      We use UNCACHEABLE_PREPARE flag.
      It is set during parsing in sql_parse.cc, mysql_new_select() for
      each SELECT_LEX object and cleared at the end of PREPARE in
      sql_prepare.cc, init_stmt_after_parse(). If this flag is set
      subquery becomes non-const and evaluation does not happen.
      
      2. CREATE|ALTER VIEW, SHOW CREATE VIEW, I_S tables which
         process FRM files
      We use LEX::view_prepare_mode field. We set it before
      view preparation and check this flag in
      ::fix_fields(), ::fix_length_and_dec().
      Some bugs are fixed using this approach,
      some are not(Bug#57352, Bug#57703). The problem here is
      that we have a lot of ::fix_fields(), ::fix_length_and_dec()
      where we use Item::val_...() calls for const items.
      
      3. Derived tables with subquery = wrong result(Bug19077)
      The reason of this bug is too early subquery evaluation.
      It was fixed by adding Item::with_subselect field
      The check of this field in appropriate places prevents
      const item evaluation if the item have subquery.
      The fix for Bug19077 fixes only the problem with
      convert_constant_item() function and does not cover
      other places(::fix_fields(), ::fix_length_and_dec() again)
      where subqueries could be evaluated.
      
      Example:
      CREATE TABLE t1 (i INT, j BIGINT);
      INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2);
      SELECT * FROM (SELECT MIN(i) FROM t1
      WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3;
      DROP TABLE t1;
      
      4. Derived tables with subquery where subquery
         is evaluated before table locking(Bug#54475, Bug#52157)
      
      Suggested solution is following:
      
      -Introduce new field LEX::context_analysis_only with the following
       possible flags:
       #define CONTEXT_ANALYSIS_ONLY_PREPARE 1
       #define CONTEXT_ANALYSIS_ONLY_VIEW    2
       #define CONTEXT_ANALYSIS_ONLY_DERIVED 4
      -Set/clean these flags when we perform
       context analysis operation
      -Item_subselect::const_item() returns
       result depending on LEX::context_analysis_only.
       If context_analysis_only is set then we return
       FALSE that means that subquery is non-const.
       As all subquery types are wrapped by Item_subselect
       it allow as to make subquery non-const when
       it's necessary.
      
      
      mysql-test/r/derived.result:
        test case
      mysql-test/r/multi_update.result:
        test case
      mysql-test/r/view.result:
        test case
      mysql-test/suite/innodb/r/innodb_multi_update.result:
        test case
      mysql-test/suite/innodb/t/innodb_multi_update.test:
        test case
      mysql-test/suite/innodb_plugin/r/innodb_multi_update.result:
        test case
      mysql-test/suite/innodb_plugin/t/innodb_multi_update.test:
        test case
      mysql-test/t/derived.test:
        test case
      mysql-test/t/multi_update.test:
        test case
      mysql-test/t/view.test:
        test case
      sql/item.cc:
        --removed unnecessary code
      sql/item_cmpfunc.cc:
        --removed unnecessary checks
        --THD::is_context_analysis_only() is replaced with LEX::is_ps_or_view_context_analysis()
      sql/item_func.cc:
        --refactored context analysis checks
      sql/item_row.cc:
        --removed unnecessary checks
      sql/item_subselect.cc:
        --removed unnecessary code
        --added DBUG_ASSERT into Item_subselect::exec()
          which asserts that subquery execution can not happen
          if LEX::context_analysis_only is set, i.e. at context
          analysis stage.
        --Item_subselect::const_item()
          Return FALSE if LEX::context_analysis_only is set.
          It prevents subquery evaluation in ::fix_fields &
          ::fix_length_and_dec at context analysis stage.
      sql/item_subselect.h:
        --removed unnecessary code
      sql/mysql_priv.h:
        --Added new set of flags.
      sql/sql_class.h:
        --removed unnecessary code
      sql/sql_derived.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_lex.cc:
        --init LEX::context_analysis_only field
      sql/sql_lex.h:
        --New LEX::context_analysis_only field
      sql/sql_parse.cc:
        --removed unnecessary code
      sql/sql_prepare.cc:
        --removed unnecessary code
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_select.cc:
        --refactored context analysis checks
      sql/sql_show.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      sql/sql_view.cc:
        --added LEX::context_analysis_only analysis intialization/cleanup
      dda99909
  18. 19 Nov, 2010 1 commit
  19. 18 Nov, 2010 1 commit
    • Alexander Barkov's avatar
      Bug#57279 updatexml dies with: Assertion failed: str_arg[length] == 0 · 57a40b19
      Alexander Barkov authored
      Problem: crash in Item_float constructor on DBUG_ASSERT due
      to not null-terminated string parameter.
      
      Fix: making Item_float::Item_float non-null-termintated parameter safe:
      - Using temporary buffer when generating error
      
      modified:
        @ mysql-test/r/xml.result
        @ mysql-test/t/xml.test
        @ sql/item.cc
      57a40b19
  20. 13 Nov, 2010 1 commit
    • Alexander Nozdrin's avatar
      Fix for Bug#56934 (mysql_stmt_fetch() incorrectly fills MYSQL_TIME · 6bf734f8
      Alexander Nozdrin authored
      structure buffer).
      
      This is a follow-up for WL#4435. The bug actually existed not only
      MYSQL_TYPE_DATETIME type. The problem was that Item_param::set_value()
      was written in an assumption that it's working with expressions, i.e.
      with basic data types.
      
      There are two different quick fixes here:
        a) Change Item_param::make_field() -- remove setting of
           Send_field::length, Send_field::charsetnr, Send_field::flags and
           Send_field::type.
      
           That would lead to marshalling all data using basic types to the client
           (MYSQL_TYPE_LONGLONG, MYSQL_TYPE_DOUBLE, MYSQL_TYPE_STRING and
           MYSQL_TYPE_NEWDECIMAL). In particular, that means, DATETIME would be
           sent as MYSQL_TYPE_STRING, TINYINT -- as MYSQL_TYPE_LONGLONG, etc.
      
           That could be Ok for the client, because the client library does
           reverse conversion automatically (the client program would see DATETIME
           as MYSQL_TIME object). However, there is a problem with metadata --
           the metadata would be wrong (misleading): it would say that DATETIME is
           marshaled as MYSQL_TYPE_DATETIME, not as MYSQL_TYPE_STRING.
      
        b) Set Item_param::param_type properly to actual underlying field type.
           That would lead to double conversion inside the server: for example,
           MYSQL_TIME-object would be converted into STRING-object
           (in Item_param::set_value()), and then converted back to MYSQL_TIME-object
           (in Item_param::send()).
      
           The data however would be marshalled more properly, and also metadata would
           be correct.
      
      This patch implements b).
      
      There is also a possibility to avoid double conversion either by clonning
      the data field, or by storing a reference to it and using it on Item::send()
      time. That requires more work and might be done later.
      6bf734f8
  21. 04 Nov, 2010 2 commits
    • Evgeny Potemkin's avatar
      Bug#57278: Crash on min/max + with date out of range. · 8b42211a
      Evgeny Potemkin authored
      MySQL officially supports DATE values starting from 1000-01-01. This is
      enforced for int values, but not for string values, thus one
      could easily insert '0001-01-01' value. Int values are checked by
      number_to_datetime function and Item_cache_datetime::val_str uses it
      to fill MYSQL_TIME struct out of cached int value. This leads to the
      scenario where Item_cache_datetime caches a non-null datetime value and when
      it tries to convert it from int to string number_to_datetime function
      treats the value as out-of-range and returns an error and
      Item_cache_datetime::val_str returns NULL for a non-null value. Due to this
      inconsistency server crashes.
      
      Now number_to_datetime allows DATE values below 1000-01-01 if the
      TIME_FUZZY_DATE flag is set. Better NULL handling for Item_cache_datetime.
      Added the Item_cache_datetime::store function to reset str_value_cached flag
      when an item is stored.
      
      mysql-test/r/type_date.result:
        Added a test case for the bug#57278.
      mysql-test/t/type_date.test:
        Added a test case for the bug#57278.
      sql-common/my_time.c:
        Bug#57278: Crash on min/max + with date out of range.
        Now number_to_datetime allows DATE values below 1000-01-01 if the
        TIME_FUZZY_DATE flag is set.
      sql/item.cc:
        Bug#57278: Crash on min/max + with date out of range.
        Item_cache_datetime::val_str now better handles
        null_value.
      8b42211a
    • Jorgen Loland's avatar
      Bug#57882 - Item_func_conv_charset::val_str(String*): · ca44833d
      Jorgen Loland authored
                  Assertion `fixed == 1' failed
      
      (also fixes duplicate bug 57515)
      
      agg_item_set_converter() (item.cc) handles conversion of 
      character sets by creating a new Item. fix_fields() is then 
      called on this newly created item. Prior to this patch, it was
      not checked whether fix_fields() was successful or not. Thus, 
      agg_item_set_converter() would return success even when an 
      error occured. This patch makes it return error (TRUE) if 
      fix_fields() fails.
      
      mysql-test/r/errors.result:
        Add test for BUG#57882
      mysql-test/t/errors.test:
        Add test for BUG#57882
      sql/item.cc:
        Make agg_item_set_converter() return with error if fix_fields() 
        on the newly created converted item fails.
      ca44833d
  22. 08 Oct, 2010 1 commit
    • Alexander Barkov's avatar
      The fix for · 3be64d25
      Alexander Barkov authored
       Bug#55744 GROUP_CONCAT + CASE + ucs return garbage
      revealed problems in how character set aggregation
      code works with prepared statements.
      
      This patch fixes (hopefully) the problems.
      3be64d25
  23. 07 Oct, 2010 1 commit
    • Evgeny Potemkin's avatar
      Bug#57095: Wrongly chosen expression cache type led to a wrong result. · 9c6b27af
      Evgeny Potemkin authored
      The coalesce function returned DATETIME type due to a DATETIME argument, but
      since it's not a date/time function it can't return correct int value for
      it. Nevertheless Item_datetime_cache was chosen to cache coalesce's result
      and that led to a wrong result.
      
      Now Item_datetime_cache is used only for those function that could return
      correct int representation of DATETIME values.
      
      
      mysql-test/r/type_datetime.result:
        Added a test case for the bug#57095.
      mysql-test/t/type_datetime.test:
        Added a test case for the bug#57095.
      sql/item.cc:
        Bug#57095: Wrongly chosen expression cache type led to a wrong result.
        Now Item_datetime_cache is used only for those function that could return
        correct int representation of DATETIME values.
      9c6b27af
  24. 13 Sep, 2010 1 commit
    • Gleb Shchepa's avatar
      Bug #55779: select does not work properly in mysql server · 9d68a0d6
      Gleb Shchepa authored
                  Version "5.1.42 SUSE MySQL RPM"
      
      When a query was using a DATE or DATETIME value formatted
      using different formatting than "yyyy-mm-dd HH:MM:SS", a
      query with a greater-or-equal '>=' condition matched only
      greater values in an indexed TIMESTAMP column.
      
      The problem was introduced by the fix for the bug 46362
      and partially solved (for DATE and DATETIME columns only)
      by the fix for the bug 47925.
      
      The stored_field_cmp_to_item function has been modified
      to take into account TIMESTAMP columns like we do for
      DATE and DATETIME columns.
      
      
      mysql-test/r/type_timestamp.result:
        Test case for bug #55779.
      mysql-test/t/type_timestamp.test:
        Test case for bug #55779.
      sql/item.cc:
        Bug #55779: select does not work properly in mysql server
                    Version "5.1.42 SUSE MySQL RPM"
        
        The stored_field_cmp_to_item function has been modified
        to take into account TIMESTAMP columns like we do for
        DATE and DATETIME.
      9d68a0d6
  25. 09 Sep, 2010 1 commit
    • Alexey Kopytov's avatar
      Addendum patch for bug #54190. · ecba60f6
      Alexey Kopytov authored
      The patch caused some test failures when merged to 5.5 because,
      unlike 5.1, it utilizes Item_cache_row to actually cache row
      values. The problem was that Item_cache_row::bring_value()
      essentially did nothing. In particular, it did not update its
      null_value, so all Item_cache_row objects were always having
      their null_values set to TRUE. This went unnoticed previously,
      but now when Arg_comparator::compare_row() actually depends on
      the row's null_value to evaluate the comparison, the problem
      has surfaced.
      
      Fixed by calling the underlying item's bring_value() and
      updating null_value in Item_cache_row::bring_value().
      
      Since the problem also exists in 5.1 code (albeit hidden, since
      the relevant code is not used anywhere), the addendum patch is
      against 5.1.
      ecba60f6
  26. 31 Aug, 2010 1 commit
  27. 25 Aug, 2010 2 commits
  28. 23 Aug, 2010 1 commit
    • Evgeny Potemkin's avatar
      Bug#56120: Failed assertion on MIX/MAX on negative time value · d214f3d6
      Evgeny Potemkin authored
      The Item_cache_datetime::val_str function wasn't taking into account that time
      could be negative. This led to failed assertion.
      Now Item_cache_datetime::val_str correctly converts negative time values
      from integer to string representation.
      
      mysql-test/r/func_group.result:
        Added a test case for the bug#56120.
      mysql-test/t/func_group.test:
        Added a test case for the bug#56120.
      sql/item.cc:
        Bug#56120: Failed assertion on MIX/MAX on negative time value
        Now Item_cache_datetime::val_str correctly converts negative time values
        from integer to string representation.
      d214f3d6
  29. 14 Aug, 2010 1 commit
    • Evgeny Potemkin's avatar
      Bug#49746: Const expression caching led to NDB not using engine condition · 3c282ea2
      Evgeny Potemkin authored
      pushdown.
            
      NDB supports only a limited set of item nodes for use in engine condition
      pushdown. Because of this adding cache for const expression effectively
      disabled this optimization.
            
      The ndb_serialize_cond function is extended to support Item_cache and treat
      it as a constant values.
      A helper function called ndb_serialize_const is added. It is used to create
      Ndb_cond value node from given const item.
      
      
      mysql-test/suite/ndb/t/disabled.def:
        Bug#49746: Const expression caching led to NDB not using engine condition
        pushdown.
        Enabled ndb_condition_pushdown test after fixing appropriate bug.
      sql/ha_ndbcluster_cond.cc:
        Bug#49746: Const expression caching led to NDB not using engine condition
        pushdown.
        The ndb_serialize_cond function is extended to support Item_cache and treat
        it as a constant values.
        A helper function called ndb_serialize_const is added. It is used to create
        Ndb_cond value node from given const item.
      sql/item.cc:
        Bug#49746: Const expression caching led to NDB not using engine condition
        pushdown.
        The Item::cache_const_expr_analyzer function is adjusted to not create
        cache for Item_int_with_ref objects.
      sql/item.h:
        Bug#49746: Const expression caching led to NDB not using engine condition
        pushdown.
        The result_type() method is added to Item_cache class.
        The Item_cache_str now initializes its collation.
      3c282ea2
  30. 02 Aug, 2010 1 commit
    • Evgeny Potemkin's avatar
      Bug#55648: Server crash on MIX/MAX on maximum time value · b7f8e896
      Evgeny Potemkin authored
      A typo in the Item_cache_datetime::val_str caused an assertion to fail on the
      maximum time value.
      
      
      mysql-test/r/func_group.result:
        A test case for the bug#55648.
      mysql-test/t/func_group.test:
        A test case for the bug#55648.
      sql/item.cc:
        Bug#55648: Server crash on MIX/MAX on maximum time value
        Corrected assertion.
      b7f8e896
  31. 20 Jul, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#45288: pb2 returns a lot of compilation warnings on linux · 450d34b7
      Davi Arnaut authored
      Fix warnings flagged by the new warning option -Wunused-but-set-variable
      that was added to GCC 4.6 and that is enabled by -Wunused and -Wall. The
      option causes a warning whenever a local variable is assigned to but is
      later unused. It also warns about meaningless pointer dereferences.
      
      client/mysql.cc:
        Meaningless pointer dereferences.
      client/mysql_upgrade.c:
        Check whether reading from the file succeeded.
      extra/comp_err.c:
        Unused.
      extra/yassl/src/yassl_imp.cpp:
        Skip instead of reading data that is discarded.
      include/my_pthread.h:
        Variable is only used in debug builds.
      include/mysys_err.h:
        Add new error messages.
      mysys/errors.c:
        Add new error message for permission related functions.
      mysys/mf_iocache.c:
        Variable is only checked under THREAD.
      mysys/my_copy.c:
        Raise a error if chmod or chown fails.
      mysys/my_redel.c:
        Raise a error if chmod or chown fails.
      regex/engine.c:
        Use a equivalent variable for the assert.
      server-tools/instance-manager/instance_options.cc:
        Unused.
      sql/field.cc:
        Unused.
      sql/item.cc:
        Unused.
      sql/log.cc:
        Do not ignore the return value of freopen: only set buffer if
        reopening succeeds.
        
        Adjust doxygen comment to the right function.
        
        Pass message lenght to log function.
      sql/mysqld.cc:
        Do not ignore the return value of freopen: only set buffer if
        reopening succeeds.
      sql/partition_info.cc:
        Unused.
      sql/slave.cc:
        No need to set pointer to the address of '\0'.
      sql/spatial.cc:
        Unused. Left for historical purposes.
      sql/sql_acl.cc:
        Unused.
      sql/sql_base.cc:
        Pointers are always set to the same variables.
      sql/sql_parse.cc:
        End statement if reading fails.
        
        Store the buffer after it has actually been updated.
      sql/sql_repl.cc:
        No need to set pointer to the address of '\0'.
      sql/sql_show.cc:
        Put variable under the same ifdef block.
      sql/udf_example.c:
        Set null pointer flag appropriately.
      storage/csv/ha_tina.cc:
        Meaningless dereferences.
      storage/example/ha_example.cc:
        Return the error since it's available.
      storage/myisam/mi_locking.c:
        Remove unused and dead code.
      450d34b7
  32. 19 Jul, 2010 1 commit
    • Evgeny Potemkin's avatar
      Bug#49771: Incorrect MIN/MAX for date/time values. · 2c1df29f
      Evgeny Potemkin authored
      This bug is a design flaw of the fix for the bug#33546. It assumed that an
      item can be used only in one comparison context, but actually it isn't the
      case. Item_cache_datetime is used to store result for MIX/MAX aggregate
      functions. Because Arg_comparator always compares datetime values as INTs when
      possible the Item_cache_datetime most time caches only INT value. But
      since all datetime values has STRING result type MIN/MAX functions are asked
      for a STRING value when the result is being sent to a client. The
      Item_cache_datetime was designed to avoid conversions and get INT/STRING
      values from an underlying item, but at the moment the values is asked
      underlying item doesn't hold it anymore thus wrong result is returned.
      Beside that MIN/MAX aggregate functions was wrongly initializing cached result
      and this led to a wrong result.
      
      The Item::has_compatible_context helper function is added. It checks whether
      this and given items has the same comparison context or can be compared as
      DATETIME values by Arg_comparator. The equality propagation optimization is
      adjusted to take into account that items which being compared as DATETIME
      can have different comparison contexts.
      The Item_cache_datetime now converts cached INT value to a correct STRING
      DATETIME value by means of number_to_datetime & my_TIME_to_str functions.
      The Arg_comparator::set_cmp_context_for_datetime helper function is added. 
      It sets comparison context of items being compared as DATETIMEs to INT if
      items will be compared as longlong.
      The Item_sum_hybrid::setup function now correctly initializes its result
      value.
      In order to avoid unnecessary conversions Item_sum_hybrid now states that it
      can provide correct longlong value if the item being aggregated can do it
      too.
      
      mysql-test/r/group_by.result:
        Added a test case for the bug#49771.
      sql/item.cc:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        The equality propagation mechanism is adjusted to take into account that
        items which being compared as DATETIME can have different comparison
        contexts.
        The Item_cache_datetime now converts cached INT value to a correct STRING
        DATETIME/TIME value.
      sql/item.h:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        The Item::has_compatible_context helper function is added. It checks whether
        this and given items has the same comparison context or can be compared as
        DATETIME values by Arg_comparator.
        Added Item_cache::clear helper function.
      sql/item_cmpfunc.cc:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        The Arg_comparator::set_cmp_func now sets the correct comparison context
        for items being compared as DATETIME values.
      sql/item_cmpfunc.h:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        The Arg_comparator::set_cmp_context_for_datetime helper function is added. 
        It sets comparison context of items being compared as DATETIMEs to INT if
        items will be compared as longlong.
      sql/item_sum.cc:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        The Item_sum_hybrid::setup function now correctly initializes its result
        value.
      sql/item_sum.h:
        Bug#49771: Incorrect MIN/MAX for date/time values.
        In order to avoid unnecessary conversions Item_sum_hybrid now states that it
        can provide correct longlong value if the item being aggregated can do it
        too.
      2c1df29f
  33. 02 Jul, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#53445: Build with -Wall and fix warnings that it generates · 1113efea
      Davi Arnaut authored
      Apart strict-aliasing warnings, fix the remaining warnings
      generated by GCC 4.4.4 -Wall and -Wextra flags.
      
      One major source of warnings was the in-house function my_bcmp
      which (unconventionally) took pointers to unsigned characters
      as the byte sequences to be compared. Since my_bcmp and bcmp
      are deprecated functions whose only difference with memcmp is
      the return value, every use of the function is replaced with
      memcmp as the special return value wasn't actually being used
      by any caller.
      
      There were also various other warnings, mostly due to type
      mismatches, missing return values, missing prototypes, dead
      code (unreachable) and ignored return values.
      
      BUILD/SETUP.sh:
        Remove flags that are implied by -Wall and -Wextra.
        Do not warn about unused parameters in C++.
      BUILD/check-cpu:
        Print only the compiler version instead of verbose banner.
        Although the option is gcc specific, the check was only
        being used for GCC specific checks anyway.
      client/mysql.cc:
        bcmp is no longer defined.
      client/mysqltest.cc:
        Pass a string to function expecting a format string.
        Replace use of bcmp with memcmp.
      cmd-line-utils/readline/Makefile.am:
        Always define _GNU_SOURCE when compiling GNU readline.
        Required to make certain prototypes visible.
      cmd-line-utils/readline/input.c:
        Condition for the code to be meaningful.
      configure.in:
        Remove check for bcmp.
      extra/comp_err.c:
        Use appropriate type.
      extra/replace.c:
        Replace use of bcmp with memcmp.
      extra/yassl/src/crypto_wrapper.cpp:
        Do not ignore the return value of fgets. Retrieve the file
        position if fgets succeed -- if it fails, the function will
        bail out and return a error.
      extra/yassl/taocrypt/include/blowfish.hpp:
        Use a single array instead of accessing positions of the sbox_
        through a subscript to pbox_.
      extra/yassl/taocrypt/include/runtime.hpp:
        One definition of such functions is enough.
      extra/yassl/taocrypt/src/aes.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/taocrypt/src/algebra.cpp:
        Rename arguments to avoid shadowing related warnings.
      extra/yassl/taocrypt/src/blowfish.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/taocrypt/src/integer.cpp:
        Do not define type within a anonymous union.
        Use a variable to return a value instead of
        leaving the result in a register -- compiler
        does not know the logic inside the asm.
      extra/yassl/taocrypt/src/misc.cpp:
        Define handler for pure virtual functions.
        Remove unused code.
      extra/yassl/taocrypt/src/twofish.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/testsuite/test.hpp:
        Function must have C language linkage.
      include/m_string.h:
        Remove check which relied on bcmp being defined -- they weren't
        being used as bcmp is only visible when _BSD_SOURCE is defined.
      include/my_bitmap.h:
        Remove bogus helpers which were used only in a few files and
        were causing warnings about dead code.
      include/my_global.h:
        Due to G++ bug, always silence false-positive uninitialized
        variables warnings when compiling C++ code with G++.
        Remove bogus helper.
      libmysql/Makefile.shared:
        Remove built-in implementation of bcmp.
      mysql-test/lib/My/SafeProcess/safe_process.cc:
        Cast pid to largest possible type for a process identifier.
      mysys/mf_loadpath.c:
        Leave space of the ending nul.
      mysys/mf_pack.c:
        Replace bcmp with memcmp.
      mysys/my_bitmap.c:
        Dead code removal.
      mysys/my_gethwaddr.c:
        Remove unused variable.
      mysys/my_getopt.c:
        Silence bogus uninitialized variable warning.
        Do not cast away the constant qualifier.
      mysys/safemalloc.c:
        Cast to expected type.
      mysys/thr_lock.c:
        Silence bogus uninitialized variable warning.
      sql/field.cc:
        Replace bogus helper with a more appropriate logic which is
        used throughout the code.
      sql/item.cc:
        Remove bogus logical condition which always evaluates to TRUE.
      sql/item_create.cc:
        Simplify code to avoid signedness related warnings.
      sql/log_event.cc:
        Replace use of bcmp with memcmp.
        No need to use helpers for simple bit operations.
      sql/log_event_old.cc:
        Replace bmove_align with memcpy.
      sql/mysqld.cc:
        Move use declaration of variable to the ifdef block where it
        is used. Remove now-unnecessary casts and arguments.
      sql/set_var.cc:
        Replace bogus helpers with simple and classic bit operations.
      sql/slave.cc:
        Cast to expected type and silence bogus warning.
      sql/sql_class.h:
        Don't use enum values as bit flags, the supposed type safety is
        bogus as the combined bit flags are not a value in the enumeration.
      sql/udf_example.c:
        Only declare variable when necessary.
      sql/unireg.h:
        Replace use of bmove_align with memcpy.
      storage/innobase/os/os0file.c:
        Silence bogus warning.
      storage/myisam/mi_open.c:
        Remove bogus cast, DBUG_DUMP expects a pointer to unsigned
        char.
      storage/myisam/mi_page.c:
        Remove bogus cast, DBUG_DUMP expects a pointer to unsigned
        char.
      strings/bcmp.c:
        Remove built-in bcmp.
      strings/ctype-ucs2.c:
        Silence bogus warning.
      tests/mysql_client_test.c:
        Use a appropriate type as expected by simple_command().
      1113efea
  34. 10 Jun, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#42733: Type-punning warnings when compiling MySQL -- · fd4b3c6c
      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.
      fd4b3c6c
  35. 31 May, 2010 1 commit
    • Tor Didriksen's avatar
      Bug #49829 Many "hides virtual function" warnings with SunStudio · e8d4687f
      Tor Didriksen authored
      Backport from mysql-pe (of those parts which have not been upmerged from 5.1)
      
      
      
      sql/field.cc:
        Local scope variable or method argument same as class attribute.
      sql/item.cc:
        Rename auto variable to avoid name clash.
      sql/item.h:
        Item_ref::basic_const_item had wrong signature (missing const)
        and was thus never called.
      sql/partition_info.cc:
        Rename, to avoid name clashes.
      sql/sql_load.cc:
        Rename, to avoid name clashes.
      e8d4687f
  36. 28 May, 2010 1 commit
    • unknown's avatar
      Bug#52168 decimal casting catastrophes: crashes and valgrind errors on simple casts · 9b3e9a21
      unknown authored
      The problem is that if a NULL is stored in an Item_cache_decimal object,
      the associated my_decimal object is not initialized.  However, it is still
      accessed when val_int() is called. The fix is to check for null_value
      within val_int(), and return without accessing the my_decimal object when
      the cached value is NULL.
      
      Bug#52122 reports the same issue for val_real(), and this patch also includes
      fixes for val_real() and val_str() and corresponding test cases from that
      bug report.  
      
      Also, NULL is returned from val_decimal() when value is null. This will
      avoid that callers access an uninitialized my_decimal object.
      
      Made similar changes to all other Item_cache classes.  Now all val_*
      methods should return a well defined value when actual value is NULL.
      
      mysql-test/r/type_decimal.result:
        Updated result file with test cases for Bug#52168 and Bug#52122.
      mysql-test/t/type_decimal.test:
        Added test cases for Bug#52168 and Bug#52122.
      sql/item.cc:
        In Item_cache_*::val_* methods, return a well defined value
        when actual value is NULL.
        
        This is especially important for Item_cache_decimal since
        otherwise one risk accessing an uninitialized my_decimal object.
      sql/item.h:
        Added method Item_cache::has_value() which returns TRUE if cache 
        object contains a non-null value.
      9b3e9a21