An error occurred fetching the project authors.
  1. 10 Aug, 2006 1 commit
  2. 02 Aug, 2006 1 commit
    • ingo/istruewing@chilla.local's avatar
      Bug#18775 - Temporary table from alter table visible to other threads · 8e4c36ad
      ingo/istruewing@chilla.local authored
      Continued implementation of WL#1324 (table name to filename encoding)
      
      The intermediate (not temporary) files of the new table
      during ALTER TABLE was visible for SHOW TABLES. These
      intermediate files are copies of the original table with
      the changes done by ALTER TABLE. After all the data is
      copied over from the original table, these files are renamed 
      to the original tables file names. So they are not temporary 
      files. They persist after ALTER TABLE, but just with another 
      name.
      
      In 5.0 the intermediate files are invisible for SHOW TABLES
      because all file names beginning with "#sql" were suppressed.
      
      This failed since 5.1.6 because even temporary table names were
      converted when making file names from them. The prefix became
      converted to "@0023sql". Converting the prefix during SHOW TABLES
      would suppress the listing of user tables that start with "#sql".
      
      The solution of the problem is to continue the implementation of
      the table name to file name conversion feature. One requirement
      is to suppress the conversion for temporary table names.
      
      This change is straightforward for real temporary tables as there
      is a function that creates temporary file names.
      
      But the generated path names are located in TMPDIR and have no
      relation to the internal table name. This cannot be used for
      ALTER TABLE. Its intermediate files need to be in the same
      directory as the old table files. And it is necessary to be
      able to deduce the same path from the same table name repeatedly.
      
      Consequently the intermediate table files must be handled like normal
      tables. Their internal names shall start with tmp_file_prefix
      (#sql) and they shall not be converted like normal table names.
      
      I added a flags parameter to all relevant functions that are
      called from ALTER TABLE. It is used to suppress the conversion
      for the intermediate table files.
      
      The outcome is that the suppression of #sql in SHOW TABLES
      works again. It does not suppress user tables as these are
      converted to @0023sql on file level.
      
      This patch does also fix ALTER TABLE ... RENAME, which could not 
      rename a table with non-ASCII characters in its name.
      
      It does also fix the problem that a user could create a table like
      `#sql-xxxx-yyyy`, where xxxx is mysqld's pid and yyyy is the thread
      ID of some other thread, which prevented this thread from running 
      ALTER TABLE.
      
      Some of the above problems are mentioned in Bug 1405, which can
      be closed with this patch.
      
      This patch does also contain some minor fixes for other forgotten
      conversions. Still known problems are reported as bugs 21370,
      21373, and 21387.
      8e4c36ad
  3. 28 Jul, 2006 1 commit
    • kroki/tomash@moonlight.intranet's avatar
      Bug#16581: deadlock: server and client both read from connection in · d06001b1
      kroki/tomash@moonlight.intranet authored
                 'conc_sys' test
      
      Concurrent execution of SELECT involing at least two INFORMATION_SCHEMA
      tables, DROP DATABASE statement and DROP TABLE statement could have
      resulted in stalled connection for this SELECT statement.
      
      The problem was that for the first query of a join there was a race
      between select from I_S.TABLES and DROP DATABASE, and the error (no
      such database) was prepared to be send to the client, but the join
      processing was continued.  On second query to I_S.COLUMNS there was a
      race with DROP TABLE, but this error (no such table) was downgraded to
      warning, and thd->net.report_error was reset.  And so neither result
      nor error was sent to the client.
      
      The solution is to stop join processing once it is clear we are going
      to report a error, and also to downgrade to warnings file system errors
      like 'no such database' (unless we are in the 'SHOW' command), because
      I_S is designed not to use locks and the query to I_S should not abort
      if something is dropped in the middle.
      
      No test case is provided since this bug is a result of a race, and is
      timing dependant.  But we test that plain SHOW TABLES and SHOW COLUMNS
      give a error if there is no such database or a table respectively.
      d06001b1
  4. 27 Jul, 2006 1 commit
    • anozdrin/alik@booka.'s avatar
      Fix for BUG#16211: Stored function return type for strings is ignored. · b7f403b5
      anozdrin/alik@booka. authored
      Fix for BUG#16676: Database CHARSET not used for stored procedures
      
      The problem in BUG#16211 is that CHARSET-clause of the return type for
      stored functions is just ignored.
      
      The problem in BUG#16676 is that if character set is not explicitly
      specified for sp-variable, the server character set is used instead
      of the database one.
      
      The fix has two parts:
      
        - always store CHARSET-clause of the return type along with the
          type definition in mysql.proc.returns column. "Always" means that
          CHARSET-clause is appended even if it has not been explicitly
          specified in CREATE FUNCTION statement (this affects BUG#16211 only).
      
          Storing CHARSET-clause if it is not specified is essential to avoid
          changing character set if the database character set is altered in
          the future.
      
          NOTE: this change is not backward compatible with the previous releases.
      
        - use database default character set if CHARSET-clause is not explicitly
          specified (this affects both BUG#16211 and BUG#16676).
      
          NOTE: this also breaks backward compatibility.
      b7f403b5
  5. 22 Jul, 2006 1 commit
  6. 21 Jul, 2006 1 commit
  7. 20 Jul, 2006 2 commits
  8. 14 Jul, 2006 1 commit
  9. 06 Jul, 2006 1 commit
    • dlenev@mysql.com's avatar
      After merge fixes for patch solving bug#18437 "Wrong values inserted with a · d6f47c31
      dlenev@mysql.com authored
      before update trigger on NDB table".
      
      Two main changes:
      - We use TABLE::read_set/write_set bitmaps for marking fields used by
        statement instead of Field::query_id in 5.1.
      - Now when we mark columns used by statement we take into account columns 
        used by table's triggers instead of marking all columns as used if table
        has triggers.
      d6f47c31
  10. 04 Jul, 2006 1 commit
  11. 01 Jul, 2006 1 commit
    • dlenev@mysql.com's avatar
      Fix for bug#18437 "Wrong values inserted with a before update trigger on · d4450e66
      dlenev@mysql.com authored
      NDB table".
      
      SQL-layer was not marking fields which were used in triggers as such. As
      result these fields were not always properly retrieved/stored by handler
      layer. So one might got wrong values or lost changes in triggers for NDB,
      Federated and possibly InnoDB tables.
      This fix solves the problem by marking fields used in triggers
      appropriately.
      
      Also this patch contains the following cleanup of ha_ndbcluster code:
      
      We no longer rely on reading LEX::sql_command value in handler in order
      to determine if we can enable optimization which allows us to handle REPLACE
      statement in more efficient way by doing replaces directly in write_row()
      method without reporting error to SQL-layer.
      Instead we rely on SQL-layer informing us whether this optimization
      applicable by calling handler::extra() method with
      HA_EXTRA_WRITE_CAN_REPLACE flag.
      As result we no longer apply this optimzation in cases when it should not
      be used (e.g. if we have on delete triggers on table) and use in some
      additional cases when it is applicable (e.g. for LOAD DATA REPLACE).
      
      Finally this patch includes fix for bug#20728 "REPLACE does not work
      correctly for NDB table with PK and unique index".
        
      This was yet another problem which was caused by improper field mark-up.
      During row replacement fields which weren't explicity used in REPLACE
      statement were not marked as fields to be saved (updated) so they have
      retained values from old row version. The fix is to mark all table
      fields as set for REPLACE statement. Note that in 5.1 we already solve
      this problem by notifying handler that it should save values from all
      fields only in case when real replacement happens.
      d4450e66
  12. 29 Jun, 2006 1 commit
  13. 26 Jun, 2006 1 commit
    • ingo@mysql.com's avatar
      Bug#16986 - Deadlock condition with MyISAM tables · d27a15a8
      ingo@mysql.com authored
      Addendum fixes after changing the condition variable
      for the global read lock.
      
      The stress test suite revealed some deadlocks. Some were
      related to the new condition variable (COND_global_read_lock)
      and some were general problems with the global read lock.
      
      It is now necessary to signal COND_global_read_lock whenever 
      COND_refresh is signalled.
      
      We need to wait for the release of a global read lock if one 
      is set before every operation that requires a write lock.
      But we must not wait if we have locked tables by LOCK TABLES.
      After setting a global read lock a thread waits until all
      write locks are released.
      d27a15a8
  14. 22 Jun, 2006 1 commit
  15. 21 Jun, 2006 2 commits
    • mikael@dator5.(none)'s avatar
      BUG#19309: Problem with calling proecdures twice · de9eb496
      mikael@dator5.(none) authored
      Need to flag when a copy is needed to not overwrite a create_info
      object connected to the lex structure
      de9eb496
    • gkodinov@mysql.com's avatar
      Bug #20482: failure on Create join view with sources views/tables in different · 75ca0554
      gkodinov@mysql.com authored
                  schemas
      The function check_one_table_access() called to check access to tables in 
      SELECT/INSERT/UPDATE was doing additional checks/modifications that don't hold
      in the context of setup_tables_and_check_access().
      That's why the check_one_table() was split into two : the functionality needed by
      setup_tables_and_check_access() into check_single_table_access() and the rest of 
      the functionality stays in check_one_table_access() that is made to call the new
      check_single_table_access() function.
      75ca0554
  16. 20 Jun, 2006 1 commit
    • monty@mysql.com's avatar
      SHOW STATUS does not anymore change local status variables (except... · be269e56
      monty@mysql.com authored
      SHOW STATUS does not anymore change local status variables (except com_show_status). Global status variables are still updated.
      SHOW STATUS are not anymore put in slow query log because of no index usage.
      
      Implemntation done by removing orig_sql_command and moving logic of SHOW STATUS to mysql_excute_command()
      This simplifies code and allows us to remove some if statements all over the code.
      
      Upgraded uc_update_queries[] to sql_command_flags and added more bitmaps to better categorize commands.
      This allowed some overall simplifaction when testing sql_command.
      
      Fixes bugs:
      Bug#10210: running SHOW STATUS increments counters it shouldn't
      Bug#19764: SHOW commands end up in the slow log as table scans
      be269e56
  17. 19 Jun, 2006 1 commit
  18. 12 Jun, 2006 1 commit
  19. 08 Jun, 2006 1 commit
    • andrey@lmy004.'s avatar
      Reorganize, physically the events code · 1d1e9d10
      andrey@lmy004. authored
      Unify method naming -> create/update/drop_event
      Move class Event_timed to event_timed.h
      class Events is in events.h (renamed from event.h)
      The implementation is in events.cc (renamed from event.h)
      1d1e9d10
  20. 04 Jun, 2006 1 commit
    • monty@mysql.com's avatar
      This changeset is largely a handler cleanup changeset (WL#3281), but includes... · 74cc73d4
      monty@mysql.com authored
      This changeset is largely a handler cleanup changeset (WL#3281), but includes fixes and cleanups that was found necessary while testing the handler changes
      
      Changes that requires code changes in other code of other storage engines.
      (Note that all changes are very straightforward and one should find all issues
      by compiling a --debug build and fixing all compiler errors and all
      asserts in field.cc while running the test suite),
      
      - New optional handler function introduced: reset()
        This is called after every DML statement to make it easy for a handler to
        statement specific cleanups.
        (The only case it's not called is if force the file to be closed)
      
      - handler::extra(HA_EXTRA_RESET) is removed. Code that was there before
        should be moved to handler::reset()
      
      - table->read_set contains a bitmap over all columns that are needed
        in the query.  read_row() and similar functions only needs to read these
        columns
      - table->write_set contains a bitmap over all columns that will be updated
        in the query. write_row() and update_row() only needs to update these
        columns.
        The above bitmaps should now be up to date in all context
        (including ALTER TABLE, filesort()).
      
        The handler is informed of any changes to the bitmap after
        fix_fields() by calling the virtual function
        handler::column_bitmaps_signal(). If the handler does caching of
        these bitmaps (instead of using table->read_set, table->write_set),
        it should redo the caching in this code. as the signal() may be sent
        several times, it's probably best to set a variable in the signal
        and redo the caching on read_row() / write_row() if the variable was
        set.
      
      - Removed the read_set and write_set bitmap objects from the handler class
      
      - Removed all column bit handling functions from the handler class.
        (Now one instead uses the normal bitmap functions in my_bitmap.c instead
        of handler dedicated bitmap functions)
      
      - field->query_id is removed. One should instead instead check
        table->read_set and table->write_set if a field is used in the query.
      
      - handler::extra(HA_EXTRA_RETRIVE_ALL_COLS) and
        handler::extra(HA_EXTRA_RETRIEVE_PRIMARY_KEY) are removed. One should now
        instead use table->read_set to check for which columns to retrieve.
      
      - If a handler needs to call Field->val() or Field->store() on columns
        that are not used in the query, one should install a temporary
        all-columns-used map while doing so. For this, we provide the following
        functions:
      
        my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
        field->val();
        dbug_tmp_restore_column_map(table->read_set, old_map);
      
        and similar for the write map:
      
        my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
        field->val();
        dbug_tmp_restore_column_map(table->write_set, old_map);
      
        If this is not done, you will sooner or later hit a DBUG_ASSERT
        in the field store() / val() functions.
        (For not DBUG binaries, the dbug_tmp_restore_column_map() and
        dbug_tmp_restore_column_map() are inline dummy functions and should
        be optimized away be the compiler).
      
      - If one needs to temporary set the column map for all binaries (and not
        just to avoid the DBUG_ASSERT() in the Field::store() / Field::val()
        methods) one should use the functions tmp_use_all_columns() and
        tmp_restore_column_map() instead of the above dbug_ variants.
      
      - All 'status' fields in the handler base class (like records,
        data_file_length etc) are now stored in a 'stats' struct. This makes
        it easier to know what status variables are provided by the base
        handler.  This requires some trivial variable names in the extra()
        function.
      
      - New virtual function handler::records().  This is called to optimize
        COUNT(*) if (handler::table_flags() & HA_HAS_RECORDS()) is true.
        (stats.records is not supposed to be an exact value. It's only has to
        be 'reasonable enough' for the optimizer to be able to choose a good
        optimization path).
      
      - Non virtual handler::init() function added for caching of virtual
        constants from engine.
      
      - Removed has_transactions() virtual method. Now one should instead return
        HA_NO_TRANSACTIONS in table_flags() if the table handler DOES NOT support
        transactions.
      
      - The 'xxxx_create_handler()' function now has a MEM_ROOT_root argument
        that is to be used with 'new handler_name()' to allocate the handler
        in the right area.  The xxxx_create_handler() function is also
        responsible for any initialization of the object before returning.
      
        For example, one should change:
      
        static handler *myisam_create_handler(TABLE_SHARE *table)
        {
          return new ha_myisam(table);
        }
      
        ->
      
        static handler *myisam_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
        {
          return new (mem_root) ha_myisam(table);
        }
      
      - New optional virtual function: use_hidden_primary_key().
        This is called in case of an update/delete when
        (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
        but we don't have a primary key. This allows the handler to take precisions
        in remembering any hidden primary key to able to update/delete any
        found row. The default handler marks all columns to be read.
      
      - handler::table_flags() now returns a ulonglong (to allow for more flags).
      
      - New/changed table_flags()
        - HA_HAS_RECORDS	    Set if ::records() is supported
        - HA_NO_TRANSACTIONS	    Set if engine doesn't support transactions
        - HA_PRIMARY_KEY_REQUIRED_FOR_DELETE
                                  Set if we should mark all primary key columns for
      			    read when reading rows as part of a DELETE
      			    statement. If there is no primary key,
      			    all columns are marked for read.
        - HA_PARTIAL_COLUMN_READ  Set if engine will not read all columns in some
      			    cases (based on table->read_set)
       - HA_PRIMARY_KEY_ALLOW_RANDOM_ACCESS
         			    Renamed to HA_PRIMARY_KEY_REQUIRED_FOR_POSITION.
       - HA_DUPP_POS              Renamed to HA_DUPLICATE_POS
       - HA_REQUIRES_KEY_COLUMNS_FOR_DELETE
      			    Set this if we should mark ALL key columns for
      			    read when when reading rows as part of a DELETE
      			    statement. In case of an update we will mark
      			    all keys for read for which key part changed
      			    value.
        - HA_STATS_RECORDS_IS_EXACT
      			     Set this if stats.records is exact.
      			     (This saves us some extra records() calls
      			     when optimizing COUNT(*))
      			    
      
      - Removed table_flags()
        - HA_NOT_EXACT_COUNT     Now one should instead use HA_HAS_RECORDS if
      			   handler::records() gives an exact count() and
      			   HA_STATS_RECORDS_IS_EXACT if stats.records is exact.
        - HA_READ_RND_SAME	   Removed (no one supported this one)
      
      - Removed not needed functions ha_retrieve_all_cols() and ha_retrieve_all_pk()
      
      - Renamed handler::dupp_pos to handler::dup_pos
      
      - Removed not used variable handler::sortkey
      
      
      Upper level handler changes:
      
      - ha_reset() now does some overall checks and calls ::reset()
      - ha_table_flags() added. This is a cached version of table_flags(). The
        cache is updated on engine creation time and updated on open.
      
      
      MySQL level changes (not obvious from the above):
      
      - DBUG_ASSERT() added to check that column usage matches what is set
        in the column usage bit maps. (This found a LOT of bugs in current
        column marking code).
      
      - In 5.1 before, all used columns was marked in read_set and only updated
        columns was marked in write_set. Now we only mark columns for which we
        need a value in read_set.
      
      - Column bitmaps are created in open_binary_frm() and open_table_from_share().
        (Before this was in table.cc)
      
      - handler::table_flags() calls are replaced with handler::ha_table_flags()
      
      - For calling field->val() you must have the corresponding bit set in
        table->read_set. For calling field->store() you must have the
        corresponding bit set in table->write_set. (There are asserts in
        all store()/val() functions to catch wrong usage)
      
      - thd->set_query_id is renamed to thd->mark_used_columns and instead
        of setting this to an integer value, this has now the values:
        MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE
        Changed also all variables named 'set_query_id' to mark_used_columns.
      
      - In filesort() we now inform the handler of exactly which columns are needed
        doing the sort and choosing the rows.
      
      - The TABLE_SHARE object has a 'all_set' column bitmap one can use
        when one needs a column bitmap with all columns set.
        (This is used for table->use_all_columns() and other places)
      
      - The TABLE object has 3 column bitmaps:
        - def_read_set     Default bitmap for columns to be read
        - def_write_set    Default bitmap for columns to be written
        - tmp_set          Can be used as a temporary bitmap when needed.
        The table object has also two pointer to bitmaps read_set and write_set
        that the handler should use to find out which columns are used in which way.
      
      - count() optimization now calls handler::records() instead of using
        handler->stats.records (if (table_flags() & HA_HAS_RECORDS) is true).
      
      - Added extra argument to Item::walk() to indicate if we should also
        traverse sub queries.
      
      - Added TABLE parameter to cp_buffer_from_ref()
      
      - Don't close tables created with CREATE ... SELECT but keep them in
        the table cache. (Faster usage of newly created tables).
      
      
      New interfaces:
      
      - table->clear_column_bitmaps() to initialize the bitmaps for tables
        at start of new statements.
      
      - table->column_bitmaps_set() to set up new column bitmaps and signal
        the handler about this.
      
      - table->column_bitmaps_set_no_signal() for some few cases where we need
        to setup new column bitmaps but don't signal the handler (as the handler
        has already been signaled about these before). Used for the momement
        only in opt_range.cc when doing ROR scans.
      
      - table->use_all_columns() to install a bitmap where all columns are marked
        as use in the read and the write set.
      
      - table->default_column_bitmaps() to install the normal read and write
        column bitmaps, but not signaling the handler about this.
        This is mainly used when creating TABLE instances.
      
      - table->mark_columns_needed_for_delete(),
        table->mark_columns_needed_for_delete() and
        table->mark_columns_needed_for_insert() to allow us to put additional
        columns in column usage maps if handler so requires.
        (The handler indicates what it neads in handler->table_flags())
      
      - table->prepare_for_position() to allow us to tell handler that it
        needs to read primary key parts to be able to store them in
        future table->position() calls.
        (This replaces the table->file->ha_retrieve_all_pk function)
      
      - table->mark_auto_increment_column() to tell handler are going to update
        columns part of any auto_increment key.
      
      - table->mark_columns_used_by_index() to mark all columns that is part of
        an index.  It will also send extra(HA_EXTRA_KEYREAD) to handler to allow
        it to quickly know that it only needs to read colums that are part
        of the key.  (The handler can also use the column map for detecting this,
        but simpler/faster handler can just monitor the extra() call).
      
      - table->mark_columns_used_by_index_no_reset() to in addition to other columns,
        also mark all columns that is used by the given key.
      
      - table->restore_column_maps_after_mark_index() to restore to default
        column maps after a call to table->mark_columns_used_by_index().
      
      - New item function register_field_in_read_map(), for marking used columns
        in table->read_map. Used by filesort() to mark all used columns
      
      - Maintain in TABLE->merge_keys set of all keys that are used in query.
        (Simplices some optimization loops)
      
      - Maintain Field->part_of_key_not_clustered which is like Field->part_of_key
        but the field in the clustered key is not assumed to be part of all index.
        (used in opt_range.cc for faster loops)
      
      -  dbug_tmp_use_all_columns(), dbug_tmp_restore_column_map()
         tmp_use_all_columns() and tmp_restore_column_map() functions to temporally
         mark all columns as usable.  The 'dbug_' version is primarily intended
         inside a handler when it wants to just call Field:store() & Field::val()
         functions, but don't need the column maps set for any other usage.
         (ie:: bitmap_is_set() is never called)
      
      - We can't use compare_records() to skip updates for handlers that returns
        a partial column set and the read_set doesn't cover all columns in the
        write set. The reason for this is that if we have a column marked only for
        write we can't in the MySQL level know if the value changed or not.
        The reason this worked before was that MySQL marked all to be written
        columns as also to be read. The new 'optimal' bitmaps exposed this 'hidden
        bug'.
      
      - open_table_from_share() does not anymore setup temporary MEM_ROOT
        object as a thread specific variable for the handler. Instead we
        send the to-be-used MEMROOT to get_new_handler().
        (Simpler, faster code)
      
      
      
      Bugs fixed:
      
      - Column marking was not done correctly in a lot of cases.
        (ALTER TABLE, when using triggers, auto_increment fields etc)
        (Could potentially result in wrong values inserted in table handlers
        relying on that the old column maps or field->set_query_id was correct)
        Especially when it comes to triggers, there may be cases where the
        old code would cause lost/wrong values for NDB and/or InnoDB tables.
      
      - Split thd->options flag OPTION_STATUS_NO_TRANS_UPDATE to two flags:
        OPTION_STATUS_NO_TRANS_UPDATE and OPTION_KEEP_LOG.
        This allowed me to remove some wrong warnings about:
        "Some non-transactional changed tables couldn't be rolled back"
      
      - Fixed handling of INSERT .. SELECT and CREATE ... SELECT that wrongly reset
        (thd->options & OPTION_STATUS_NO_TRANS_UPDATE) which caused us to loose
        some warnings about
        "Some non-transactional changed tables couldn't be rolled back")
      
      - Fixed use of uninitialized memory in ha_ndbcluster.cc::delete_table()
        which could cause delete_table to report random failures.
      
      - Fixed core dumps for some tests when running with --debug
      
      - Added missing FN_LIBCHAR in mysql_rm_tmp_tables()
        (This has probably caused us to not properly remove temporary files after
        crash)
      
      - slow_logs was not properly initialized, which could maybe cause
        extra/lost entries in slow log.
      
      - If we get an duplicate row on insert, change column map to read and
        write all columns while retrying the operation. This is required by
        the definition of REPLACE and also ensures that fields that are only
        part of UPDATE are properly handled.  This fixed a bug in NDB and
        REPLACE where REPLACE wrongly copied some column values from the replaced
        row.
      
      - For table handler that doesn't support NULL in keys, we would give an error
        when creating a primary key with NULL fields, even after the fields has been
        automaticly converted to NOT NULL.
      
      - Creating a primary key on a SPATIAL key, would fail if field was not
        declared as NOT NULL.
      
      
      Cleanups:
      
      - Removed not used condition argument to setup_tables
      
      - Removed not needed item function reset_query_id_processor().
      
      - Field->add_index is removed. Now this is instead maintained in
        (field->flags & FIELD_IN_ADD_INDEX)
      
      - Field->fieldnr is removed (use field->field_index instead)
      
      - New argument to filesort() to indicate that it should return a set of
        row pointers (not used columns). This allowed me to remove some references
        to sql_command in filesort and should also enable us to return column
        results in some cases where we couldn't before.
      
      - Changed column bitmap handling in opt_range.cc to be aligned with TABLE
        bitmap, which allowed me to use bitmap functions instead of looping over
        all fields to create some needed bitmaps. (Faster and smaller code)
      
      - Broke up found too long lines
      
      - Moved some variable declaration at start of function for better code
        readability.
      
      - Removed some not used arguments from functions.
        (setup_fields(), mysql_prepare_insert_check_table())
      
      - setup_fields() now takes an enum instead of an int for marking columns
         usage.
      
      - For internal temporary tables, use handler::write_row(),
        handler::delete_row() and handler::update_row() instead of
        handler::ha_xxxx() for faster execution.
      
      - Changed some constants to enum's and define's.
      
      - Using separate column read and write sets allows for easier checking
        of timestamp field was set by statement.
      
      - Remove calls to free_io_cache() as this is now done automaticly in ha_reset()
      
      - Don't build table->normalized_path as this is now identical to table->path
        (after bar's fixes to convert filenames)
      
      - Fixed some missed DBUG_PRINT(.."%lx") to use "0x%lx" to make it easier to
        do comparision with the 'convert-dbug-for-diff' tool.
      
      
      Things left to do in 5.1:
      
      - We wrongly log failed CREATE TABLE ... SELECT in some cases when using
        row based logging (as shown by testcase binlog_row_mix_innodb_myisam.result)
        Mats has promised to look into this.
      
      - Test that my fix for CREATE TABLE ... SELECT is indeed correct.
        (I added several test cases for this, but in this case it's better that
        someone else also tests this throughly).
        Lars has promosed to do this.
      74cc73d4
  21. 29 May, 2006 1 commit
  22. 28 May, 2006 1 commit
    • serg@sergbook.mysql.com's avatar
      handlerton cleanup: · fe97dbb5
      serg@sergbook.mysql.com authored
      duplicate fields removed, st_mysql_storage_engine added to support
      run-time handlerton initialization (no compiler warnings), handler API
      is now tied to MySQL version, handlerton->plugin mapping added
      (slot-based), dummy default_hton removed, plugin-type-specific
      initialization generalized, built-in plugins are now initialized too,
      --default-storage-engine no longer needs a list of storage engines
      in handle_options().
      
      mysql-test-run.pl bugfixes
      fe97dbb5
  23. 27 May, 2006 2 commits
  24. 26 May, 2006 2 commits
    • mikael@c-870ae253.1238-1-64736c10.cust.bredbandsbolaget.se's avatar
    • gkodinov@mysql.com's avatar
      BUG#18681: View privileges are broken · a21a2b5b
      gkodinov@mysql.com authored
      The check for view security was lacking several points :
      1. Check with the right set of permissions : for each table ref that
      participates in a view there were the right credentials to use in it's
      security_ctx member, but these weren't used for checking the credentials.
      This makes hard enforcing the SQL SECURITY DEFINER|INVOKER property
      consistently.
      2. Because of the above the security checking for views was just ruled out
      in explicit ways in several places.
      3. The security was checked only for the columns of the tables that are
      brought into the query from a view. So if there is no column reference
      outside of the view definition it was not detecting the lack of access to
      the tables in the view in SQL SECURITY INVOKER mode.
      
      The fix below tries to fix the above 3 points.
      a21a2b5b
  25. 24 May, 2006 2 commits
    • monty@mysql.com's avatar
      More DBUG statements · 9e9ca8b6
      monty@mysql.com authored
      Replaced COND_refresh with COND_global_read_lock becasue of a bug in NTPL threads when using different mutexes as arguments to pthread_cond_wait()
      The original code caused a hang in FLUSH TABLES WITH READ LOCK in some circumstances because pthread_cond_broadcast() was not delivered to other threads.
      This fixes:
      Bug#16986: Deadlock condition with MyISAM tables
      Bug#20048: FLUSH TABLES WITH READ LOCK causes a deadlock
      9e9ca8b6
    • monty@mysql.com's avatar
      Remove dflt_field from field structure as this was only needed when createing... · 97b941d9
      monty@mysql.com authored
      Remove dflt_field from field structure as this was only needed when createing temporary table and I found another soultion that doesn't increase the size of the field structure for all table instances. (Better fix for bug #19089)
      Fixed compiler warnings
      Fixed valgrind warning in Item_date_add_intervall::eq. (Recoding of bugfix #19490)
      97b941d9
  26. 22 May, 2006 1 commit
    • andrey@lmy004.'s avatar
      fix for bug #17619 Scheduler race conditions · b429d73d
      andrey@lmy004. authored
      - Scheduler is either initialized at server start or never.
        Starting & stopping is now suspending & resuming.
      - The scheduler has clear OO interface
      - Now all calls to the scheduler are synchronous
      - GLOBAL event_scheduler uses thd::sys_var_tmp (see set_var.cc)
      - External API is encapsulated into class Events
      - Includes fixes for all comments of Kostja's review of 19.05.2005
      
      Starting to merge into 5.1-release (5.1.10) and push
      b429d73d
  27. 18 May, 2006 1 commit
  28. 15 May, 2006 1 commit
  29. 14 May, 2006 1 commit
  30. 12 May, 2006 1 commit
  31. 09 May, 2006 2 commits
    • aelkin@mysql.com's avatar
      BUG#14157: utf8 encoding in binlog without set character_set_client e.g DROP temporary · 226d978a
      aelkin@mysql.com authored
      Binlog lacks encoding info about DROPped temporary table.
      
      Idea of the fix is to switch temporary to system_charset_info when a temporary table
      is DROPped for binlog. Since that is the server, that automatically, but not the client, who generates the query
      the binlog should be updated on the server's encoding for the coming DROP.
      The `write_binlog_with_system_charset()' is introduced to replace similar problematic places in the code.
      226d978a
    • dlenev@mysql.com's avatar
      Fix for bugs#12472/#15137 'CREATE TABLE ... SELECT ... which explicitly · 589daad1
      dlenev@mysql.com authored
      or implicitly uses stored function gives "Table not locked" error'
      
      CREATE TABLE ... SELECT ... statement which was explicitly or implicitly
      (through view) using stored function gave "Table not locked" error.
      
      The actual bug resides in the current locking scheme of CREATE TABLE SELECT
      code, which first opens and locks tables of the SELECT statement itself,
      and then, having SELECT tables locked, creates the .FRM, opens the .FRM and
      acquires lock on it. This scheme opens a possibility for a deadlock, which
      was present and ignored since version 3.23 or earlier. This scheme also
      conflicts with the invariant of the prelocking algorithm -- no table can
      be open and locked while there are tables locked in prelocked mode.
      
      The patch makes an exception for this invariant when doing CREATE TABLE ...
      SELECT, thus extending the possibility of a deadlock to the prelocked mode.
      We can't supply a better fix in 5.0.
      589daad1
  32. 08 May, 2006 1 commit
    • jimw@mysql.com's avatar
      Bug #1039: tmpdir and datadir not available via @@ system variable syntax · ebe38efa
      jimw@mysql.com authored
      Bug #19606: ssl variables are not displayed in show variables
      Bug #19616: log_queries_not_using_indexes  is not listed in show variables
      
        Make basedir, datadir, tmpdir, log_queries_not_using_indexes, ssl_ca,
        ssl_capath, ssl_cert, ssl_cipher, and ssl_key all available both from
        SHOW VARIABLES and as @@variables.
      
        As a side-effect of this change, log_queries_not_using_indexes can
        be changed at runtime (but only globally, not per-connection).
      ebe38efa
  33. 05 May, 2006 2 commits