An error occurred fetching the project authors.
  1. 18 Sep, 2006 1 commit
  2. 15 Sep, 2006 1 commit
  3. 12 Sep, 2006 2 commits
    • svoj@april.(none)'s avatar
      After merge fix. · 8dba18f7
      svoj@april.(none) authored
      8dba18f7
    • svoj@april.(none)'s avatar
      BUG#20256 - LOCK WRITE - MyISAM · 44f167ee
      svoj@april.(none) authored
      Only MyISAM tables locked with LOCK TABLES ... WRITE were affected.
      
      A query that is optimized with index_merge doesn't reflect rows
      inserted within LOCK TABLES.
      
      MyISAM doesn't flush a state within LOCK TABLES. index_merge
      optimization creates a copy of the handler, which thus gets
      outdated MyISAM state.
      
      New handler->clone() method is introduced to fix this problem.
      For non-MyISAM storage engines it allocates a handler and opens
      it with ha_open(). For MyISAM it additionally copies MyISAM state
      pointer to cloned handler.
      44f167ee
  4. 30 Aug, 2006 2 commits
  5. 29 Aug, 2006 1 commit
  6. 25 Aug, 2006 2 commits
  7. 23 Aug, 2006 1 commit
  8. 22 Aug, 2006 1 commit
    • brian@zim.(none)'s avatar
      This changest: · b5187637
      brian@zim.(none) authored
      Plugins now when compiled or not compiled work correctly with status variables. 
      Status variables from plugins now set their own names (removed bit where plugin name was pre-appended this broke Innodb and Cluster)
      A few Makefile cleanups. 
      b5187637
  9. 20 Aug, 2006 1 commit
  10. 19 Aug, 2006 2 commits
  11. 17 Aug, 2006 1 commit
    • andrey@example.com's avatar
      Cleanup patch. · 081b8659
      andrey@example.com authored
      There is an existing macros for initializing LEX_STRINGs
      with constant strings -> C_STRING_WITH_LEN. Change existing code to use it.
      (char *) STRING_WITH_LEN -> C_STRING_WITH_LEN
      081b8659
  12. 10 Aug, 2006 1 commit
  13. 03 Aug, 2006 1 commit
    • petr/cps@mysql.com/owlet.'s avatar
      Fix Bug #18559 "log tables cannot change engine, and · be2ce261
      petr/cps@mysql.com/owlet. authored
                      gets deadlocked when dropping w/ log on"
      
      Log tables rely on concurrent insert machinery to add data.
      This means that log tables are always opened and locked by
      special (artificial) logger threads. Because of this, the thread
      which tries to drop a log table starts to wait for the table
      to be unlocked. Which will happen only if the log table is disabled.
      Alike situation happens if one tries to alter a log table.
      However in addition to the problem above, alter table calls
      check_if_locking_is_allowed() routine for the engine. The
      routine does not allow alter for the log tables. So, alter
      doesn't start waiting forever for logs to be disabled, but 
      returns with an error.
      Another problem is that not all engines could be used for
      the log tables. That's because they need concurrent insert.
      
      In this patch we:
      (1) Explicitly disallow to drop/alter a log table if it
          is currently used by the logger.
      (2) Update MyISAM to support log tables
      (3) Allow to drop log tables/alter log tables if log is
          disabled
      At the same time we (4) Disallow to alter log tables to
      unsupported engine (after this patch CSV and MyISAM are 
      alowed)
      Recommit with review fixes.
      be2ce261
  14. 21 Jul, 2006 1 commit
  15. 20 Jul, 2006 1 commit
  16. 14 Jul, 2006 1 commit
  17. 12 Jul, 2006 1 commit
  18. 10 Jul, 2006 1 commit
    • guilhem@gbichot3.local's avatar
      fixes after merge. Updates to test's results. · 1cc3c800
      guilhem@gbichot3.local authored
      We now reset the THD members related to auto_increment+binlog in
      MYSQL_LOG::write(). This is better than in THD::cleanup_after_query(),
      which was not able to distinguish between SELECT myfunc1(),myfunc2()
      and INSERT INTO t SELECT myfunc1(),myfunc2() from a binlogging point
      of view.
      Rows_log_event::exec_event() now calls lex_start() instead of
      mysql_init_query() because the latter now does too much (it resets
      the binlog format).
      1cc3c800
  19. 09 Jul, 2006 1 commit
    • guilhem@gbichot3.local's avatar
      WL#3146 "less locking in auto_increment": · 0594e1b8
      guilhem@gbichot3.local authored
      this is a cleanup patch for our current auto_increment handling:
      new names for auto_increment variables in THD, new methods to manipulate them
      (see sql_class.h), some move into handler::, causing less backup/restore
      work when executing substatements. 
      This makes the logic hopefully clearer, less work is is needed in
      mysql_insert().
      By cleaning up, using different variables for different purposes (instead
      of one for 3 things...), we fix those bugs, which someone may want to fix
      in 5.0 too:
      BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
      statement-based"
      BUG#20341 "stored function inserting into one auto_increment puts bad
      data in slave"
      BUG#19243 "wrong LAST_INSERT_ID() after ON DUPLICATE KEY UPDATE"
      (now if a row is updated, LAST_INSERT_ID() will return its id)
      and re-fixes:
      BUG#6880 "LAST_INSERT_ID() value changes during multi-row INSERT"
      (already fixed differently by Ramil in 4.1)
      Test of documented behaviour of mysql_insert_id() (there was no test).
      The behaviour changes introduced are:
      - LAST_INSERT_ID() now returns "the first autogenerated auto_increment value
      successfully inserted", instead of "the first autogenerated auto_increment
      value if any row was successfully inserted", see auto_increment.test.
      Same for mysql_insert_id(), see mysql_client_test.c.
      - LAST_INSERT_ID() returns the id of the updated row if ON DUPLICATE KEY
      UPDATE, see auto_increment.test. Same for mysql_insert_id(), see
      mysql_client_test.c.
      - LAST_INSERT_ID() does not change if no autogenerated value was successfully 
      inserted (it used to then be 0), see auto_increment.test.
      - if in INSERT SELECT no autogenerated value was successfully inserted,
      mysql_insert_id() now returns the id of the last inserted row (it already
      did this for INSERT VALUES), see mysql_client_test.c.
      - if INSERT SELECT uses LAST_INSERT_ID(X), mysql_insert_id() now returns X
      (it already did this for INSERT VALUES), see mysql_client_test.c.
      - NDB now behaves like other engines wrt SET INSERT_ID: with INSERT IGNORE,
      the id passed in SET INSERT_ID is re-used until a row succeeds; SET INSERT_ID
      influences not only the first row now.
      
      Additionally, when unlocking a table we check that the thread is not keeping
      a next_insert_id (as the table is unlocked that id is potentially out-of-date);
      forgetting about this next_insert_id is done in a new
      handler::ha_release_auto_increment().
      
      Finally we prepare for engines capable of reserving finite-length intervals
      of auto_increment values: we store such intervals in THD. The next step
      (to be done by the replication team in 5.1) is to read those intervals from
      THD and actually store them in the statement-based binary log. NDB
      will be a good engine to test that.
      0594e1b8
  20. 06 Jul, 2006 1 commit
    • guilhem@mysql.com's avatar
      Fix for BUG#20524 "auto_increment_* not observed when inserting · 140b488c
      guilhem@mysql.com authored
      a too large value": the bug was that if MySQL generated a value for an
      auto_increment column, based on auto_increment_* variables, and this value
      was bigger than the column's max possible value, then that max possible
      value was inserted (after issuing a warning). But this didn't honour
      auto_increment_* variables (and so could cause conflicts in a master-master
      replication where one master is supposed to generated only even numbers,
      and the other only odd numbers), so now we "round down" this max possible
      value to honour auto_increment_* variables, before inserting it.
      140b488c
  21. 05 Jul, 2006 1 commit
    • guilhem@mysql.com's avatar
      Fix for BUG#20188 "REPLACE or ON DUPLICATE KEY UPDATE in · a43c4b02
      guilhem@mysql.com authored
      auto_increment breaks binlog":
      if slave's table had a higher auto_increment counter than master's (even
      though all rows of the two tables were identical), then in some cases,
      REPLACE and INSERT ON DUPLICATE KEY UPDATE failed to replicate
      statement-based (it inserted different values on slave from on master).
      write_record() contained a "thd->next_insert_id=0" to force an adjustment
      of thd->next_insert_id after the update or replacement. But it is this
      assigment introduced indeterminism of the statement on the slave, thus
      the bug. For ON DUPLICATE, we replace that assignment by a call to
      handler::adjust_next_insert_id_after_explicit_value() which is deterministic
      (does not depend on slave table's autoinc counter). For REPLACE, this
      assignment can simply be removed (as REPLACE can't insert a number larger
      than thd->next_insert_id).
      We also move a too early restore_auto_increment() down to when we really know
      that we can restore the value.
      a43c4b02
  22. 23 Jun, 2006 1 commit
  23. 22 Jun, 2006 3 commits
  24. 16 Jun, 2006 1 commit
  25. 15 Jun, 2006 1 commit
  26. 12 Jun, 2006 1 commit
    • acurtis@xiphis.org's avatar
      Bug#20168 · 62729fcd
      acurtis@xiphis.org authored
        "Change in behavior --default-storage-engine=ndb or ndbcluster"
        Reduce use of legacy_db_type, some code cleanup
        (serg read my mind and implemented desired mysqld.cc changes)
      62729fcd
  27. 06 Jun, 2006 1 commit
  28. 05 Jun, 2006 1 commit
  29. 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
  30. 02 Jun, 2006 2 commits
  31. 01 Jun, 2006 1 commit
  32. 31 May, 2006 2 commits