An error occurred fetching the project authors.
  1. 28 May, 2007 2 commits
    • unknown's avatar
      Bug#24988 FLUSH PRIVILEGES causes brief unavailability · 416122b2
      unknown authored
      - A race condition caused brief unavailablility when trying to acccess
        a table. 
      - The variable 'grant_option' was removed to resolve the race condition and
        to simplify the design pattern. This flag was originally intended to optimize
        grant checks.
      
      
      sql/mysql_priv.h:
        - removed 'grant_option' flag.
      sql/sql_acl.cc:
        - removed 'grant_option' flag.
      sql/sql_db.cc:
        - removed 'grant_option' flag.
      sql/sql_insert.cc:
        - removed 'grant_option' flag.
      sql/sql_parse.cc:
        - removed 'grant_option' flag.
        - removed unnecessary variables found_access, found
      sql/sql_show.cc:
        - removed 'grant_option' flag.
      sql/sql_update.cc:
        - removed 'grant_option' flag.
      sql/sql_view.cc:
        - removed 'grant_option' flag.
      416122b2
    • unknown's avatar
      5.1 version of a fix and test cases for bugs: · b11f1d0c
      unknown authored
      Bug#4968 ""Stored procedure crash if cursor opened on altered table"
      Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
      Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from 
      stored procedure."
      Bug#19733 "Repeated alter, or repeated create/drop, fails"
      Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
      Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a 
      growing key length" (this bug is not fixed in 5.0)
      
      Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE 
      statements in stored routines or as prepared statements caused
      incorrect results (and crashes in versions prior to 5.0.25).
      
      In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
      SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
        
      The problem of bugs 4968, 19733, 19282 and 6895 was that functions
      mysql_prepare_table, mysql_create_table and mysql_alter_table are not
      re-execution friendly: during their operation they modify contents
      of LEX (members create_info, alter_info, key_list, create_list),
      thus making the LEX unusable for the next execution.
      In particular, these functions removed processed columns and keys from
      create_list, key_list and drop_list. Search the code in sql_table.cc 
      for drop_it.remove() and similar patterns to find evidence.
        
      The fix is to supply to these functions a usable copy of each of the
      above structures at every re-execution of an SQL statement. 
        
      To simplify memory management, LEX::key_list and LEX::create_list
      were added to LEX::alter_info, a fresh copy of which is created for
      every execution.
        
      The problem of crashing bug 22060 stemmed from the fact that the above 
      metnioned functions were not only modifying HA_CREATE_INFO structure 
      in LEX, but also were changing it to point to areas in volatile memory
      of the execution memory root.
         
      The patch solves this problem by creating and using an on-stack
      copy of HA_CREATE_INFO in mysql_execute_command.
      
      Additionally, this patch splits the part of mysql_alter_table
      that analizes and rewrites information from the parser into
      a separate function - mysql_prepare_alter_table, in analogy with
      mysql_prepare_table, which is renamed to mysql_prepare_create_table.
      
      
      mysql-test/r/ps.result:
        Update test results (Bug#19182, Bug#22060, Bug#4968, Bug#6895)
      mysql-test/r/sp.result:
        Update results (Bug#19733)
      mysql-test/t/ps.test:
        Add test cases for Bug#19182, Bug#22060, Bug#4968, Bug#6895
      mysql-test/t/sp.test:
        Add a test case for Bug#19733
      sql/field.h:
        Implement a deep copy constructor for create_field
      sql/mysql_priv.h:
        LEX::key_list and LEX::create_list were moved to LEX::alter_info.
        Update declarations to use LEX::alter_info instead of these two
        members.
        Remove declarations of mysql_add_index, mysql_drop_index.
      sql/sql_class.cc:
        Implement deep copy constructors.
      sql/sql_class.h:
        Implement (almost) deep copy constructors for key_part_spec, 
        Alter_drop, Alter_column, Key, foreign_key.
        Replace pair<columns, keys> with an instance of Alter_info in
        select_create constructor. We create a new copy of Alter_info
        each time we re-execute SELECT .. CREATE prepared statement.
      sql/sql_insert.cc:
        Adjust to a new signature of create_table_from_items.
      sql/sql_lex.cc:
        Implement Alter_info::Alter_info that would make a "deep" copy
        of all definition lists (keys, columns).
        Move is_partition_management() from sql_partition.cc (feature-based
        file division is evil).
      sql/sql_lex.h:
        Move key_list and create_list to class Alter_info. Implement
        Alter_info::Alter_info that can be used with PS and SP.
        Get rid of Alter_info::clear() which was an attempt to save on
        matches and always use Alter_info::reset().
        Implement an auxiliary Alter_info::init_for_create_from_alter()
        which is used in mysql_alter_table.
      sql/sql_list.cc:
          Implement a copy constructor of class List that makes a deep copy
          of all list nodes.
      sql/sql_list.h:
        Implement a way to make a deep copy of all list nodes.
      sql/sql_parse.cc:
        Adjust to new signatures of mysql_create_table, mysql_alter_table,
        select_create. Functions mysql_create_index and mysql_drop_index has
        become identical after initialization of alter_info was moved to the 
        parser, and were merged. Flag enable_slow_log was not updated for 
        SQLCOM_DROP_INDEX, which was a bug.
        Just like CREATE INDEX, DROP INDEX is currently done via complete 
        table rebuild and is rightfully a slow administrative statement.
      sql/sql_partition.cc:
        Move is_partition_management() to sql_lex.cc
        Adjust code to the new Alter_info.
      sql/sql_table.cc:
        Adjust mysql_alter_table, mysql_recreate_table, mysql_create_table,
        mysql_prepare_table to new signatures.
        Rename mysql_prepare_table to mysql_prepare_create_table. Make
        sure it follows the convention and returns FALSE for success and
        TRUE for error.
        Move parts of mysql_alter_table to mysql_prepare_alter_table.
        Move the first invokation of mysql_prepare_table from mysql_alter_table
        to compare_tables, as it was needed only for the purpose
        of correct comparison.
        Since now Alter_info itself is created in the runtime mem root,
        adjust mysql_prepare_table to always allocate memory in the
        runtime memory root.
        Remove dead code.
      sql/sql_yacc.yy:
        LEX::key_list and LEX::create_list moved to class Alter_info
      b11f1d0c
  2. 22 May, 2007 1 commit
    • unknown's avatar
      Bug#21554 (sp_cache.cc: violates C++ aliasing rules) · bb64e39e
      unknown authored
      The problem reported is a compile bug,
      reported by the development GCC team with GCC 4.2.
      
      The original issue can no longer be reproduced in MySQL 5.1,
      since the configure script no longer define HAVE_ATOMIC_ADD,
      which caused the Linux atomic functions to be used (and cause a problem
      with an invalid cast).
      
      This patch implements some code cleanup for 5.1 only, which was identified
      during the investigation of this issue.
      
      With this patch, statistics maintained in THD::status_var are by definition
      owned by the running thread, and do not need to be protected against race
      conditions. These statistics are maintained by the status_var_* helpers,
      which do not require any lock.
      
      
      include/my_global.h:
        General cleanup of thread_safe_increment / statistic_increment
      include/my_pthread.h:
        General cleanup of thread_safe_increment / statistic_increment
      sql/filesort.cc:
        General cleanup of thread_safe_increment / statistic_increment
      sql/handler.cc:
        General cleanup of thread_safe_increment / statistic_increment
      sql/sql_insert.cc:
        General cleanup of thread_safe_increment / statistic_increment
      sql/sql_parse.cc:
        General cleanup of thread_safe_increment / statistic_increment
      sql/sql_prepare.cc:
        General cleanup of thread_safe_increment / statistic_increment
      sql/sql_select.cc:
        General cleanup of thread_safe_increment / statistic_increment
      bb64e39e
  3. 16 May, 2007 3 commits
    • unknown's avatar
      Fix a failing assert. · 75392f37
      unknown authored
      sql/sql_insert.cc:
        Do not access delayed thread memory without a mutex.
      75392f37
    • unknown's avatar
      Correct a merge error. · 5ac4515a
      unknown authored
      sql/sql_insert.cc:
        Correct a merge error (wrong declaration was used).
      5ac4515a
    • unknown's avatar
      A fix and a test case for · 3395c53e
      unknown authored
      Bug#21483 "Server abort or deadlock on INSERT DELAYED with another
      implicit insert"
      Also fixes and adds test cases for bugs:
      20497 "Trigger with INSERT DELAYED causes Error 1165"
      21714 "Wrong NEW.value and server abort on INSERT DELAYED to a
      table with a trigger".
      Post-review fixes.
      
      Problem:
      In MySQL INSERT DELAYED is a way to pipe all inserts into a
      given table through a dedicated thread. This is necessary for
      simplistic storage engines like MyISAM, which do not have internal
      concurrency control or threading and thus can not
      achieve efficient INSERT throughput without support from SQL layer.
      DELAYED INSERT works as follows:
      For every distinct table, which can accept DELAYED inserts and has
      pending data to insert, a dedicated thread is created to write data
      to disk. All user connection threads that attempt to
      delayed-insert into this table interact with the dedicated thread in
      producer/consumer fashion: all records to-be inserted are pushed
      into a queue of the dedicated thread, which fetches the records and 
      writes them.
      In this design, client connection threads never open or lock
      the delayed insert table.
      This functionality was introduced in version 3.23 and does not take 
      into account existence of triggers, views, or pre-locking.
      E.g. if INSERT DELAYED is called from a stored function, which,
      in turn, is called from another stored function that uses the delayed
      table, a deadlock can occur, because delayed locking by-passes
      pre-locking. Besides:
       * the delayed thread works directly with the subject table through
         the storage engine API and does not invoke triggers
       * even if it was patched to invoke triggers, if triggers,
         in turn, used other tables, the delayed thread would
         have to open and lock involved tables (use pre-locking).
       * even if it was patched to use pre-locking, without deadlock
         detection the delayed thread could easily lock out user 
         connection threads in case when the same table is used both
         in a trigger and on the right side of the insert query: 
         the delayed thread would not release locks until all inserts 
         are complete, and user connection can not complete inserts 
         without having locks on the tables used on the right side of the
         query.
      
      Solution:
      
      These considerations suggest two general alternatives for the
      future of INSERT DELAYED:
       * it is considered a full-fledged alternative to normal INSERT
       * it is regarded as an optimisation that is only relevant 
         for simplistic engines.
      Since we missed our chance to provide complete support of new
      features when 5.0 was in development, the first alternative
      currently renders infeasible.
      However, even the second alternative, which is to detect
      new features and convert DELAYED insert into a normal insert, 
      is not easy to implement.
      The catch-22 is that we don't know if the subject table has triggers
      or is a view before we open it, and we only open it in the
      delayed thread. We don't know if the query involves pre-locking
      until we have opened all tables, and we always first create
      the delayed thread, and only then open the remaining tables.
      This patch detects the problematic scenarios and converts
      DELAYED INSERT to a normal INSERT using the following approach:
       * if the statement is executed under pre-locking (e.g. from
         within a stored function or trigger) or the right
         side may require pre-locking, we detect the situation
         before creating a delayed insert thread and convert the statement
         to a conventional INSERT.
        * if the subject table is a view or has triggers, we shutdown
         the delayed thread and convert the statement to a conventional
         INSERT.
      
      
      mysql-test/r/insert.result:
        Update test results.
      mysql-test/t/insert.test:
        Add a test case for Bug#21483, Bug#20497, Bug#21714 (INSERT DELAYED
        and stored routines, triggers).
      sql/sp_head.cc:
        Upgrade lock type to TL_WRITE when computing the pre-locking set.
      sql/sql_base.cc:
        Use a new method.
      sql/sql_insert.cc:
        INSERT DELAYED and pre-locking:
        - if  under pre-locking, upgrade the lock type to TL_WRITE
        and proceed as a normal write
        - if DELAYED table has triggers, also request a lock upgrade.
        - make sure errors in the delayed thread are propagated
        correctly
      sql/sql_lex.h:
        Add a method to check if a parsed tree refers to stored
        routines.
      3395c53e
  4. 14 May, 2007 1 commit
    • unknown's avatar
      Fix a warning. · d98a2a87
      unknown authored
      sql/sql_insert.cc:
        Fix a compile-time warning (log_on is not used in embedded).
      d98a2a87
  5. 11 May, 2007 2 commits
    • unknown's avatar
      Fix for: · d46c8ce6
      unknown authored
        Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
                    with locked tables"
        Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
        Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
        Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
                    temporary table exists"
      
      Deadlock occured when one tried to execute CREATE TABLE IF NOT
      EXISTS ... SELECT statement under LOCK TABLES which held
      read lock on target table.
      Attempt to execute the same statement for already existing
      target table with triggers caused server crashes.
      Also concurrent execution of CREATE TABLE ... SELECT statement
      and other statements involving target table suffered from
      various races (some of which might've led to deadlocks).
      Finally, attempt to execute CREATE TABLE ... SELECT in case
      when a temporary table with same name was already present
      led to the insertion of data into this temporary table and
      creation of empty non-temporary table.
       
      All above problems stemmed from the old implementation of CREATE
      TABLE ... SELECT in which we created, opened and locked target
      table without any special protection in a separate step and not
      with the rest of tables used by this statement.
      This underminded deadlock-avoidance approach used in server
      and created window for races. It also excluded target table
      from prelocking causing problems with trigger execution.
      
      The patch solves these problems by implementing new approach to
      handling of CREATE TABLE ... SELECT for base tables.
      We try to open and lock table to be created at the same time as
      the rest of tables used by this statement. If such table does not
      exist at this moment we create and place in the table cache special
      placeholder for it which prevents its creation or any other usage
      by other threads.
      We still use old approach for creation of temporary tables.
      
      Note that we have separate fix for 5.0 since there we use slightly
      different less intrusive approach.
      
      
      mysql-test/r/create.result:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/r/trigger.result:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      mysql-test/t/create.test:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/t/trigger.test:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      sql/lock.cc:
        Now for creation of name-lock placeholder lock_table_name() uses
        auxiliary function table_cache_insert_placeholder().
      sql/mysql_priv.h:
        Removed declaration of non-existing build_table_path() routine.
        The former mysql_create_table_internal() was renamed to
        mysql_create_table_no_lock() and now exposed to other modules to
        give them opportunity of creation of tables in cases when name-lock
        is already obtained.
        reopen_name_locked_table() now has 3rd argument which controls linking
        in of table being opened into THD::open_tables (this is useful in
        cases when placeholder used for name-locking is already linked into
        this list).
        Added declaration of auxiliary function table_cache_insert_placeholder()
        which is used for creation of table placeholders for name-locking.
        Added declaration of lock_table_name_if_not_cached() which can be
        used to take an exclusive name-lock on table if there are no records
        for it in table cache.
        Changed signature of unlink_open_table() function to simplify its use
        and make it useful for table placeholders and tables that are only open.
        Added auxiliary drop_open_table() routine.
        Moved declaration of refresh_version to table.h header to make it
        accessible from inline methods of TABLE class.
        MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
        MYSQL_OPEN_TEMPORARY_ONLY option was added.
      sql/sql_base.cc:
        Added support for the new approach to the handling of CREATE TABLE
        ... SELECT for base tables.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads.
        
        Note significant distinctions of this placeholder from the placeholder
        used for normal name-lock: 1) It is treated like open table by other
        name-locks so it does not allow name-lock taking operations like DROP
        TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
        list and automatically removed during close_thread_tables() call
          
        open_tables():
          Implemented logic described above. To do this added
          auxiliary check_if_table_exists() function.
          Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
          which is no longer used.
          Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
          search for temporary tables only.
        close_cached_tables()/close_thread_table()/reopen_tables()/
        close_old_data_files()/table_is_used()/remove_table_from_cache():
          Added support for open placeholders (note that we also use them
          when we need to re-open tables during flush).
        unlink_open_table():
          Changed function signature to simplify its use and to make
          useful for open placeholders and tables which are only
          open and not locked.
        Added auxiliary drop_open_table() routine.
        reopen_name_locked_table():
          Now has 3rd argument which controls linking in of table being
          opened into THD::open_tables (this is useful in cases when
          placeholder used for name-locking is already linked into
          this list).
        Added auxiliary table_cache_insert_placeholder() routine which
        simplifies creation of placeholders used for name-locking.
        Added lock_table_name_if_not_cached() which can be used to take
        an exclusive name-lock on table if there are no records for it
        in table cache.
      sql/sql_handler.cc:
        Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
        handle placeholders which now can be linked into open tables
        list.
      sql/sql_insert.cc:
        Introduced new approach to handling of base tables in CREATE TABLE
        ... SELECT statement.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads. By doing this we avoid races which existed with
        previous approach in which we created, opened and locked target in
        separate step without any special protection.
        This also allows properly calculate prelocking set in cases when
        target table already exists and has some on insert triggers.
        
        Note that we don't employ the same approach for temporary tables
        (this is okay as such tables are unaffected by other threads).
        
        Changed create_table_from_items() and methods of select_create
        class to implement this approach.
      sql/sql_parse.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_prepare.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_table.cc:
        Changed mysql_create_table(), mysql_create_like_table() and
        mysql_alter_table() (in rename case) to obtain exclusive name-lock
        on the non-temporary table which is going to be created (to which
        we going to rename). This ensures that not only destination table
        doesn't exist on disk but also that there are no placeholder in 
        table cache for it (i.e. there is no CREATE TABLE ... SELECT operation
        in progress for it). Note that to avoid deadlocks while taking these
        name-locks this code assumes that existence of any record for table in
        table cache (even name-lock) means that table exists. Altough such
        check can lead to false positives these should occur only in case of
        highly concurrent DDL operations on the table and should not break
        binary logging.
        
        Renamed mysql_create_table_internal() to mysql_create_table_no_lock()
        and made it accessible from other files to give them ability to create
        table in situation when name-lock is already obtained or not relevant.
        
        Adjusted calls to reopen_name_locked_table(), which now takes
        extra argument, which controls linking of open table into
        THD::open_tables list.
        
        Removed redundant setting of table's 'version' field before calls
        to close_cached_table(). This function will set it to 0 itself
        anyway.
      sql/sql_trigger.cc:
        reopen_name_locked_tables() now has one more argument which controls
        linking of opened table into the THD::open_tables list.
      sql/sql_yacc.yy:
        The new approach to handling of CREATE TABLE ... SELECT statement
        for base tables assumes that all tables including table to be
        created are open and (or) locked at the same time. Therefore
        we need to set correct lock for target table.
      sql/table.h:
        Moved declaration of refresh_version variable from mysql_priv.h
        to make it accessible from inline methods of TABLE class.
        Renamed TABLE::locked_by_flush member to open_placeholder since
        now it is also used for taking exclusive name-lock and not only
        by flush. 
        Introduced TABLE::is_name_opened() helper method which can be used
        to distinguish TABLE instances corresponding to open tables or
        placeholders for them from closed instances (e.g. due to their old
        version). Also introduced TABLE::needs_reopen_or_name_lock() helper
        which allows to check if TABLE instance corresponds to outdated
        version of table or to name-lock placeholder.
        Introduced TABLE_LIST::create member which marks elements of
        table list corresponds to the table to be created.
        Adjusted TABLE_LIST::placeholder() method to take into account 
        name-lock placeholders for tables to be created (this, for example,
        allows to properly handle such placeholders in lock_tables()).
        Finally, moved currently unused TABLE::open_next/open_prev
        members under ifdef NOT_YET.
      mysql-test/r/create_select-big.result:
        New BitKeeper file ``mysql-test/r/create_select-big.result''
      mysql-test/t/create_select-big.test:
        New BitKeeper file ``mysql-test/t/create_select-big.test''
      d46c8ce6
    • unknown's avatar
      Fix for: · c5a82455
      unknown authored
        Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
                    with locked tables"
        Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
        Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
        Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
                    temporary table exists"
       
      Deadlock occured when one tried to execute CREATE TABLE IF NOT
      EXISTS ... SELECT statement under LOCK TABLES which held
      read lock on target table.
      Attempt to execute the same statement for already existing
      target table with triggers caused server crashes.
      Also concurrent execution of CREATE TABLE ... SELECT statement
      and other statements involving target table suffered from
      various races (some of which might've led to deadlocks).
      Finally, attempt to execute CREATE TABLE ... SELECT in case
      when a temporary table with same name was already present
      led to the insertion of data into this temporary table and
      creation of empty non-temporary table.
       
      All above problems stemmed from the old implementation of CREATE
      TABLE ... SELECT in which we created, opened and locked target
      table without any special protection in a separate step and not
      with the rest of tables used by this statement.
      This underminded deadlock-avoidance approach used in server
      and created window for races. It also excluded target table
      from prelocking causing problems with trigger execution.
        
      The patch solves these problems by implementing new approach to
      handling of CREATE TABLE ... SELECT for base tables.
      We try to open and lock table to be created at the same time as
      the rest of tables used by this statement. If such table does not
      exist at this moment we create and place in the table cache special
      placeholder for it which prevents its creation or any other usage
      by other threads.
      
      We still use old approach for creation of temporary tables.
      
      Also note that we decided to postpone introduction of some tests
      for concurrent behaviour of CREATE TABLE ... SELECT till 5.1.
      The main reason for this is absence in 5.0 ability to set @@debug
      variable at runtime, which can be circumvented only by using several
      test files with individual .opt files. Since the latter is likely
      to slowdown test-suite unnecessary we chose not to push this tests
      into 5.0, but run them manually for this version and later push
      their optimized version into 5.1
      
      
      mysql-test/r/create.result:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/r/trigger.result:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      mysql-test/t/create.test:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/t/trigger.test:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      sql/lock.cc:
        Now for creation of name-lock placeholder in lock_table_name() we use
        auxiliary function table_cache_insert_placeholder().
      sql/mysql_priv.h:
        Made build_table_path() function available outside of sql_table.cc file.
        reopen_name_locked_table() now has 3rd argument which controls linking
        in of table being opened into THD::open_tables (this is useful in
        cases when placeholder used for name-locking is already linked into
        this list).
        Added declaration of auxiliary function table_cache_insert_placeholder()
        which is used for creation of table placeholders for name-locking.
        Added declaration of table_cache_has_open_placeholder() function which
        can be used for checking if table cache contains an open placeholder for
        the table and if this placeholder was created by another thread.
        (This function is needed only in 5.0 where we use it in various versions
         of CREATE TABLE in order to protect it from concurrent CREATE TABLE
         ... SELECT operations for the table. Starting from 5.1 we use different
         approach so it is going to be removed there).
        Made close_old_data_files() static within sql_base.cc file. 
        Added auxiliary drop_open_table() routine.
        Moved declaration of refresh_version to table.h header to make it
        accessible from inline methods of TABLE class.
        MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
        MYSQL_OPEN_TEMPORARY_ONLY option was added.
      sql/sql_base.cc:
        Added support for the new approach to the handling of CREATE TABLE
        ... SELECT for base tables.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads.
        
        Note significant distinctions of this placeholder from the placeholder
        used for normal name-lock: 1) It is treated like open table by other
        name-locks so it does not allow name-lock taking operations like DROP
        TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
        list and automatically removed during close_thread_tables() call.
        
        open_tables():
          Implemented logic described above. To do this added
          auxiliary check_if_table_exists() function.
          Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
          which is no longer used.
          Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
          search for temporary tables only.
        close_cached_tables()/close_thread_table()/reopen_tables()/
        close_old_data_files()/table_is_used()/remove_table_from_cache():
          Added support for open placeholders (note that we also use them
          when we need to re-open tables during flush).
        Added auxiliary drop_open_table() routine.
        reopen_name_locked_table():
          Now has 3rd argument which controls linking in of table being
          opened into THD::open_tables (this is useful in cases when
          placeholder used for name-locking is already linked into
          this list).
        Added auxiliary table_cache_insert_placeholder() routine which
        simplifies creation of placeholders used for name-locking.
        Added table_cache_has_open_placeholder() function which can be
        used for checking if table cache contains an open placeholder for
        the table and if this placeholder was created by another thread.
        (This function is needed only in 5.0 where we use it in various versions
         of CREATE TABLE in order to protect it from concurrent CREATE TABLE
         ... SELECT operations for the table. Starting from 5.1 we use different
         approach so it is going to be removed there).
      sql/sql_handler.cc:
        Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
        handle placeholders which now can be linked into open tables
        list.
      sql/sql_insert.cc:
        Introduced new approach to handling of base tables in CREATE TABLE
        ... SELECT statement.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads. By doing this we avoid races which existed with
        previous approach in which we created, opened and locked target in
        separate step without any special protection.
        This also allows properly calculate prelocking set in cases when
        target table already exists and has some on insert triggers.
          
        Note that we don't employ the same approach for temporary tables
        (this is okay as such tables are unaffected by other threads).
        
        Changed create_table_from_items() and select_create methods to
        implement this approach.
      sql/sql_parse.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_prepare.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_table.cc:
        Now mysql_create_table_internal(), mysql_create_like_table() and
        mysql_alter_table() not only check that destination table doesn't
        exist on disk but also check that there is no create placeholder
        in table cache for it (i.e. there is no CREATE TABLE ... SELECT
        operation in progress for it). Note that starting from 5.1 we
        use different approach in order to to protect CREATE TABLE ... SELECT
        from concurrent CREATE TABLE (ALTER TABLE ... RENAME) operations,
        the latter simply take name-locks on table before its creation
        (on target table name before renaming).
        
        Also made build_table_path() available from other files and
        asjusted calls to reopen_name_locked_table(), which now takes
        extra argument, which controls linking of open table into
        THD::open_tables list.
      sql/sql_trigger.cc:
        reopen_name_locked_tables() now has one more argument which controls
        linking of opened table into the THD::open_tables list.
      sql/sql_yacc.yy:
        The new approach to handling of CREATE TABLE ... SELECT statement
        for base tables assumes that all tables including table to be
        created are open and (or) locked at the same time. Therefore
        we need to set correct lock for target table.
      sql/table.h:
        Moved declaration of refresh_version variable from mysql_priv.h
        to make it accessible from inline methods of TABLE class. 
        Renamed TABLE::locked_by_flush member to open_placeholder since
        now it is also used for taking exclusive name-lock and not only
        by flush. 
        Introduced TABLE::is_name_opened() helper method which can be used
        to distinguish TABLE instances corresponding to open tables or
        placeholders for them from closed instances (e.g. due to their old
        version). Also introduced TABLE::needs_reopen_or_name_lock() helper
        which allows to check if TABLE instance corresponds to outdated
        version of table or to name-lock placeholder.
        Introduced TABLE_LIST::create member which marks elements of
        table list corresponds to the table to be created.
        Adjusted TABLE_LIST::placeholder() method to take into account 
        name-lock placeholders for tables to be created (this, for example,
        allows to properly handle such placeholders in lock_tables()).
      c5a82455
  6. 10 May, 2007 3 commits
    • unknown's avatar
      Fixed bug #28000. · 36190568
      unknown authored
      Bug occurs in INSERT IGNORE ... SELECT ... ON DUPLICATE KEY UPDATE
      statements, when SELECT returns duplicated values and UPDATE clause
      tries to assign NULL values to NOT NULL fields.
      NOTE: By current design MySQL server treats INSERT IGNORE ... ON
      DUPLICATE statements as INSERT ... ON DUPLICATE with update of
      duplicated records, but MySQL manual lacks this information.
      After this fix such behaviour becomes legalized.
      
      The write_record() function was returning error values even within
      INSERT IGNORE, because ignore_errors parameter of
      the fill_record_n_invoke_before_triggers() function call was
      always set to FALSE. FALSE is replaced by info->ignore.
      
      
      sql/sql_insert.cc:
        Fixed bug #28000:
        The write_record() function was returning error values even within
        INSERT IGNORE, because ignore_errors parameter of
        the fill_record_n_invoke_before_triggers() function call was
        always set to FALSE. FALSE is replaced by info->ignore.
      mysql-test/t/insert_update.test:
        Added test case for bug #28000.
      mysql-test/r/insert_update.result:
        Added test case for bug #28000.
      36190568
    • unknown's avatar
      Follow the coding style with class names. · 30184f96
      unknown authored
      sql/sql_insert.cc:
        delayed_insert -> Delayed_insert
      30184f96
    • unknown's avatar
      No semantical change. Move checks of compatibility · d12a8413
      unknown authored
      of requested lock type and requested table operation from 
      mysql_insert into a separate function.
      
      
      sql/sql_insert.cc:
        Cleanup: move a number of locking related checks from mysql_insert 
        to a separate function.
        Add comments.
      d12a8413
  7. 12 Apr, 2007 1 commit
    • unknown's avatar
      BUG#25688 (RBR: circular replication may cause STMT_END_F flags to be · 6ed9fc6b
      unknown authored
      skipped):
      
      By moving statement end actions from Rows_log_event::do_apply_event() to
      Rows_log_event::do_update_pos() they will always be executed, even if
      Rows_log_event::do_apply_event() is skipped because the event originated
      at the same server. This because Rows_log_event::do_update_pos() is always
      executed (unless Rows_log_event::do_apply_event() failed with an error,
      in which case the slave stops with an error anyway). 
      
      Adding test case.
      
      Fixing logic to detect if inside a group. If a rotate event occured
      when an initial prefix of events for a statement, but for which the
      table did contain a key, last_event_start_time is set to zero, causing
      rotate to end the group but without unlocking any tables. This left a
      lock hanging around, which subsequently triggered an assertion when a
      second attempt was made to lock the same sequence of tables.
      
      In order to solve the above problem, a new flag was added to the relay
      log info structure that is used to indicate that the replication thread
      is currently executing a statement. Using this flag, the replication
      thread is in a group if it is either in a statement or inside a trans-
      action.
      
      The patch also eliminates some gratuitous header file inclusions that
      were not needed (and caused compile errors) and replaced them with
      forward definitions.
      
      
      sql/item_func.cc:
        Including definition of MASTER_INFO.
      sql/log.cc:
        Including definition of RELAY_LOG_INFO since it is used in the file.
      sql/log_event.cc:
        Moving statement end actions from Rows_log_event::do_apply_event() to
        Rows_log_event::do_update_pos().
        Factoring out code to update group positions and event positions into
        relay log info structure.
        ---
        Adding debugging printouts.
        Fixing logic to detect if inside a group.
      sql/log_event.h:
        Adding Rows_log_event::do_update_pos().
      sql/mysqld.cc:
        Including definition of MASTER_INFO.
      sql/repl_failsafe.cc:
        Including definition of MASTER_INFO.
      sql/rpl_mi.h:
        Including definition of RELAY_LOG_INFO since it is used in the file.
      sql/rpl_rli.cc:
        Adding member function stmt_done() to do after-statement updates of the
        relay log info structure.
      sql/rpl_rli.h:
        Adding member function stmt_done() to do after-statement updates of the
        relay log info structure.
      sql/set_var.cc:
        Including definition of MASTER_INFO.
      sql/slave.cc:
        Adding debuging printouts.
      sql/slave.h:
        Removing inclusion definitions of MASTER_INFO and RELAY_LOG_INFO and
        replacing them with forward declarations since the classes are not
        used in the file. The gratuitous inclusion lead to compile errors in
        the two classes above in files that used neither.
      sql/sql_binlog.cc:
        Including definition of RELAY_LOG_INFO since it is used in the file.
      sql/sql_class.cc:
        Including definition of RELAY_LOG_INFO since it is used in the file.
      sql/sql_class.h:
        Removing inclusion definitions of RELAY_LOG_INFO and replacing it
        with forward declaration since the class is not used in the file.
        The gratuitous inclusion lead to compile errors in the class above
        in files didn't use the class.
      sql/sql_insert.cc:
        Including definition of MASTER_INFO.
      sql/sql_repl.cc:
        Including definition of MASTER_INFO.
      mysql-test/r/rpl_ndb_circular_simplex.result:
        New BitKeeper file ``mysql-test/r/rpl_ndb_circular_simplex.result''
      mysql-test/t/rpl_ndb_circular_simplex.test:
        New BitKeeper file ``mysql-test/t/rpl_ndb_circular_simplex.test''
      6ed9fc6b
  8. 04 Apr, 2007 2 commits
    • unknown's avatar
      Merge from 5.0 · 59a64c2b
      unknown authored
      mysql-test/r/ndb_trigger.result:
        Re-generated
      sql/mysql_priv.h:
        Merge
      sql/sql_insert.cc:
        Merge
      sql/sql_load.cc:
        Merge
      sql/sql_update.cc:
        Merge
      59a64c2b
    • unknown's avatar
      Bug #26242 UPDATE with subquery and triggers failing with cluster tables · 2efc0f51
      unknown authored
      In certain cases AFTER UPDATE/DELETE triggers on NDB tables that referenced
      subject table didn't see the results of operation which caused invocation
      of those triggers. In other words AFTER trigger invoked as result of update
      (or deletion) of particular row saw version of this row before update (or
      deletion).
      
      The problem occured because NDB handler in those cases postponed actual
      update/delete operations to be able to perform them later as one batch.
      
      This fix solves the problem by disabling this optimization for particular
      operation if subject table has AFTER trigger for this operation defined.
      To achieve this we introduce two new flags for handler::extra() method:
      HA_EXTRA_DELETE_CANNOT_BATCH and HA_EXTRA_UPDATE_CANNOT_BATCH.
      These are called if there exists AFTER DELETE/UPDATE triggers during a
      statement that potentially can generate calls to delete_row()/update_row().
      This includes multi_delete/multi_update statements as well as insert statements
      that do delete/update as part of an ON DUPLICATE statement.
      
      
      include/my_base.h:
        Added HA_EXTRA_DELETE_CANNOT_BATCH and HA_EXTRA_UPDATE_CANNOT_BATCH to inform handler when batching of delete/update is not possible.
      mysql-test/r/ndb_trigger.result:
        Bug #26242  UPDATE with subquery and triggers failing with cluster tables
        ---
        Added new test cases
      mysql-test/t/ndb_trigger.test:
        Bug #26242  UPDATE with subquery and triggers failing with cluster tables
        ---
        Added new test cases
      sql/ha_ndbcluster.cc:
        Bug #26242  UPDATE with subquery and triggers failing with cluster tables: Use HA_EXTRA_DELETE_CANNOT_BATCH and HA_EXTRA_UPDATE_CANNOT_BATCH to inform handler when batching of delete/update is not possible
      sql/ha_ndbcluster.h:
        Bug #26242  UPDATE with subquery and triggers failing with cluster tables: Added member variables for handling of HA_EXTRA_DELETE_CANNOT_BATCH and HA_EXTRA_UPDATE_CANNOT_BATCH to inform handler when batching of delete/update is not possible
      sql/mysql_priv.h:
        Added new method prepare_triggers_for_insert_stmt to check if batching of delete/update must be disallowed.
      sql/sql_delete.cc:
        Use HA_EXTRA_DELETE_CANNOT_BATCH to inform handler when batching of delete is not possible
      sql/sql_insert.cc:
        Added method prepare_triggers_for_insert_stmt to check if batching of delete/update must be dissallowed.
        Use HA_EXTRA_DELETE_CANNOT_BATCH and HA_EXTRA_UPDATE_CANNOT_BATCH to inform handler
         when batching of delete/update is not possible
      sql/sql_load.cc:
        Call prepare_triggers_for_insert_stmt to check if batching of delete/update must be dissallowed and
        mark fields used by triggers for the insert statement.
      sql/sql_trigger.h:
        Added has_triggers to support what particular triggers exist on a table.
      sql/sql_update.cc:
        Use HA_EXTRA_UPDATE_CANNOT_BATCH to inform handler when batching of update is not possible
      2efc0f51
  9. 30 Mar, 2007 1 commit
    • unknown's avatar
      Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the · 86a0ffdd
      unknown authored
      NO_AUTO_VALUE_ON_ZERO mode.
      
      In the NO_AUTO_VALUE_ON_ZERO mode the table->auto_increment_field_not_null
      variable is used to indicate that a non-NULL value was specified by the user
      for an auto_increment column. When an INSERT .. ON DUPLICATE updates the
      auto_increment field this variable is set to true and stays unchanged for the
      next insert operation. This makes the next inserted row sometimes wrongly have
      0 as the value of the auto_increment field.
      
      Now the fill_record() function resets the table->auto_increment_field_not_null
      variable before filling the record.
      The table->auto_increment_field_not_null variable is also reset by the
      open_table() function for a case if we missed some auto_increment_field_not_null
      handling bug.
      Now the table->auto_increment_field_not_null is reset at the end of the
      mysql_load() function.
      
      Reset the table->auto_increment_field_not_null variable after each
      write_row() call in the copy_data_between_tables() function.
      
      
      
      
      sql/field_conv.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        A comment is corrected.
      sql/handler.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the handler::update_auto_increment() function doesn't reset the
        table->auto_increment_field_not_null variable as it is done in the
        fill_record() function.
      sql/sql_base.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the fill_record() function resets the table->auto_increment_field_not_null
        variable before filling the record.
        The table->auto_increment_field_not_null variable is also reset by the
        open_table() function for a case if we missed some auto_increment_field_not_null
        handling bug.
      sql/sql_insert.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the the table->auto_increment_field_not_null is reset at the end of the
        mysql_insert() an in the select_insert class destructor.
      sql/sql_load.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the table->auto_increment_field_not_null is reset at the end of the
        mysql_load() function.
      sql/sql_table.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        Reset the table->auto_increment_field_not_null variable after each
        write_row() call in the copy_data_between_tables() function.
      sql/table.h:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        A comment added.
      mysql-test/r/insert_update.result:
        Added the test case for the bug#23233: 0 as LAST_INSERT_ID() after
        INSERT .. ON DUPLICATE in the NO_AUTO_VALUE_ON_ZERO mode.
      mysql-test/t/insert_update.test:
        Added the test case for the bug#23233: 0 as LAST_INSERT_ID() after
        INSERT .. ON DUPLICATE in the NO_AUTO_VALUE_ON_ZERO mode.
      86a0ffdd
  10. 29 Mar, 2007 1 commit
  11. 23 Mar, 2007 1 commit
    • unknown's avatar
      Bug #27395 OPTION_STATUS_NO_TRANS_UPDATE is not preserved at the end of SF() · 4a76ac5f
      unknown authored
      thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit was not restored at the end of SF() invocation, where
      SF() modified non-ta table.
      As the result of this artifact it was not possible to detect whether there were any side-effects when
      top-level query ends. 
      If the top level query table was not modified and the bit is lost there would be no binlogging.
      
      Fixed with preserving the bit inside of thd->no_trans_update struct. The struct agregates two bool flags
      telling whether the current query and the current transaction modified any non-ta table.
      The flags stmt, all are dropped at the end of the query and the transaction.
      
      
      mysql-test/r/sp_trans.result:
        results will be changed once again after bug#23333 will be fixed.
      mysql-test/t/sp_trans.test:
        regression test added
      sql/ha_ndbcluster.cc:
        replacing thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit and bool thd->no_trans_update
        with thd->no_trans_update as struct
      sql/handler.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/log.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/set_var.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sp_head.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_class.h:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_delete.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_insert.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_load.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_parse.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_table.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_update.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      4a76ac5f
  12. 22 Mar, 2007 1 commit
    • unknown's avatar
      Fixed bug #27229: crash when a set function aggregated in outer · 1f8bdbe4
      unknown authored
      context was used as an argument of GROUP_CONCAT.
      Ensured correct setting of the depended_from field in references
      generated for set functions aggregated in outer selects.
      A wrong value of this field resulted in wrong maps returned by 
      used_tables() for these references.
      Made sure that a temporary table field is added for any set function
      aggregated in outer context when creation of a temporary table is 
      needed to execute the inner subquery. 
      
      
      mysql-test/r/subselect.result:
        Added a test case for bug #27229.
      mysql-test/t/subselect.test:
        Added a test case for bug #27229.
      sql/item.cc:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Ensured correct setting of the depended_from field in references
        generated for set functions aggregated in outer selects.
      sql/item_sum.cc:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Added the field aggr_sel to the objects of the class Item_sum.
        In any Item_sum object created for a set function this field 
        has to contain a pointer to the select where the set function
        is aggregated.
      sql/item_sum.h:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Added the field aggr_sel to the objects of the class Item_sum.
        In any Item_sum object created for a set function this field 
        has to contain a pointer to the select where the set function
        is aggregated.
        Added a method that says whether a set function is aggregated
        in outer context and, if so, returns the aggregating select.
        Removed the field nest_level_tables_count introduced by the
        patch for bug 24484 as aggr_sel->join->tables contains the
        sane number.
      sql/sql_base.cc:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Added the field aggr_sel to the objects of the class Item_sum.
        Removed changes introduced by the patch for bug 24484 as 
        the field leaf_count of the THD class is not used anymore.
      sql/sql_class.h:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Added the field aggr_sel to the objects of the class Item_sum.
        Removed changes introduce by the patch for bug 24484 as 
        the field leaf_count of the THD class is not used anymore.
      sql/sql_insert.cc:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        Added the field aggr_sel to the objects of the class Item_sum.
        Removed changes introduce by the patch for bug 24484 as 
        the field leaf_count of the THD class is not used anymore.
      sql/sql_select.cc:
        Fixed bug #27229: crash when a set function aggregated in outer
        context was used as an argument of GROUP_CONCAT.
        When creating a temporary table a field is added in it for any 
        set function aggregated in outer context.
      1f8bdbe4
  13. 20 Mar, 2007 1 commit
    • unknown's avatar
      Bug #24484: · 9c89dd65
      unknown authored
      To correctly decide which predicates can be evaluated with a given table
      the optimizer must know the exact set of tables that a predicate depends 
      on. If that mask is too wide (refer to non-existing tables) the optimizer
      can erroneously skip a predicate.
      One such case of wrong table usage mask were the aggregate functions.
      The have a all-1 mask (meaning depend on all tables, including non-existent
      ones).
      Fixed by making a real used_tables mask for the aggregates. The mask is
      constructed in the following way :
      1. OR the table dependency masks of all the arguments of the aggregate.
      2. If all the arguments of the function are from the local name resolution 
        context and it is evaluated in the same name resolution
        context where it is referenced all the tables from that name resolution 
        context are OR-ed to the dependency mask. This is to denote that an
        aggregate function depends on the number of rows it processes.
      3. Handle correctly the case of an aggregate function optimization (such that
        the aggregate function can be pre-calculated and made a constant).
      
      Made sure that an aggregate function is never a constant (unless subject of a 
      specific optimization and pre-calculation).  
      
      One other flaw was revealed and fixed in the process : references were 
      not calling the recalculation method for used_tables of their targets.
      
      
      mysql-test/r/subselect3.result:
        Bug #24484: test case
      mysql-test/t/subselect3.test:
        Bug #24484: test case
      sql/item.h:
        Bug #24484: Item_ref must update the used tables.
      sql/item_sum.cc:
        Bug #24484: correct calculation of used_tables for aggregates.
      sql/item_sum.h:
        Bug #24484: correct calculation of used_tables for aggregates.
      sql/opt_range.cc:
        Bug #24484: fixed ref resolution in loose index scan
      sql/sql_base.cc:
        Bug #24484: moved counting of leaf tables inside 
        setup_tables_and_check_access.
      sql/sql_class.h:
        Bug #24484: changed table count to more narrow type.
      sql/sql_insert.cc:
        Bug #24484: moved counting of leaf tables inside 
        setup_tables_and_check_access. Substract the first
        table (and its subtables) of an INSERT statement
        from leaf_count.
      sql/sql_select.cc:
        Bug #24484: correct check for aggregates
      9c89dd65
  14. 19 Mar, 2007 2 commits
    • unknown's avatar
      sql_insert.cc: · c71bff6d
      unknown authored
        After merge fix.
      
      
      sql/sql_insert.cc:
        After merge fix.
      c71bff6d
    • unknown's avatar
      sql_insert.cc: · 3798a7d5
      unknown authored
        Removed wrong fix for the bug#27006.
        The bug was added by the fix for the bug#19978 and fixed by Monty on 2007/02/21.
      trigger.test, trigger.result:
        Corrected test case for the bug#27006.
      
      
      sql/sql_insert.cc:
        Removed wrong fix for the bug#27006.
        The bug was added by the fix for the bug#19978 and fixed by Monty on 2007/02/21.
      mysql-test/t/trigger.test:
        Corrected test case for the bug#27006.
      mysql-test/r/trigger.result:
        Corrected test case for the bug#27006.
      3798a7d5
  15. 16 Mar, 2007 5 commits
    • unknown's avatar
      wl#3700 - post-review fixes: · 7d383909
      unknown authored
      s/ulonglong/key_part_map/, comments
      
      
      include/heap.h:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      include/my_base.h:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      include/myisam.h:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      include/myisammrg.h:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      sql/event_db_repository.cc:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      sql/ha_partition.cc:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      sql/ha_partition.h:
        wl#3700 - post-review fixes:
        s/ulonglong/key_part_map/
      sql/sql_select.h:
        wl#3700 - post-review fixes:
        remove tab_to_keypart_map()
      7d383909
    • unknown's avatar
      sql_insert.cc: · 84d24679
      unknown authored
        Post-merge fix.
      
      
      sql/sql_insert.cc:
        Post-merge fix.
      84d24679
    • unknown's avatar
      merging · 68f09e77
      unknown authored
      68f09e77
    • unknown's avatar
      Bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY · 6d93f150
      unknown authored
      UPDATE if the row wasn't actually changed.
      
      This bug was caused by fix for bug#19978. It causes AFTER UPDATE triggers
      not firing if a row wasn't actually changed by the update part of the
      INSERT .. ON DUPLICATE KEY UPDATE.
      
      Now triggers are always fired if a row is touched by the INSERT ... ON
      DUPLICATE KEY UPDATE.
      
      
      sql/sql_insert.cc:
        Bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
        Now triggers are always fired if a row is touched by the INSERT ... ON
        DUPLICATE KEY UPDATE.
      mysql-test/r/trigger.result:
        Added a test case for the bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
      mysql-test/t/trigger.test:
        Added a test case for the bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
      6d93f150
    • unknown's avatar
      Bug #26261: · 2e8e78a4
      unknown authored
       INSERT uses query_id to verify what fields are
       mentioned in the fields list of the INSERT command.
       However the check for that is made after the 
       ON DUPLICATE KEY is processed. This causes all
       the fields mentioned in ON DUPLICATE KEY to be 
       considered as mentioned in the fields list of 
       INSERT.
       Moved the check up, right after processing the
       fields list.
      
      
      mysql-test/r/insert_update.result:
        Bug #26261: test case
      mysql-test/t/insert_update.test:
        Bug #26261: test case
      sql/mysql_priv.h:
        Bug #26261: moved the check inside mysql_prepare_insert
      sql/sql_insert.cc:
        Bug #26261: move the check inside mysql_prepare_insert
        before setting up the ON DUPLICATE KEY part
      sql/sql_prepare.cc:
        Bug #26261: moved the check inside mysql_prepare_insert
      2e8e78a4
  16. 15 Mar, 2007 1 commit
    • unknown's avatar
      Bug#27033: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE if rows were · 542f18a3
      unknown authored
      touched but not actually changed.
      
      The LAST_INSERT_ID() is reset to 0 if no rows were inserted or changed.
      This is the case when an INSERT ... ON DUPLICATE KEY UPDATE updates a row
      with the same values as the row contains.
      
      Now the LAST_INSERT_ID() values is reset to 0 only if there were no rows
      successfully inserted or touched.
      The new 'touched' field is added to the COPY_INFO structure. It holds the
      number of rows that were touched no matter whether they were actually
      changed or not.
      
      
      sql/sql_class.h:
        Bug#27033: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE if rows were
        touched but not actually changed.
        
        The new 'touched' field is added to the COPY_INFO structure. It holds the
        number of rows that were touched no matter whether they were actually
        changed or not.
      mysql-test/r/insert_update.result:
        Added a test case for the bug#27033: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE if rows were
        touched but not actually changed.
      mysql-test/t/insert_update.test:
        Added a test case for the bug#27033: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE if rows were
        touched but not actually changed.
      sql/sql_insert.cc:
        Bug#27033: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE if rows were
        touched but not actually changed.
        
        Now the LAST_INSERT_ID() values is reset to 0 only if there were no rows
        successfully inserted or touched.
      542f18a3
  17. 02 Mar, 2007 1 commit
    • unknown's avatar
      WL#2936 · 1fc7f211
      unknown authored
        "Server Variables for Plugins"
        Implement support for plugins to declare server variables.
        Demonstrate functionality by removing InnoDB specific code from sql/*
        New feature for HASH - HASH_UNIQUE flag
        New feature for DYNAMIC_ARRAY - initializer accepts preallocated ptr.
        Completed support for plugin reference counting.
      
      
      include/hash.h:
        New flag for HASH
          HASH_UNIQUE
      include/my_getopt.h:
        New data types for options: ENUM and SET.
        Use typelib to enumerate possible values.
        New flag variable:
          my_getopt_skip_unknown
      include/my_sys.h:
        change to DYNAMIC_ARRAY init functions to support pre-allocated buffers
      include/mysql.h:
        relocate inclusion of typelib due to longlong requirement
      include/mysql/plugin.h:
        wl2936
          New declarations for plugin server variable support.
          New functions for use by plugins
      include/mysys_err.h:
        new my_getopt return value: EXIT_ARGUMENT_INVALID
      include/typelib.h:
        new typelib function: find_typeset(), returns an int which is a SET of
        the elements in the typelib
      mysql-test/r/im_utils.result:
        change to more specific command line settings
        --skip-innodb => --skip-plugin-innodb
        etc.
      mysql-test/r/log_tables.result:
        set default storage engine to MEMORY so that test will succeed even
        when some of the other named storage engines are not present
      mysql-test/r/ndb_dd_basic.result:
        change in error message
      mysql-test/r/partition_innodb.result:
        change in results
      mysql-test/r/ps_1general.result:
        bdb doesn't exist, use myisam for a non-transactional engine
      mysql-test/r/variables.result:
        information schema doesn't sort row results for server variables.
      mysql-test/t/log_tables.test:
        set default storage engine to MEMORY so that test will succeed even
        when some of the other named storage engines are not present
      mysql-test/t/ndb_dd_basic.test:
        ALTER LOGFILE GROUP no longer silently fail here
      mysql-test/t/partition_innodb.test:
        ALTER TABLE no longer silently fails for unknown storage engine
      mysql-test/t/ps_1general.test:
        remove unneccessary parts
        use myisam as it is an always present non-transactional engine
      mysql-test/t/variables.test:
        information schema doesn't sort row results for server variables.
      mysql-test/t/warnings_engine_disabled-master.opt:
        use the new style command line option
      mysys/array.c:
        change to DYNAMIC_ARRAY init functions to support pre-allocated buffers
      mysys/hash.c:
        New flag for HASH
          HASH_UNIQUE
        Implement HASH_UNIQUE functionality by performing a hash_search
      mysys/my_getopt.c:
        New data types for options: ENUM and SET.
        Use typelib to enumerate possible values.
        New flag variable:
          my_getopt_skip_unknown
      mysys/typelib.c:
        new typelib function: find_typeset(), returns an int which is a SET of
        the elements in the typelib
      sql/ha_ndbcluster.cc:
        use ha_statistic_increment() method instead of
        statistic_increment() function
        ha_ndbcluster variable has gone away.
      sql/ha_partition.cc:
        fix for reference counting
      sql/ha_partition.h:
        fix for reference counting
      sql/handler.cc:
        fixes for reference counting
      sql/handler.h:
        fixes for reference counting
        some new methods to aid storage engine writers
      sql/item_func.cc:
        find_sys_var() function now requires thd
      sql/item_sum.cc:
        fixes for ref counting
      sql/mysql_priv.h:
        remove unneccessary globals.
        new lock: LOCK_system_variables_hash
      sql/mysqld.cc:
        Remove InnoBase specific code.
        Support plugin command line processing.
      sql/set_var.cc:
        Remove InnoBase specific declarations
        Remove redundant declarations
        changes to permit new variables at run time
        changes for ref counting
      sql/set_var.h:
        changes to permit new variables at run time
        changes for ref counting
      sql/sql_base.cc:
        changes for ref counting
      sql/sql_cache.cc:
        mark code as needing work in the future
      sql/sql_class.cc:
        new functions to aid plugin authors
        initialize variables for dynamic plugin variables
      sql/sql_class.h:
        remove InnoBase specific declarations
        New declarations for plugin variables.
      sql/sql_connect.cc:
        initialization and cleanup of plugin variables
      sql/sql_delete.cc:
        change for ref counting
      sql/sql_insert.cc:
        change for ref counting
      sql/sql_lex.cc:
        changes for ref counting and plugin variables
      sql/sql_lex.h:
        add properties for plugin ref counting,
        add to distructor to clean up
      sql/sql_partition.cc:
        changes for ref counting
      sql/sql_plugin.cc:
        WL2936
          Plugin Variables
          New methods and code to support server variables for plugins.
          New code to complete plugin reference counting
          Debug code adds further indirection so that malloc debugging can be
          used to aid finding plugin ref count leaks
      sql/sql_plugin.h:
        WL2936
          Plugin Variables
          New methods and code to support server variables for plugins.
          New code to complete plugin reference counting
          Debug code adds further indirection so that malloc debugging can be
          used to aid finding plugin ref count leaks
      sql/sql_repl.cc:
        replication system variables moved here from set_var.cc
      sql/sql_repl.h:
        new function to initialise replication server variables
      sql/sql_select.cc:
        changes for ref counting
      sql/sql_show.cc:
        changes for ref counting
      sql/sql_table.cc:
        changes for ref counting
      sql/sql_tablespace.cc:
        use supplied functions instead of digging into data structures manually
      sql/sql_yacc.yy:
        changes for ref counting
        find_sys_var() now requires thd parameter
        changes on reporting errors to keep user-visible behaviour the same.
      sql/structs.h:
        changes for ref counting
      sql/table.cc:
        changes for ref counting
      sql/table.h:
        changes for ref counting
      storage/federated/ha_federated.cc:
        use ha_statistic_increment() method instead of statistic_increment()
        function
      storage/heap/ha_heap.cc:
        use ha_statistic_increment() method instead of statistic_increment()
        function
      storage/innobase/handler/ha_innodb.cc:
        use ha_statistic_increment() method instead of statistic_increment()
        function
        WL2936
          Move InnoBase specific code out of mysqld.cc and into here
          Declare all required server variables for InnoBase
      storage/innobase/include/trx0trx.h:
        store a bit more state so that InnoBase does not have to dig into
        mysqld internal data structures.
      storage/myisam/ha_myisam.cc:
        use ha_statistic_increment() method instead of statistic_increment()
        function
      storage/myisammrg/ha_myisammrg.cc:
        use ha_statistic_increment() method instead of statistic_increment()
        function
      1fc7f211
  18. 01 Mar, 2007 3 commits
    • unknown's avatar
      Bug#25122: Views based on a self-joined table aren't insertable. · 1437a9c5
      unknown authored
      When INSERT is done over a view the table being inserted into is 
      checked to be unique among all views tables. But if the view contains
      self-joined table an error will be thrown even if all tables are used under
      different aliases.
      
      The unique_table() function now also checks tables' aliases when needed.
      
      
      sql/mysql_priv.h:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated prototype of the unique_table() function.
      sql/sql_base.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Now the unique_table() function checks tables' aliases when needed.
      sql/sql_delete.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated calls to the unique_table() function.
      sql/sql_insert.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated calls to the unique_table() function.
      sql/sql_load.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated calls to the unique_table() function.
      sql/sql_parse.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated calls to the unique_table() function.
      sql/sql_update.cc:
        Bug#25122:  Views based on a self-joined table aren't insertable.
        Updated calls to the unique_table() function.
      1437a9c5
    • unknown's avatar
      Post-merge fix · 17b3cbe8
      unknown authored
      17b3cbe8
    • unknown's avatar
      Fixes of compilation warnings and errors. · b3fafa40
      unknown authored
      sql/mysql_priv.h:
        Removing compiler warning "NULL used in arithmetic"
      sql/mysqld.cc:
        First argument to WARN_DEPRECATED is supposed to be a pointer (to THD structure)
      sql/sql_insert.cc:
        Removing compiler warning "unused variable". Apparently query is not used when compiling libmysqld.
      sql/sql_yacc.yy:
        Removing compiler error "Macro already defined"
      b3fafa40
  19. 26 Feb, 2007 2 commits
  20. 24 Feb, 2007 2 commits
  21. 23 Feb, 2007 1 commit
    • unknown's avatar
      Fixed compiler warnings · 9e678492
      unknown authored
      Fixed compile-pentium64 scripts
      Fixed wrong estimate of update_with_key_prefix in sql-bench
      Merge bk-internal.mysql.com:/home/bk/mysql-5.1 into mysql.com:/home/my/mysql-5.1
      Fixed unsafe define of uint4korr()
      Fixed that --extern works with mysql-test-run.pl
      Small trivial cleanups
      This also fixes a bug in counting number of rows that are updated when we have many simultanous queries
      Move all connection handling and command exectuion main loop from sql_parse.cc to sql_connection.cc
      Split handle_one_connection() into reusable sub functions.
      Split create_new_thread() into reusable sub functions.
      Added thread_scheduler; Preliminary interface code for future thread_handling code.
      
      Use 'my_thread_id' for internal thread id's
      Make thr_alarm_kill() to depend on thread_id instead of thread
      Make thr_abort_locks_for_thread() depend on thread_id instead of thread
      In store_globals(), set my_thread_var->id to be thd->thread_id.
      Use my_thread_var->id as basis for my_thread_name()
      The above changes makes the connection we have between THD and threads more soft.
      
      Added a lot of DBUG_PRINT() and DBUG_ASSERT() functions
      Fixed compiler warnings
      Fixed core dumps when running with --debug
      Removed setting of signal masks (was never used)
      Made event code call pthread_exit() (portability fix)
      Fixed that event code doesn't call DBUG_xxx functions before my_thread_init() is called.
      Made handling of thread_id and thd->variables.pseudo_thread_id uniform.
      Removed one common 'not freed memory' warning from mysqltest
      Fixed a couple of usage of not initialized warnings (unlikely cases)
      Suppress compiler warnings from bdb and (for the moment) warnings from ndb
      
      
      BitKeeper/deleted/.del-SETUP.sh.rej:
        Rename: BUILD/SETUP.sh.rej -> BitKeeper/deleted/.del-SETUP.sh.rej
      BitKeeper/deleted/.del-configure.in.rej:
        Rename: configure.in.rej -> BitKeeper/deleted/.del-configure.in.rej
      BitKeeper/deleted/.del-my_global.h.rej:
        Rename: include/my_global.h.rej -> BitKeeper/deleted/.del-my_global.h.rej
      BitKeeper/deleted/.del-my_pthread.h.rej:
        Rename: include/my_pthread.h.rej -> BitKeeper/deleted/.del-my_pthread.h.rej
      BitKeeper/deleted/.del-mysql_client_test.c.rej:
        Rename: tests/mysql_client_test.c.rej -> BitKeeper/deleted/.del-mysql_client_test.c.rej
      BitKeeper/deleted/.del-mysqld.cc.rej~35c1c438e11ebd89:
        Rename: sql/mysqld.cc.rej -> BitKeeper/deleted/.del-mysqld.cc.rej~35c1c438e11ebd89
      BitKeeper/deleted/.del-sql_parse.cc.rej:
        Rename: sql/sql_parse.cc.rej -> BitKeeper/deleted/.del-sql_parse.cc.rej
      BitKeeper/deleted/.del-table.cc.rej:
        Rename: sql/table.cc.rej -> BitKeeper/deleted/.del-table.cc.rej
      BitKeeper/deleted/.del-thr_alarm.c.rej:
        Rename: mysys/thr_alarm.c.rej -> BitKeeper/deleted/.del-thr_alarm.c.rej
      BUILD/compile-pentium64:
        Update this to be in line with compile-pentium
      BUILD/compile-pentium:
        Send command line options to SETUP.sh
      BUILD/compile-solaris-sparc-debug:
        Update scripts
      BUILD/compile-solaris-sparc-forte:
        Update scripts
      BUILD/compile-solaris-sparc-purify:
        Update scripts
      BUILD/compile-solaris-sparc:
        Update scripts
      BitKeeper/deleted/.del-DbtupSystemRestart.cpp~15b54d7e4e75d2d:
        Removed compiler warning
      BitKeeper/deleted/.del-ha_berkeley.cc:
        Moved get_auto_primary_key() here as int5store() gives (wrong) compiler warnings in win64
      configure.in:
        Added detection of port_create and port.h (for future)as 
        ---
        manual merge
      BitKeeper/deleted/.del-ha_berkeley.h:
        Moved get_auto_primary_key() to ha_berkeley.cc
      BitKeeper/deleted/.del-mysqlmanager.c~e97636d71145a0b:
        Fixed compiler warnings
      BitKeeper/etc/ignore:
        added storage/ndb/src/ndbapi/ndberror_check
      client/mysqlbinlog.cc:
        Removed not needed 'static' (caused compiler warning)
      client/mysqldump.c:
        Fixed compiler warnings from 'max' build
      client/mysqltest.c:
        Free warning and query memory no abort.
        (Removes strange warnings on screen if mysql-test-run fails)
        Removed compiler warnings
        Portability fix for windows (windows doesn't have mode_t)
      client/sql_string.h:
        Removed compiler warning
      cmd-line-utils/readline/xmalloc.c:
        Fixed compiler warnings from 'max' build
      extra/charset2html.c:
        Fixed compiler warnings
      extra/comp_err.c:
        Fixed compiler warnings from 'max' build
      extra/yassl/include/lock.hpp:
        Fix for windows64
      extra/yassl/include/openssl/ssl.h:
        Changed prototype for SSL_set_fd() to fix compiler warnings (and possible errors) on windows 64 bit
      extra/yassl/include/socket_wrapper.hpp:
        Moved socket_t to ssl.h, to be able to removed compiler warnings on windows 64 bit
      extra/yassl/include/yassl.hpp:
        Fix for windows64
      extra/yassl/src/ssl.cpp:
        Removed compiler warning
        Detect wrong parameter (Happens when running test suite on solaris)
        Changed prototype for SSL_set_fd() to fix compiler warnings (and possible errors) on windows 64 bit
      extra/yassl/taocrypt/src/integer.cpp:
        Fixed compiler warnings
      extra/yassl/testsuite/testsuite.cpp:
        Removed compiler warning
      include/config-win.h:
        Added HAVE_WINSOCK2 (for future)
      include/my_dbug.h:
        Fixed DBUG_PROCESS() so that we don't get compiler warnings for it
      include/my_global.h:
        Fixed unsafe define of uint4korr()
        manual merge (ignore changes from 5.0)
        Fixed warnings on win64 when using int5store and int6store
      include/my_pthread.h:
        Added my_thread_id typedef
        Renamed 'my_thread_id() function to my_thead_dbug_id()
      include/thr_alarm.h:
        Make thr_alarm_kill() to depend on thread_id instead of thread
      include/thr_lock.h:
        Make thr_abort_locks_for_thread() depend on thread_id instead of thread
      libmysql/libmysql.def:
        Fixed compiler warnings on win64
      libmysqld/CMakeLists.txt:
        Added missing files
      libmysqld/Makefile.am:
        Added new files
      libmysqld/lib_sql.cc:
        Remove not needed code (store_globals() now takes care of things)
      mysql-test/lib/mtr_report.pl:
        Removed wrong messages when using --extern
      mysql-test/mysql-test-run.pl:
        Fixed that --extern works
        Print help on stdout instead of stderr (make it easier to pipe it to less)
        Fixed typo that caused mysql-test-run.pl to fail on Solaris
      mysql-test/r/keywords.result:
        manual merge
      mysql-test/r/ndb_lock.result:
        After merge fixes
      mysql-test/r/ps.result:
        Portability fix
      mysql-test/t/disabled.def:
        Disabled ndb_alter_table as this very often fails for me (and have done it for a long time)
      mysql-test/t/keywords.test:
        manual merge
      mysql-test/t/ndb_lock.test:
        Added other possible error code
      mysql-test/t/ps.test:
        Portability fix (when compiling without DLOPEN)
      mysql-test/t/wait_timeout.test:
        Don't run this if we are not using a thread per connection (as other thread_handling code may not support timeouts)
      mysys/base64.c:
        Fixed compiler warnings on win64
      mysys/mf_keycache.c:
        Fixed compiler warnings
      mysys/my_getopt.c:
        Fixed compiler warning
      mysys/my_init.c:
        Fixed compiler warning
        Re-indented long comment
      mysys/my_thr_init.c:
        Always use mysys_var->id to generate thread name (makes things uniform accross thread implementations and thread usage)
        Always generate my_thread_name() when using DBUG
        Ensure mysys_var->pthread_self is set
        Fixed compiler warnings
      mysys/ptr_cmp.c:
        Fixed compiler warnings from 'max' build
      mysys/thr_alarm.c:
        Change thr_alarm_kill() to use mysys_var->id instead of thread id
        Fixed compiler warning on windows
      mysys/thr_lock.c:
        Change thr_abort_locks_for_thread() to use mysys_var->id instead of thread id
        Add purecov statements around not tested code
        Fixed compiler warnings
      mysys/thr_mutex.c:
        my_thread_id() -> my_thread_dbug_id()
      server-tools/instance-manager/guardian.cc:
        Fixed compiler warning
      server-tools/instance-manager/instance.cc:
        Fixed compiler warning
      server-tools/instance-manager/mysql_connection.cc:
        Fixed compiler warnings
      server-tools/instance-manager/mysqlmanager.cc:
        Fixed compiler warnings
      sql/CMakeLists.txt:
        Added missing files
      sql/Makefile.am:
        Added new files
      sql/event_scheduler.cc:
        Added pthread_exit() calls
        Ensure DBUG_xxx calls are not made before my_thread_init()
        Use common functions to set up thread handling
      sql/field.h:
        manual merge
      sql/ha_ndbcluster.cc:
        Removed some trivial 'current_thd' calls
      sql/handler.cc:
        Avoid warnings on KILL_CONNECTION
        Don't print out null pointer with printf()  (Causes crashes on Solaris)
      sql/item.cc:
        Fixed compiler warnings from 'max' build
      sql/item_cmpfunc.cc:
        After merge fixes
      sql/item_func.cc:
        Merge embedded and normal code usage
        (GET_LOCK, RELEASE_LOCK now works on my_thread_id instead of pthread_t)
        Fixed compiler warning
      sql/item_strfunc.cc:
        Fixed compiler warning
      sql/item_timefunc.cc:
        Fixed compiler warnings
      sql/lock.cc:
        Use (new) parameter to thr_abort_locks_for_thread()
      sql/log.cc:
        Fixed compiler warning
      sql/log_event.cc:
        Fixed compiler warnings about not used variable
      sql/mysql_priv.h:
        Remove TEST_NO_THREADS (not needed with new scheduler interface)
        Added functions from sql_connect.cc and new functions from sql_parse.cc
      sql/mysqld.cc:
        Use thread_scheduler structure to dispatch calls (make code more dynamic)
        Change --one-thread option to use thread_scheduler interface
        Made ONE_THREAD option independent of DBUG_BUILD
        --one-thread is now depricated. One should instead use '--thread-handling=no-threads'
        Remove not used uname() function.
        Split create_new_thread() into reusable sub functions.
        Preliminary interface code for future thread_handling code.
        Fixed compiler warnings
      sql/parse_file.cc:
        Don't send zero pointer to fn_format() (Causes crashes when using --debug)
      sql/repl_failsafe.cc:
        Setup pseudo_thread_id same way as other code
      sql/set_var.cc:
        Added variables 'thread_handling'
        Prepare for future variable 'thread_pool_size'
        Fixed compiler warnings
      sql/set_var.h:
        Fixed compiler warning
      sql/slave.cc:
        Setup pseudo_thread_id same way as other code
        Removed not used signal mask
      sql/sql_acl.cc:
        Fixed compiler warnings from 'max' build
      sql/sql_base.cc:
        Fixed long comments
        Normalized variable setup
        Don't destroy value of thd->variables.pseduo_thread_id
        More DBUG_PRINT()'s
        More DBUG_ASSERT()'s
        Fixed compiler warnings from 'max' build
      sql/sql_class.cc:
        Remove thd->real_id and thd->dbug_thread_id
        Added DBUG_ASSERT()
        Use thread_scheduler to signal threads to be killed.
        In THD::store_globals(), set my_thread_var->id to be thd->thread_id.
        Fixed compiler warnings
      sql/sql_class.h:
        Use 'my_thread_id' for internal thread id's
        Remove not needed THD elements: block_signals and dbug_thread_id
        Added 'thread_scheduler' scheduling extension element to THD
      sql/sql_insert.cc:
        After merge fixes
        (This actually fixes a bug in old code when many connections are in use)
        Setup pseudo_thread_id same way as other code
        Removed not used signal mask
        Initialize variable that may be used unitialized on error conditions (not fatal)
      sql/sql_parse.cc:
        Move connection related code to sql_connect.cc
        Remove setting of signal mask (not needed)
        Ensure TABLE_LIST->alias is set for generated TABLE_LIST elements (fixed core dumps when running with --debug)
        Added previous 'optional' element to reset_mgh()
        Removed not needed DBUG_PRINT call
      sql/sql_partition.cc:
        Fixed compiler warnings
      sql/sql_prepare.cc:
        Removed not needed casts
        Fixed compiler warnings from 'max' build
      sql/sql_select.cc:
        Fixed compiler warnings
      sql-bench/bench-init.pl.sh:
        Added --one-missing-tests
      sql-bench/example:
        Better example
      sql-bench/run-all-tests.sh:
        Added --only-missing-tests
      sql-bench/test-insert.sh:
        Fixed wrong estimate of update_with_key_prefix
      sql/sql_show.cc:
        Don't send pthread_kill() to threads to detect if they exists.
        (Not that useful and causes problems with future thread_handling code)
        Fixed compiler warnings
      sql/sql_table.cc:
        Simplify code
        Fixed compiler warnings
      sql/sql_test.cc:
        Remove dbug_thread_id from test output
      sql/sql_view.cc:
        Don't send zero pointer to fn_format()
      sql/tztime.cc:
        Fixed compiler warning
      sql/udf_example.def:
        Fixed compiler warnings on win64
      sql/unireg.cc:
        Initialize variable that may be used unitialized on error conditions
      storage/archive/archive_test.c:
        Fixed compiler warnings
      storage/archive/azio.c:
        Fixed compiler warnings
      storage/innobase/dict/dict0crea.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/dict/dict0dict.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/dict/dict0load.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/dict/dict0mem.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/eval/eval0proc.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/handler/ha_innodb.cc:
        Fixed compiler warnings detected on windows64
      storage/innobase/include/ut0byte.ic:
        Fixed compiler warnings on win64
      storage/innobase/include/ut0ut.ic:
        Fixed compiler warnings on win64
      storage/innobase/mtr/mtr0log.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/pars/pars0lex.l:
        Fixed warnings on win64
      storage/innobase/rem/rem0cmp.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/row/row0mysql.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/row/row0sel.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/sync/sync0rw.c:
        Fixed compiler warnings detected on windows64
      storage/innobase/trx/trx0trx.c:
        Fixed compiler warnings detected on windows64
      storage/myisam/mi_log.c:
        my_thread_id() -> my_thread_debug_id()
      storage/myisam/mi_packrec.c:
        Fixed compiler warnings detected on windows64
      storage/myisam/myisamchk.c:
        Fixed compiler warnings from 'max' build
      storage/ndb/src/common/debugger/EventLogger.cpp:
        Fixed compiler warnings
      storage/ndb/src/common/util/ConfigValues.cpp:
        Removed compiler warnings
      storage/ndb/src/common/util/NdbSqlUtil.cpp:
        Removed compiler warnings
      storage/ndb/src/cw/cpcd/CPCD.hpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/backup/Backup.cpp:
        Fixed compiler warnings detected on windows64
      storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp:
        Fixed compiler warnings detected on windows64
      storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp:
        Fixed compiler warnings detected on windows64
      storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/tuppage.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtup/tuppage.hpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/dbtux/DbtuxStat.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/blocks/diskpage.hpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/vm/ndbd_malloc.cpp:
        Fixed compiler warnings
      storage/ndb/src/kernel/vm/ndbd_malloc_impl.cpp:
        Fixed compiler warnings
      storage/ndb/src/mgmclient/main.cpp:
        Fixed compiler warnings
      storage/ndb/src/ndbapi/NdbEventOperationImpl.cpp:
        Fixed compiler warnings
      storage/ndb/src/ndbapi/NdbOperationExec.cpp:
        Fixed compiler warnings
      storage/ndb/src/ndbapi/SignalSender.cpp:
        Fixed compiler warnings
      storage/ndb/tools/restore/consumer_restore.cpp:
        Fixed compiler warnings
      strings/ctype-ucs2.c:
        Fixed compiler warnings
      strings/ctype-utf8.c:
        Fixed compiler warnings
      strings/decimal.c:
        Fixed compiler warnings
      strings/my_strchr.c:
        Fixed conflict between function and prototype
      support-files/compiler_warnings.supp:
        Ignore warnings from sql_yacc.cc that are hard to remove
        Ignore some not important warnings from windows 64 bit build
        Suppress warnings from bdb and (for the moment) warnings from ndb
        Suppress all warnings for all pushbuild platforms (should make all trees green)
      vio/viosslfactories.c:
        Added DBUG_PRINT
      BUILD/compile-pentium64-max:
        New BitKeeper file ``BUILD/compile-pentium64-max''
      libmysqld/scheduler.cc:
        New BitKeeper file ``libmysqld/scheduler.cc''
      libmysqld/sql_connect.cc:
        New BitKeeper file ``libmysqld/sql_connect.cc''
      mysql-test/include/one_thread_per_connection.inc:
        New BitKeeper file ``mysql-test/include/one_thread_per_connection.inc''
      mysql-test/r/no-threads.result:
        New BitKeeper file ``mysql-test/r/no-threads.result''
      mysql-test/r/one_thread_per_connection.require:
        New BitKeeper file ``mysql-test/r/one_thread_per_connection.require''
      mysql-test/t/no-threads-master.opt:
        New BitKeeper file ``mysql-test/t/no-threads-master.opt''
      mysql-test/t/no-threads.test:
        New BitKeeper file ``mysql-test/t/no-threads.test''
      sql/scheduler.cc:
        New BitKeeper file ``sql/scheduler.cc''
      sql/scheduler.h:
        New BitKeeper file ``sql/scheduler.h''
      sql/sql_connect.cc:
        New BitKeeper file ``sql/sql_connect.cc''
      9e678492
  22. 22 Feb, 2007 1 commit
    • unknown's avatar
      Fixed compiler warnings (for linux and win32 and win64) · 50bd97a9
      unknown authored
      Fixed a couple of usage of not initialized warnings (unlikely cases)
      
      
      client/mysqldump.c:
        Fixed compiler warnings from 'max' build
      client/mysqltest.c:
        Removed compiler warnings
      cmd-line-utils/readline/xmalloc.c:
        Fixed compiler warnings from 'max' build
      extra/comp_err.c:
        Fixed compiler warnings from 'max' build
      extra/yassl/include/openssl/ssl.h:
        Changed prototype for SSL_set_fd() to fix compiler warnings (and possible errors) on windows 64 bit
      extra/yassl/include/socket_wrapper.hpp:
        Moved socket_t to ssl.h, to be able to removed compiler warnings on windows 64 bit
      extra/yassl/src/ssl.cpp:
        Changed prototype for SSL_set_fd() to fix compiler warnings (and possible errors) on windows 64 bit
      extra/yassl/taocrypt/src/integer.cpp:
        Fixed compiler warnings
      include/my_global.h:
        Added my_offsetof() macro from 5.1 to get rid of compiler warnings
      innobase/include/ut0byte.ic:
        Fixed compiler warnings on win64
      innobase/include/ut0ut.ic:
        Fixed compiler warnings on win64
      libmysql/libmysql.def:
        Fixed compiler warnings on win64
      myisam/mi_packrec.c:
        Fixed compiler warnings on win64
      myisam/myisamchk.c:
        Fixed compiler warnings from 'max' build
      mysys/base64.c:
        Fixed compiler warnings on win64
      mysys/mf_keycache.c:
        Fixed compiler warnings from 'max' build
      mysys/my_getopt.c:
        Fixed compiler warnings from 'max' build
      mysys/my_init.c:
        Fixed compiler warnings from 'max' build
      mysys/my_thr_init.c:
        Fixed compiler warnings
      mysys/ptr_cmp.c:
        Fixed compiler warnings from 'max' build
      ndb/include/kernel/signaldata/DictTabInfo.hpp:
        Fixed compiler warnings
      server-tools/instance-manager/mysql_connection.cc:
        Fixed compiler warnings
      server-tools/instance-manager/mysqlmanager.cc:
        Fixed compiler warnings
      sql/filesort.cc:
        Initalize variable that was used unitialized in error conditions
      sql/ha_berkeley.cc:
        Moved get_auto_primary_key() here as int5store() gives (wrong) compiler warnings in win64
      sql/ha_berkeley.h:
        Moved get_auto_primary_key() to ha_berkeley.cc
      sql/ha_innodb.cc:
        Fixed compiler warnings
      sql/item.cc:
        Fixed compiler warnings from 'max' build
      sql/item_timefunc.cc:
        Fixed compiler warnings
      sql/mysqld.cc:
        Fixed compiler warnings
      sql/sql_acl.cc:
        Fixed compiler warnings from 'max' build
      sql/sql_base.cc:
        Fixed compiler warnings from 'max' build
      sql/sql_insert.cc:
        Initialize variable that may be used unitialized on error conditions (not fatal)
      sql/sql_prepare.cc:
        Fixed compiler warnings from 'max' build
      sql/sql_select.cc:
        Fixed compiler warnings
      sql/sql_show.cc:
        Fixed compiler warnings
      sql/udf_example.def:
        Fixed compiler warnings on win64
      sql/unireg.cc:
        Initialize variable that may be used unitialized on error conditions
      strings/ctype-ucs2.c:
        Fixed compiler warnings
      strings/ctype-utf8.c:
        Fixed compiler warnings
      strings/decimal.c:
        Fixed compiler warnings
      support-files/compiler_warnings.supp:
        Ignore warnings from sql_yacc.cc that are hard to remove
        Ignore some not important warnings from windows 64 bit build
      tools/mysqlmanager.c:
        Fixed compiler warnings
      50bd97a9
  23. 21 Feb, 2007 1 commit
    • unknown's avatar
      After merge fixes · e5706080
      unknown authored
      This also fixes a bug in counting number of rows that are updated when we have many simultanous queries
      
      
      extra/yassl/src/ssl.cpp:
        Removed compiler warning
      extra/yassl/taocrypt/src/asn.cpp:
        After merge fixes
      extra/yassl/testsuite/testsuite.cpp:
        Removed compiler warning
      mysql-test/r/ndb_lock.result:
        After merge fixes
      ndb/src/common/debugger/EventLogger.cpp:
        Removed compiler warning
      ndb/src/common/util/ConfigValues.cpp:
        Removed compiler warning
      ndb/src/common/util/NdbSqlUtil.cpp:
        Removed compiler warning
      ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
        Removed compiler warning
      ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp:
        Removed compiler warning
      ndb/src/kernel/blocks/dbtup/DbtupSystemRestart.cpp:
        Removed compiler warning
      ndb/src/kernel/vm/ndbd_malloc.cpp:
        Removed compiler warning
      ndb/src/mgmclient/main.cpp:
        Removed compiler warning
      ndb/src/ndbapi/SignalSender.cpp:
        Removed compiler warning
      sql/ha_ndbcluster.cc:
        Some extra safety
      sql/item_cmpfunc.cc:
        After merge fixes
      sql/item_subselect.cc:
        After merge fixes
      sql/sql_insert.cc:
        After merge fixes
        (This actually fixes a bug in old code when many connections are in use)
      support-files/compiler_warnings.supp:
        Removed some suppressed warnings
      e5706080
  24. 19 Feb, 2007 1 commit
    • unknown's avatar
      Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving. · a97fd193
      unknown authored
       Several problems fixed: 
        1. There was a "catch-all" context initialization in setup_tables()
          that was causing the table that we insert into to be visible in the 
          SELECT part of an INSERT .. SELECT .. statement with no tables in
          its FROM clause. This was making sure all the under-initialized
          contexts in various parts of the code are not left uninitialized.
          Fixed by removing the "catch-all" statement and initializing the 
          context in the parser.
        2. Incomplete name resolution context when resolving the right-hand
          values in the ON DUPLICATE KEY UPDATE ... part of an INSERT ... SELECT ...
          caused columns from NATURAL JOIN/JOIN USING table references in the
          FROM clause of the select to be unavailable.
          Fixed by establishing a proper name resolution context.
        3. When setting up the special name resolution context for problem 2
          there was no check for cases where an aggregate function without a
          GROUP BY effectively takes the column from the SELECT part of an 
          INSERT ... SELECT unavailable for ON DUPLICATE KEY UPDATE.
          Fixed by checking for that condition when setting up the name 
          resolution context.
      
      
      mysql-test/r/insert_update.result:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - test case
      mysql-test/t/insert_update.test:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - test case
      sql/item.h:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - save_next_local is not referenced any more outside class methods
      sql/sql_base.cc:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - removed a "catch-all" code to cater for correct context initialization
      sql/sql_help.cc:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - fixed the name resolution context initialization
      sql/sql_insert.cc:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - Fixed the context of resolving the values in INSERT SELECT ON UPDATE
      sql/sql_prepare.cc:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - Correct context for name resolution of prepared INSERT .. SELECT
      sql/sql_union.cc:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - fixed the name resolution context initialization
      sql/sql_yacc.yy:
        Bug #25831: Deficiencies in INSERT ... SELECT ... field name resolving.
         - Set the context here instead of setup_tables()
      a97fd193